Fix DuckDB-WASM client mode in Shiny apps

In Shiny, htmlDependency scripts are dynamically inserted via
document.createElement(), so document.currentScript is null. This broke
WASM/worker path detection and Parquet URL resolution.

Fixes:
- Add duckdb-locator.js as a separate script that runs before the webpack
  bundle, with querySelector fallback for when currentScript is null
- Add runtime querySelector fallback in Reactable.js useEffect for both
  wasmBasePath and parquetUrl resolution (DOM is populated by then)
- Fix Parquet locator script to also use querySelector fallback
- Suppress false positive preRenderHook warning when user explicitly
  sets mode='client' (only warn for auto-resolved client mode)

Test updates:
- Add R test verifying backendDuckDB(mode='client') skips preRenderHook
- Add Shiny test apps for Arrow IPC and Parquet in client mode
- Update server-side-data plan doc with completed selection and client
  mode work

Author: glin

R/reactable.R

@@ -719,8 +719,10 @@ reactable <- function(
 
   # Resolve backend mode: "auto" detects Shiny vs static, then route to client or server path
   isDuckDBClientMode <- FALSE
+  isDuckDBClientModeExplicit <- FALSE
   isServerMode <- FALSE
   if (isDuckDBBackend(backend)) {
+    isDuckDBClientModeExplicit <- identical(backend$mode, "client")
     resolvedMode <- resolveDuckDBMode(backend)
     if (resolvedMode == "server") {
       # Route DuckDB server mode through the server infrastructure
@@ -921,19 +923,22 @@ reactable <- function(
     # Warn if this widget ends up being rendered in a Shiny session, since DuckDB-WASM
     # (client mode) was selected because no Shiny session was detected at reactable() call time.
     # This happens when reactable() is called at the top level of a Shiny app script.
-    preRenderHook <- function(instance) {
-      session <- if (requireNamespace("shiny", quietly = TRUE)) {
-        shiny::getDefaultReactiveDomain()
-      }
-      if (!is.null(session)) {
-        warning(
-          "`backendDuckDB()` was configured for client-side mode because `reactable()` was called ",
-          "outside of a Shiny render function. Move the `reactable()` call inside `renderReactable()` ",
-          "so the backend can detect the Shiny session and use server mode.",
-          call. = FALSE
-        )
+    # Don't warn if the user explicitly set mode = "client".
+    if (!isDuckDBClientModeExplicit) {
+      preRenderHook <- function(instance) {
+        session <- if (requireNamespace("shiny", quietly = TRUE)) {
+          shiny::getDefaultReactiveDomain()
+        }
+        if (!is.null(session)) {
+          warning(
+            "`backendDuckDB()` was configured for client-side mode because `reactable()` was called ",
+            "outside of a Shiny render function. Move the `reactable()` call inside `renderReactable()` ",
+            "so the backend can detect the Shiny session and use server mode.",
+            call. = FALSE
+          )
+        }
+        instance
       }
-      instance
     }
   } else {
     data <- toJSON(data)
@@ -1255,7 +1260,7 @@ duckdbDependency <- function() {
     name = "duckdb-wasm",
     version = "1.29.0",
     src = system.file("htmlwidgets/lib/duckdb-wasm", package = "reactable"),
-    script = "reactable-duckdb.js",
+    script = c("duckdb-locator.js", "reactable-duckdb.js"),
     all_files = TRUE
   )
 }
@@ -1264,9 +1269,10 @@ duckdbDependency <- function() {
 # Includes a locator script that registers the Parquet file URL so JS can find it.
 parquetDependency <- function(parquetDir, parquetFilename, parquetId) {
   # Write a locator script that registers the Parquet URL for this widget.
-  # Uses document.currentScript to detect the deployed path (same technique as duckdb-entry.js).
+  # Uses document.currentScript to detect the deployed path, with a querySelector
+  # fallback for Shiny where scripts are dynamically inserted.
   locatorJs <- sprintf(
-    "(function(){var s=document.currentScript;var b=s?s.src.replace(/[^/]*$/,''):'';window.__ReactableParquet=window.__ReactableParquet||{};window.__ReactableParquet['%s']=b+'%s';})();",
+    "(function(){var s=document.currentScript||document.querySelector('script[src*=\"parquet-locator\"]');var b=s?s.src.replace(/[^/]*$/,''):'';window.__ReactableParquet=window.__ReactableParquet||{};window.__ReactableParquet['%s']=b+'%s';})();",
     parquetId, parquetFilename
   )
   locatorFile <- file.path(parquetDir, "parquet-locator.js")

design/duckdb-wasm-engine/duckdb-wasm-engine-test.Rmd

@@ -899,6 +899,84 @@ reactable(
 )
 ```
 
+### Parquet in Shiny (client mode)
+
+Test that Parquet sidecar files work in a Shiny app. In Shiny, `backendDuckDB()` defaults
+to server mode (data stays in R), so Parquet requires `mode = "client"` to force DuckDB-WASM.
+The Parquet file is served via Shiny's htmlDependency resource path, and the locator script
+resolves the URL using `document.currentScript.src`.
+
+Test steps:
+1. Table should render and be interactive (sort, filter, search).
+2. Open browser DevTools Network tab -- requests to the `.parquet` file should use HTTP
+   range requests (partial content, status 206 or 200 with Range header).
+3. Sorting, filtering should work without full file download.
+
+```{r eval=FALSE}
+library(shiny)
+library(reactable)
+
+n <- 1000000
+parquet_data <- data.frame(
+  id = seq_len(n),
+  value = rnorm(n),
+  category = sample(LETTERS, n, replace = TRUE),
+  score = round(runif(n, 0, 100), 2),
+  label = paste0("item-", seq_len(n))
+)
+
+ui <- fluidPage(
+  h3("Parquet sidecar in Shiny (DuckDB client mode, 1M rows)"),
+  reactableOutput("table")
+)
+
+server <- function(input, output, session) {
+  output$table <- renderReactable({
+    reactable(
+      parquet_data,
+      backend = backendDuckDB(mode = "client", format = "parquet"),
+      defaultPageSize = 20,
+      sortable = TRUE,
+      filterable = TRUE,
+      searchable = TRUE,
+      showPageSizeOptions = TRUE
+    )
+  })
+}
+
+shinyApp(ui, server)
+```
+
+### Arrow IPC in Shiny (client mode)
+
+Test that embedded Arrow IPC works in a Shiny app with DuckDB client mode.
+This should work the same as the Parquet example but with data embedded in the HTML.
+
+```{r eval=FALSE}
+library(shiny)
+library(reactable)
+
+ui <- fluidPage(
+  h3("Arrow IPC in Shiny (DuckDB client mode)"),
+  reactableOutput("table")
+)
+
+server <- function(input, output, session) {
+  output$table <- renderReactable({
+    reactable(
+      MASS::Cars93,
+      backend = backendDuckDB(mode = "client", format = "arrow"),
+      defaultPageSize = 10,
+      sortable = TRUE,
+      filterable = TRUE,
+      searchable = TRUE
+    )
+  })
+}
+
+shinyApp(ui, server)
+```
+
 ## Cross-page selection
 
 ### Select-all across pages

design/server-side-data/server-side-data.md

@@ -11,7 +11,10 @@ Server-side data processing (`reactable(server = TRUE)`) moves sorting, filterin
 - ✅ Pagination, sorting, filtering, global search
 - ✅ Grouping with aggregation (V8 backend)
 - ✅ Custom S3 backend interface
-- ⚠️ Row selection/expansion only work for current page
+- ✅ Cross-page row selection (select-all, deselect-all, per-row)
+- ✅ `defaultSelected` with stable row IDs across pages
+- ✅ `updateReactable(selected = ...)` in backend modes
+- ✅ DuckDB-WASM client mode in Shiny (`mode = "client"`, both Arrow IPC and Parquet)
 - ⚠️ R render functions still run for entire table up front
 - ❌ No documentation vignette
 
@@ -91,7 +94,6 @@ JavaScript sends these parameters on every data request:
 | `searchValue` | string | Global search value |
 | `groupBy` | list | Grouped column IDs |
 | `expanded` | object | Expanded row state (currently unused) |
-| `selectedRowIds` | object | Selected row state (currently unused) |
 
 ### Response Format
 
@@ -164,25 +166,34 @@ df[["__state"]] <- listSafeDataFrame(
 When server-side search returns zero results, pagination shows "1-10 of 0 rows" instead of "0-0 of 0 rows".
 
 #### 1.4 Stop Sending Unused State
-**File:** `srcjs/Reactable.js` lines 1180-1183
+**File:** `srcjs/Reactable.js`
+
+~~Currently sends `expanded` and `selectedRowIds` in every request, but no backend uses them.~~ **Done.** `selectedRowIds` has been removed from server requests and all backend signatures. `expanded` is still sent for potential future use with `paginateSubRows`.
+
+### 2. Server-Side Row Selection
 
-Currently sends `expanded` and `selectedRowIds` in every request, but no backend uses them. Either:
-- Remove from requests until server-side selection/expansion is implemented
-- Or implement server-side versions (see section 2)
+~~This is complex work involving react-table hooks and row ID management.~~
 
-### 2. Server-Side Row Selection and Expansion
+**Done.** Cross-page row selection is fully implemented:
 
-This is complex work involving react-table hooks and row ID management.
+- Select-all queries the backend for all matching row IDs (via `selectAll` param) and stores them as explicit `selectedRowIds`
+- Deselect-all only removes the filtered/searched rows, leaving other selections intact
+- Per-row selections persist across page navigation, sort, and filter changes
+- `isAllRowsSelected` checks against `serverRowCount` (not just current page rows)
+- `toggleAllInProgressRef` guard prevents concurrent async calls from checkbox onChange+onClick bubbling
+- All 3 backends (DuckDB, V8, df) support `selectAll`
+- `defaultSelected` works correctly with `defaultSorted` via `__state` on pre-rendered pages
+- `updateReactable(selected = ...)` works in backend modes (0-based indices match `__state.id`)
 
-#### Current Behavior
-- Selection and expansion fall back to client-side mode
-- Select-all and expand-all only affect rows on the current page
-- This matches ag-Grid's server-side model behavior
+### 3. DuckDB-WASM Client Mode in Shiny
 
-#### Implementation Approach
+**Done.** DuckDB-WASM client mode (`backendDuckDB(mode = "client")`) works in Shiny apps:
 
-**Option A: Document limitation (recommended for v1)**
-- Document that select-all/expand-all only work for current page
+- WASM base path detection: locator script (`duckdb-locator.js`) runs before the main bundle and uses `document.currentScript` with a `querySelector` fallback for Shiny (where scripts are dynamically inserted and `document.currentScript` is null)
+- Runtime fallback in `Reactable.js` `useEffect`: queries DOM for `script[src*="reactable-duckdb"]` to resolve WASM/worker paths
+- Parquet sidecar files: same `querySelector` fallback in the Parquet locator script and a runtime URL resolution fallback in `useEffect`
+- Both `format = "arrow"` and `format = "parquet"` work correctly
+- Warning suppressed when user explicitly sets `mode = "client"` (only warns for auto-resolved client mode)
 - This is acceptable behavior matching other table libraries
 - Much simpler than full server-side implementation
 

inst/htmlwidgets/lib/duckdb-wasm/duckdb-locator.js

@@ -0,0 +1,10 @@
+// Detect and register the base path for DuckDB WASM files.
+// WASM and worker files are in the same directory as this script.
+// In Shiny, scripts are dynamically inserted via document.createElement(),
+// so document.currentScript is null. Fall back to querying the DOM.
+(function() {
+  var s = document.currentScript ||
+    document.querySelector('script[src*="duckdb-locator"]');
+  var basePath = s ? s.src.replace(/[^/]*$/, '') : '';
+  window.__ReactableDuckDBBasePath = basePath;
+})();

srcjs/Reactable.js

@@ -1272,6 +1272,16 @@ function Table({
       const parquetRegistry = window.__ReactableParquet
       if (parquetRegistry && parquetRegistry[parquetId]) {
         parquetUrl = parquetRegistry[parquetId]
+        // If the locator script couldn't detect its base path (e.g., in Shiny where
+        // document.currentScript is null for dynamically-inserted scripts), the URL
+        // will be just a filename. Resolve it against the locator script's actual URL
+        // from the DOM.
+        if (parquetUrl && !/^https?:\/\//.test(parquetUrl)) {
+          const locatorEl = document.querySelector('script[src*="parquet-locator"]')
+          if (locatorEl) {
+            parquetUrl = locatorEl.src.replace(/[^/]*$/, '') + parquetUrl
+          }
+        }
       } else {
         console.error(
           'Parquet sidecar file not found for parquetId: ' +
@@ -1286,8 +1296,20 @@ function Table({
     const duckdbBackend = new duckdbModule.DuckDBBackend()
     duckdbRef.current = duckdbBackend
 
+    // Resolve wasmBasePath. The locator script sets this at load time via
+    // document.currentScript, but in Shiny, scripts are dynamically inserted
+    // and document.currentScript is null. By the time this useEffect runs,
+    // the script elements are in the DOM, so fall back to querySelector.
+    let { wasmBasePath } = duckdbModule
+    if (!wasmBasePath) {
+      const scriptEl = document.querySelector('script[src*="reactable-duckdb"]')
+      if (scriptEl) {
+        wasmBasePath = scriptEl.src.replace(/[^/]*$/, '')
+      }
+    }
+
     duckdbBackend
-      .init({ arrowBase64: arrowData, parquetUrl, wasmBasePath: duckdbModule.wasmBasePath })
+      .init({ arrowBase64: arrowData, parquetUrl, wasmBasePath: wasmBasePath || '' })
       .then(() => {
         if (cancelled) return
         setServerRowCount(duckdbBackend.totalRowCount)

srcjs/duckdb-entry.js

@@ -1,10 +1,11 @@
 import { DuckDBBackend } from './DuckDBBackend'
 
-// Detect the base path for WASM files from this script's URL.
-// This script is loaded via an htmlDependency <script> tag, so
-// document.currentScript points to it. WASM files are in the same directory.
-const currentScript = document.currentScript
-const wasmBasePath = currentScript ? currentScript.src.replace(/[^/]*$/, '') : ''
+// Read the WASM base path from the locator script (duckdb-locator.js), which runs
+// as a separate <script> tag before this bundle. The locator uses
+// document.currentScript to detect its own URL, which is more reliable than trying
+// to detect the path from within a webpack bundle (where document.currentScript
+// may not be set, e.g., in Shiny's dynamic dependency loading).
+const wasmBasePath = window.__ReactableDuckDBBasePath || ''
 
 // Register globally so the main reactable bundle can access it
 window.__ReactableDuckDB = {

tests/testthat/test-server.R

@@ -30,3 +30,12 @@ test_that("backendDuckDB() client mode has preRenderHook for Shiny detection", {
   )
   expect_warning(tbl$preRenderHook(tbl), "outside of a Shiny render function")
 })
+
+test_that("backendDuckDB(mode = 'client') skips preRenderHook warning", {
+  skip_if_not_installed("arrow")
+
+  data <- data.frame(x = c(1, 2), y = c("a", "b"))
+  tbl <- reactable(data, backend = backendDuckDB(mode = "client"))
+  # preRenderHook should not be set when user explicitly chose client mode
+  expect_null(tbl$preRenderHook)
+})