From 5b7bad420fb803320e7504618e1a2f1ee694942f Mon Sep 17 00:00:00 2001
From: Barret Schloerke <barret@posit.co>
Date: Thu, 22 Oct 2026 16:05:53 -0400
Subject: [PATCH 1/2] feat(reactlog_widget): Add an htmlwidget for the reactlog
 (#160)

reactlog_widget() inlines the reactlog page and shows it in an iframe,
so it can be embedded in R Markdown or Quarto. Like reactlog_show(),
log defaults to shiny::reactlog(). htmlwidgets is a suggested package,
checked at run time with rlang::check_installed().
---
 DESCRIPTION                  |  2 +
 NAMESPACE                    |  1 +
 NEWS.md                      |  2 +
 R/renderReactLog.R           | 55 +++++++++++----------
 R/widget.R                   | 93 ++++++++++++++++++++++++++++++++++++
 inst/htmlwidgets/reactlog.js | 18 +++++++
 man/reactlog_widget.Rd       | 53 ++++++++++++++++++++
 tests/testthat/test-render.R | 18 +++++++
 8 files changed, 217 insertions(+), 25 deletions(-)
 create mode 100644 R/widget.R
 create mode 100644 inst/htmlwidgets/reactlog.js
 create mode 100644 man/reactlog_widget.Rd

diff --git a/DESCRIPTION b/DESCRIPTION
index e0df144..13a11ed 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -23,10 +23,12 @@ Depends:
     R (>= 3.0.2)
 Imports:
     jsonlite (>= 0.9.16),
+    rlang,
     rmarkdown
 Suggests:
     fontawesome (>= 0.3.0),
     htmltools,
+    htmlwidgets,
     knitr,
     shiny (>= 1.5.0),
     testthat
diff --git a/NAMESPACE b/NAMESPACE
index c4f8636..321f44f 100644
--- a/NAMESPACE
+++ b/NAMESPACE
@@ -6,4 +6,5 @@ export(reactlog_module_server)
 export(reactlog_module_ui)
 export(reactlog_render)
 export(reactlog_show)
+export(reactlog_widget)
 export(reactlog_write)
diff --git a/NEWS.md b/NEWS.md
index 8996ec4..f134359 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -1,5 +1,7 @@
 # reactlog (development)
 
+- Added `reactlog_widget()`, which shows the reactlog as an htmlwidget so it can be embedded in R Markdown or Quarto documents. Like `reactlog_show()`, `log` defaults to `shiny::reactlog()`. Requires the htmlwidgets package (#160)
+
 - `reactlog_show()` now uses `shiny::reactlog()` as its default `log`, so `reactlog_show()` works with no arguments after running an app (#91)
 
 - The graph legend now shows that a solid line is a dependency, a dashed line is an `isolate()`d dependency, and a dotted line is an inactive dependency (one that existed earlier but is not active at the current step) (#76)
diff --git a/R/renderReactLog.R b/R/renderReactLog.R
index 2502bf2..f19c043 100644
--- a/R/renderReactLog.R
+++ b/R/renderReactLog.R
@@ -11,31 +11,7 @@ inst_reactlog_assets <- function() {
 #' @param session_token token to be used to subset which session is displayed.
 #'   Defaults to all sessions.
 reactlog_render <- function(log, session_token = NULL, time = TRUE) {
-  log <- reactlog_upgrade(log)
-
-  template_file <- inst_reactlog_file("reactlog.html")
-  # does not need utf8 support
-  html <- paste(readLines(template_file, warn = FALSE), collapse = "\n")
-
-  # get the json form of the lgo without writing to disk
-  json_blob <- as.character(
-    reactlog_write(log, file = NULL, session_token = session_token)
-  )
-
-  fixed_sub <- function(...) {
-    sub(..., fixed = TRUE)
-  }
-
-  html <- fixed_sub(
-    "__DATA__", paste(json_blob, collapse = "\n"),
-    fixed_sub(
-      "__TIME__", paste0("\"", time, "\""),
-      fixed_sub(
-        "<script src=\"defaultLog.js\"></script>", "",
-        html
-      )
-    )
-  )
+  html <- reactlog_page_html(log, session_token = session_token, time = time)
 
   # check if shiny is even available
   if (requireNamespace("shiny", quietly = TRUE)) {
@@ -60,3 +36,32 @@ reactlog_render <- function(log, session_token = NULL, time = TRUE) {
 
   file
 }
+
+fixed_sub <- function(...) {
+  sub(..., fixed = TRUE)
+}
+
+# The reactlog page as one string. Assets are still linked from `reactlogAsset/`.
+reactlog_page_html <- function(log, session_token = NULL, time = TRUE) {
+  log <- reactlog_upgrade(log)
+
+  template_file <- inst_reactlog_file("reactlog.html")
+  # does not need utf8 support
+  html <- paste(readLines(template_file, warn = FALSE), collapse = "\n")
+
+  # get the json form of the lgo without writing to disk
+  json_blob <- as.character(
+    reactlog_write(log, file = NULL, session_token = session_token)
+  )
+
+  fixed_sub(
+    "__DATA__", paste(json_blob, collapse = "\n"),
+    fixed_sub(
+      "__TIME__", paste0("\"", time, "\""),
+      fixed_sub(
+        "<script src=\"defaultLog.js\"></script>", "",
+        html
+      )
+    )
+  )
+}
diff --git a/R/widget.R b/R/widget.R
new file mode 100644
index 0000000..f4bb5cd
--- /dev/null
+++ b/R/widget.R
@@ -0,0 +1,93 @@
+#' Reactlog htmlwidget
+#'
+#' Displays the reactlog as an \pkg{htmlwidgets} widget, so it can be embedded
+#' in R Markdown or Quarto documents, or shown in the RStudio viewer.
+#'
+#' The widget is a self-contained page shown in an `<iframe>`. Requires the
+#' \pkg{htmlwidgets} package.
+#'
+#' @inheritParams reactlog_show
+#' @param width,height Size of the widget. Defaults to `"100%"` wide and
+#'   `600` pixels tall.
+#' @param elementId Optional element id for the widget.
+#' @seealso [reactlog_show()]
+#' @export
+#' @examples
+#' \dontrun{
+#' library(shiny)
+#' reactlog_enable()
+#'
+#' # run a shiny app
+#' app <- system.file("examples/01_hello", package = "shiny")
+#' runApp(app)
+#'
+#' # once app has closed, display reactlog as a widget
+#' reactlog_widget()
+#' }
+reactlog_widget <- function(
+  log = shiny::reactlog(),
+  time = TRUE,
+  ...,
+  width = NULL,
+  height = NULL,
+  elementId = NULL # nolint: object_name_linter.
+) {
+  rlang::check_installed("htmlwidgets")
+
+  html <- reactlog_page_html(log, time = as.logical(time), ...)
+
+  htmlwidgets::createWidget(
+    name = "reactlog",
+    x = list(html = reactlog_inline_assets(html)),
+    width = width,
+    height = height,
+    package = "reactlog",
+    elementId = elementId,
+    sizingPolicy = htmlwidgets::sizingPolicy(
+      defaultWidth = "100%",
+      defaultHeight = 600,
+      knitr.figure = FALSE
+    )
+  )
+}
+
+# Put the css, js, and images into the page so it works from an iframe `srcdoc`
+reactlog_inline_assets <- function(html) {
+  asset_dir <- inst_reactlog_assets()
+  read_asset <- function(file) {
+    paste(readLines(file.path(asset_dir, file), warn = FALSE), collapse = "\n")
+  }
+  svg_uri <- function(file) {
+    path <- file.path(asset_dir, "images", file)
+    paste0(
+      "data:image/svg+xml;base64,",
+      # base64_enc() adds line breaks, which break css `url("...")`
+      gsub("\n", "", jsonlite::base64_enc(readBin(path, "raw", file.size(path))), fixed = TRUE)
+    )
+  }
+
+  for (css in c("fira-mono_source-sans-pro_latin-ext.css", "reactlog.css")) {
+    content <- fixed_sub(
+      "url(\"images/iconSearch.svg\")",
+      paste0("url(\"", svg_uri("iconSearch.svg"), "\")"),
+      read_asset(css)
+    )
+    html <- fixed_sub(
+      paste0("<link rel=\"stylesheet\" type=\"text/css\" href=\"reactlogAsset/", css, "\">"),
+      paste0("<style>", content, "</style>"),
+      html
+    )
+  }
+
+  html <- fixed_sub(
+    "<script src=\"reactlogAsset/reactlog.js\"></script>",
+    paste0("<script>", read_asset("reactlog.js"), "</script>"),
+    html
+  )
+
+  for (svg in dir(file.path(asset_dir, "images"))) {
+    html <- gsub(paste0("./reactlogAsset/images/", svg), svg_uri(svg), html, fixed = TRUE)
+  }
+
+  html
+}
diff --git a/inst/htmlwidgets/reactlog.js b/inst/htmlwidgets/reactlog.js
new file mode 100644
index 0000000..e8089fc
--- /dev/null
+++ b/inst/htmlwidgets/reactlog.js
@@ -0,0 +1,18 @@
+HTMLWidgets.widget({
+  name: "reactlog",
+  type: "output",
+  factory: function (el) {
+    var iframe = document.createElement("iframe");
+    iframe.style.width = "100%";
+    iframe.style.height = "100%";
+    iframe.style.border = "none";
+    el.appendChild(iframe);
+
+    return {
+      renderValue: function (x) {
+        iframe.srcdoc = x.html;
+      },
+      resize: function () {},
+    };
+  },
+});
diff --git a/man/reactlog_widget.Rd b/man/reactlog_widget.Rd
new file mode 100644
index 0000000..c2d658d
--- /dev/null
+++ b/man/reactlog_widget.Rd
@@ -0,0 +1,53 @@
+% Generated by roxygen2: do not edit by hand
+% Please edit documentation in R/widget.R
+\name{reactlog_widget}
+\alias{reactlog_widget}
+\title{Reactlog htmlwidget}
+\usage{
+reactlog_widget(
+  log = shiny::reactlog(),
+  time = TRUE,
+  ...,
+  width = NULL,
+  height = NULL,
+  elementId = NULL
+)
+}
+\arguments{
+\item{log}{Log produced by shiny to be processed. Defaults to
+\code{\link[shiny:reactlog]{shiny::reactlog()}}, the log recorded in the current R session.}
+
+\item{time}{A boolean that specifies whether or not to display the
+time that each reactive takes to calculate a result.}
+
+\item{...}{Arguments passed on to \code{reactlog_render()}, such as \code{session_token}.}
+
+\item{width, height}{Size of the widget. Defaults to \code{"100\%"} wide and
+\code{600} pixels tall.}
+
+\item{elementId}{Optional element id for the widget.}
+}
+\description{
+Displays the reactlog as an \pkg{htmlwidgets} widget, so it can be embedded
+in R Markdown or Quarto documents, or shown in the RStudio viewer.
+}
+\details{
+The widget is a self-contained page shown in an \verb{<iframe>}. Requires the
+\pkg{htmlwidgets} package.
+}
+\examples{
+\dontrun{
+library(shiny)
+reactlog_enable()
+
+# run a shiny app
+app <- system.file("examples/01_hello", package = "shiny")
+runApp(app)
+
+# once app has closed, display reactlog as a widget
+reactlog_widget()
+}
+}
+\seealso{
+\code{\link[=reactlog_show]{reactlog_show()}}
+}
diff --git a/tests/testthat/test-render.R b/tests/testthat/test-render.R
index a0fc4e0..dfb6c35 100644
--- a/tests/testthat/test-render.R
+++ b/tests/testthat/test-render.R
@@ -32,3 +32,21 @@ test_that("reactlog_show() defaults to shiny::reactlog()", {
   reactlog_show()
   expect_true(called)
 })
+
+test_that("reactlog_widget() inlines the page and defaults to shiny::reactlog()", {
+  skip_if_not_installed("shiny")
+  skip_if_not_installed("htmlwidgets")
+  local_mocked_bindings(
+    reactlog = function() structure(list(), version = "1"),
+    .package = "shiny"
+  )
+  w <- reactlog_widget()
+  expect_s3_class(w, "htmlwidget")
+  expect_no_error(htmltools::renderTags(w))
+  html <- w$x$html
+  expect_false(grepl("reactlogAsset/", html, fixed = TRUE))
+  expect_false(grepl("images/iconSearch.svg", html, fixed = TRUE))
+  expect_true(grepl("data:image/svg+xml;base64,", html, fixed = TRUE))
+  # no line breaks inside the base64 data uris
+  expect_false(grepl("base64,[A-Za-z0-9+/=]*\n", html))
+})

From 020c6edf015b1cdf9642e48cfff1e4c9bf87920a Mon Sep 17 00:00:00 2001
From: Barret Schloerke <barret@posit.co>
Date: Thu, 22 Oct 2026 16:19:23 -0400
Subject: [PATCH 2/2] feat(reactlog_widget): Add Shiny bindings, a widget
 module, and shinytest2 tests

Add reactlog_widget_output() and render_reactlog_widget(), plus
reactlog_widget_module_ui() and reactlog_widget_module_server(), which
show the widget with a refresh button. Add shinytest2 tests that check
the iframe module, the render function, and the widget module load new
log entries after a refresh.
---
 DESCRIPTION                        |  4 +-
 NAMESPACE                          |  4 ++
 NEWS.md                            |  2 +-
 R/shinyModule.R                    | 77 +++++++++++++++++++++++++++---
 R/widget.R                         | 50 +++++++++++++++++++
 man/reactlog_widget_module.Rd      | 51 ++++++++++++++++++++
 man/reactlog_widget_output.Rd      | 52 ++++++++++++++++++++
 tests/testthat/apps/reactlog/app.R | 30 ++++++++++++
 tests/testthat/test-app.R          | 52 ++++++++++++++++++++
 9 files changed, 313 insertions(+), 9 deletions(-)
 create mode 100644 man/reactlog_widget_module.Rd
 create mode 100644 man/reactlog_widget_output.Rd
 create mode 100644 tests/testthat/apps/reactlog/app.R
 create mode 100644 tests/testthat/test-app.R

diff --git a/DESCRIPTION b/DESCRIPTION
index 13a11ed..4785036 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -31,7 +31,9 @@ Suggests:
     htmlwidgets,
     knitr,
     shiny (>= 1.5.0),
-    testthat
+    shinytest2,
+    testthat,
+    withr
 VignetteBuilder: 
     knitr
 Config/roxygen2/version: 8.1.1
diff --git a/NAMESPACE b/NAMESPACE
index 321f44f..73cb3d6 100644
--- a/NAMESPACE
+++ b/NAMESPACE
@@ -7,4 +7,8 @@ export(reactlog_module_ui)
 export(reactlog_render)
 export(reactlog_show)
 export(reactlog_widget)
+export(reactlog_widget_module_server)
+export(reactlog_widget_module_ui)
+export(reactlog_widget_output)
 export(reactlog_write)
+export(render_reactlog_widget)
diff --git a/NEWS.md b/NEWS.md
index f134359..05f4605 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -1,6 +1,6 @@
 # reactlog (development)
 
-- Added `reactlog_widget()`, which shows the reactlog as an htmlwidget so it can be embedded in R Markdown or Quarto documents. Like `reactlog_show()`, `log` defaults to `shiny::reactlog()`. Requires the htmlwidgets package (#160)
+- Added `reactlog_widget()`, which shows the reactlog as an htmlwidget so it can be embedded in R Markdown or Quarto documents. Like `reactlog_show()`, `log` defaults to `shiny::reactlog()`. To show it in a Shiny app, use `reactlog_widget_module_ui()` and `reactlog_widget_module_server()`, or `reactlog_widget_output()` and `render_reactlog_widget()`. Requires the htmlwidgets package (#160)
 
 - `reactlog_show()` now uses `shiny::reactlog()` as its default `log`, so `reactlog_show()` works with no arguments after running an app (#91)
 
diff --git a/R/shinyModule.R b/R/shinyModule.R
index bd58411..42b57fa 100644
--- a/R/shinyModule.R
+++ b/R/shinyModule.R
@@ -55,17 +55,20 @@
 reactlog_module_ui <- function(include_refresh = TRUE, id = "reactlog_module") {
   ns <- shiny::NS(id)
   shiny::tagList(
-    if (isTRUE(include_refresh))
-      shiny::actionButton(
-        ns("refresh"),
-        "",
-        icon = shiny::icon("arrows-rotate", lib = "font-awesome"),
-        class = "btn-sm btn-warning"
-      ),
+    if (isTRUE(include_refresh)) refresh_button(ns),
     shiny::uiOutput(ns("iframe"))
   )
 }
 
+refresh_button <- function(ns) {
+  shiny::actionButton(
+    ns("refresh"),
+    "",
+    icon = shiny::icon("arrows-rotate", lib = "font-awesome"),
+    class = "btn-sm btn-warning"
+  )
+}
+
 #' @rdname reactlog_module
 #' @export
 reactlog_module_server <- function(
@@ -146,3 +149,63 @@ assert_shiny_version <- function() {
     stop("`shiny` v", shiny_version_required(), " or greater must be installed")
   }
 }
+
+
+#' Reactlog widget Shiny module
+#'
+#' Displays a [reactlog_widget()] in the given application, filtered to the
+#' current session. Unlike [reactlog_module_ui()], the log is sent through
+#' Shiny's websocket, so it does not need the `reactlog` URL that Shiny serves.
+#'
+#' The log is read when the widget renders. Click the refresh button to show
+#' newer entries. The first render runs before Shiny is idle for the first
+#' time, so it may not show a complete step until refreshed.
+#'
+#' @inheritParams reactlog_module_ui
+#' @param width,height Size of the widget. Must be a valid CSS unit or a number.
+#' @seealso [reactlog_widget_output()]
+#' @rdname reactlog_widget_module
+#' @export
+#' @examples
+#' if (interactive()) {
+#'   library(shiny)
+#'   reactlog_enable()
+#'
+#'   ui <- fluidPage(
+#'     numericInput("n", "n", 1),
+#'     reactlog_widget_module_ui()
+#'   )
+#'   server <- function(input, output, session) {
+#'     reactlog_widget_module_server()
+#'   }
+#'   shinyApp(ui, server)
+#' }
+reactlog_widget_module_ui <- function(
+  include_refresh = TRUE,
+  id = "reactlog_widget_module",
+  width = "100%",
+  height = "600px"
+) {
+  ns <- shiny::NS(id)
+  shiny::tagList(
+    if (isTRUE(include_refresh)) refresh_button(ns),
+    reactlog_widget_output(ns("widget"), width = width, height = height)
+  )
+}
+
+#' @rdname reactlog_widget_module
+#' @export
+reactlog_widget_module_server <- function(id = "reactlog_widget_module") {
+  assert_shiny_version()
+
+  shiny::moduleServer(
+    id,
+    function(input, output, session) {
+      output$widget <- render_reactlog_widget({
+        # trigger render refresh
+        input$refresh
+        reactlog_widget(session_token = session$token)
+      })
+    }
+  )
+}
diff --git a/R/widget.R b/R/widget.R
index f4bb5cd..d8b9033 100644
--- a/R/widget.R
+++ b/R/widget.R
@@ -51,6 +51,56 @@ reactlog_widget <- function(
   )
 }
 
+#' Shiny bindings for `reactlog_widget()`
+#'
+#' Output and render functions for using [reactlog_widget()] within Shiny
+#' applications. The log is read when `expr` runs, so make `expr` depend on an
+#' input (such as a refresh button) to show newer entries.
+#'
+#' The first render runs before Shiny is idle for the first time, so it may not
+#' show a complete step. Refresh to load the full log.
+#'
+#' @param output_id Output variable to read from.
+#' @param width,height Must be a valid CSS unit (like `"100%"`, `"400px"`,
+#'   `"auto"`) or a number, which will be coerced to a string and have `"px"`
+#'   appended.
+#' @param expr An expression that returns a [reactlog_widget()].
+#' @param env The environment in which to evaluate `expr`.
+#' @param quoted Is `expr` a quoted expression (with `quote()`)?
+#' @export
+#' @examples
+#' if (interactive()) {
+#'   library(shiny)
+#'   reactlog_enable()
+#'
+#'   ui <- fluidPage(
+#'     numericInput("n", "n", 1),
+#'     actionButton("refresh", "Refresh"),
+#'     reactlog_widget_output("reactlog")
+#'   )
+#'   server <- function(input, output, session) {
+#'     output$reactlog <- render_reactlog_widget({
+#'       input$refresh
+#'       reactlog_widget(session_token = session$token)
+#'     })
+#'   }
+#'   shinyApp(ui, server)
+#' }
+reactlog_widget_output <- function(output_id, width = "100%", height = "600px") {
+  rlang::check_installed("htmlwidgets")
+  htmlwidgets::shinyWidgetOutput(output_id, "reactlog", width, height, package = "reactlog")
+}
+
+#' @rdname reactlog_widget_output
+#' @export
+render_reactlog_widget <- function(expr, env = parent.frame(), quoted = FALSE) {
+  rlang::check_installed("htmlwidgets")
+  if (!quoted) {
+    expr <- substitute(expr)
+  }
+  htmlwidgets::shinyRenderWidget(expr, reactlog_widget_output, env, quoted = TRUE)
+}
+
 # Put the css, js, and images into the page so it works from an iframe `srcdoc`
 reactlog_inline_assets <- function(html) {
   asset_dir <- inst_reactlog_assets()
diff --git a/man/reactlog_widget_module.Rd b/man/reactlog_widget_module.Rd
new file mode 100644
index 0000000..8c1e9af
--- /dev/null
+++ b/man/reactlog_widget_module.Rd
@@ -0,0 +1,51 @@
+% Generated by roxygen2: do not edit by hand
+% Please edit documentation in R/shinyModule.R
+\name{reactlog_widget_module_ui}
+\alias{reactlog_widget_module_ui}
+\alias{reactlog_widget_module_server}
+\title{Reactlog widget Shiny module}
+\usage{
+reactlog_widget_module_ui(
+  include_refresh = TRUE,
+  id = "reactlog_widget_module",
+  width = "100\%",
+  height = "600px"
+)
+
+reactlog_widget_module_server(id = "reactlog_widget_module")
+}
+\arguments{
+\item{include_refresh}{should the iframe refresh button be included?}
+
+\item{id}{\pkg{shiny} module id to use}
+
+\item{width, height}{Size of the widget. Must be a valid CSS unit or a number.}
+}
+\description{
+Displays a \code{\link[=reactlog_widget]{reactlog_widget()}} in the given application, filtered to the
+current session. Unlike \code{\link[=reactlog_module_ui]{reactlog_module_ui()}}, the log is sent through
+Shiny's websocket, so it does not need the \code{reactlog} URL that Shiny serves.
+}
+\details{
+The log is read when the widget renders. Click the refresh button to show
+newer entries. The first render runs before Shiny is idle for the first
+time, so it may not show a complete step until refreshed.
+}
+\examples{
+if (interactive()) {
+  library(shiny)
+  reactlog_enable()
+
+  ui <- fluidPage(
+    numericInput("n", "n", 1),
+    reactlog_widget_module_ui()
+  )
+  server <- function(input, output, session) {
+    reactlog_widget_module_server()
+  }
+  shinyApp(ui, server)
+}
+}
+\seealso{
+\code{\link[=reactlog_widget_output]{reactlog_widget_output()}}
+}
diff --git a/man/reactlog_widget_output.Rd b/man/reactlog_widget_output.Rd
new file mode 100644
index 0000000..ff19044
--- /dev/null
+++ b/man/reactlog_widget_output.Rd
@@ -0,0 +1,52 @@
+% Generated by roxygen2: do not edit by hand
+% Please edit documentation in R/widget.R
+\name{reactlog_widget_output}
+\alias{reactlog_widget_output}
+\alias{render_reactlog_widget}
+\title{Shiny bindings for \code{reactlog_widget()}}
+\usage{
+reactlog_widget_output(output_id, width = "100\%", height = "600px")
+
+render_reactlog_widget(expr, env = parent.frame(), quoted = FALSE)
+}
+\arguments{
+\item{output_id}{Output variable to read from.}
+
+\item{width, height}{Must be a valid CSS unit (like \code{"100\%"}, \code{"400px"},
+\code{"auto"}) or a number, which will be coerced to a string and have \code{"px"}
+appended.}
+
+\item{expr}{An expression that returns a \code{\link[=reactlog_widget]{reactlog_widget()}}.}
+
+\item{env}{The environment in which to evaluate \code{expr}.}
+
+\item{quoted}{Is \code{expr} a quoted expression (with \code{quote()})?}
+}
+\description{
+Output and render functions for using \code{\link[=reactlog_widget]{reactlog_widget()}} within Shiny
+applications. The log is read when \code{expr} runs, so make \code{expr} depend on an
+input (such as a refresh button) to show newer entries.
+}
+\details{
+The first render runs before Shiny is idle for the first time, so it may not
+show a complete step. Refresh to load the full log.
+}
+\examples{
+if (interactive()) {
+  library(shiny)
+  reactlog_enable()
+
+  ui <- fluidPage(
+    numericInput("n", "n", 1),
+    actionButton("refresh", "Refresh"),
+    reactlog_widget_output("reactlog")
+  )
+  server <- function(input, output, session) {
+    output$reactlog <- render_reactlog_widget({
+      input$refresh
+      reactlog_widget(session_token = session$token)
+    })
+  }
+  shinyApp(ui, server)
+}
+}
diff --git a/tests/testthat/apps/reactlog/app.R b/tests/testthat/apps/reactlog/app.R
new file mode 100644
index 0000000..e7f48b4
--- /dev/null
+++ b/tests/testthat/apps/reactlog/app.R
@@ -0,0 +1,30 @@
+library(shiny)
+library(reactlog)
+
+reactlog_enable()
+
+ui <- fluidPage(
+  numericInput("a", "A", 3),
+  numericInput("b", "B", 4),
+  verbatimTextOutput("c"),
+  reactlog_module_ui(),
+  reactlog_widget_module_ui(),
+  actionButton("refresh_widget", "Refresh widget"),
+  reactlog_widget_output("widget")
+)
+
+server <- function(input, output, session) {
+  a2 <- reactive(input$a * input$a, label = "a^2")
+  b2 <- reactive(input$b * input$b, label = "b^2")
+  output$c <- renderText(sqrt(a2() + b2()))
+
+  reactlog_module_server()
+  reactlog_widget_module_server()
+
+  output$widget <- render_reactlog_widget({
+    input$refresh_widget
+    reactlog_widget(session_token = session$token)
+  })
+}
+
+shinyApp(ui, server)
diff --git a/tests/testthat/test-app.R b/tests/testthat/test-app.R
new file mode 100644
index 0000000..e41bb38
--- /dev/null
+++ b/tests/testthat/test-app.R
@@ -0,0 +1,52 @@
+module_iframe <- "document.querySelector('iframe[id^=\"reactlog_module-reactlog_iframe_\"]')"
+widget_iframe <- "document.querySelector('#widget iframe')"
+widget_module_iframe <- "document.querySelector('#reactlog_widget_module-widget iframe')"
+
+# Number of log entries loaded in the reactlog inside `iframe`, or -1 if not loaded yet
+log_length_js <- function(iframe) {
+  paste0("(function() {
+    var frame = ", iframe, ";
+    var win = frame && frame.contentWindow;
+    var step = win && win.document.querySelector('#eventStepNum');
+    if (!win || !win.log || !step || step.textContent.trim() === '') return -1;
+    return win.log.length;
+  })()")
+}
+
+expect_log_grows <- function(app, iframe, refresh_id) {
+  app$wait_for_js(paste0(log_length_js(iframe), " > 0"))
+  n <- app$get_js(log_length_js(iframe))
+
+  app$set_inputs(a = 5)
+  app$click(refresh_id)
+  app$wait_for_js(paste0(log_length_js(iframe), " > ", n))
+
+  expect_gt(app$get_js(log_length_js(iframe)), n)
+}
+
+local_app <- function(env = parent.frame()) {
+  skip_on_cran()
+  skip_if_not_installed("shinytest2")
+  skip_if_not_installed("htmlwidgets")
+  app <- shinytest2::AppDriver$new(test_path("apps/reactlog"), name = "reactlog")
+  withr::defer(app$stop(), envir = env)
+  app
+}
+
+test_that("module iframe shows the log and its refresh button loads new entries", {
+  app <- local_app()
+  expect_log_grows(app, module_iframe, "reactlog_module-refresh")
+})
+
+test_that("render_reactlog_widget() shows the log and re-renders with new entries", {
+  app <- local_app()
+  # The first render happens before shiny's first idle, so refresh once to load a full log
+  app$click("refresh_widget")
+  expect_log_grows(app, widget_iframe, "refresh_widget")
+})
+
+test_that("widget module shows the log and its refresh button loads new entries", {
+  app <- local_app()
+  app$click("reactlog_widget_module-refresh")
+  expect_log_grows(app, widget_module_iframe, "reactlog_widget_module-refresh")
+})