table3 0.3.0__tar.gz → 0.5.0__tar.gz

table3-0.5.0/CHANGELOG.md

@@ -0,0 +1,81 @@
+# Changelog
+
+## 0.5.0 — 2026-11-03
+
+### Added
+
+- In SolveIt, `view()` hides its cell from the AI (SolveIt's red eye), as
+  plot3 does for plots, so the explorer's rows don't fill the model's
+  context. SolveIt hides the cell's code with its output. `view(hide=False)`
+  keeps one cell visible, and `table3.autohide(False)` turns it off for the
+  session. `show()` and printed tables are not hidden. Outside SolveIt
+  nothing changes.
+
+### Changed
+
+- A paged table writes only its first page as styled cells, and every row
+  as compact JSON its script draws into the other pages: about a quarter
+  of the size (a printed 8-column frame of 100 rows, 23 KB instead of
+  86 KB), which matters in SolveIt, where a cell's output goes to the AI.
+  Where scripts don't run, the first page shows. `pages=False` is
+  unchanged.
+
+### Fixed
+
+- The explorer's headers show that they sort before the first click: a
+  faint ↕ beside each name, which turns into ▲ or ▼ on the sorted column,
+  and "Click to sort by …" on hover.
+
+## 0.4.0 — 2026-11-03
+
+### Added
+
+- `table3.view(data)` opens a data explorer over the first 10,000 rows, as
+  R's `View()`: one grid to scroll, with row numbers, a search box, headers
+  that sort on a click (ascending, descending, off; nulls last), and a filter
+  under each column: from–to for numbers and dates (`2008` matches a year),
+  "contains" for text, and a pick-list for booleans and columns of at most
+  50 values. The status line counts the rows that pass ("120 of 344 rows").
+  It runs in the notebook's browser, so it works in saved notebooks; the
+  rows are JSON drawn a screen at a time, about 1 MB for 10,000 rows of a
+  dozen columns. Where output scripts don't run, it shows the first 100
+  rows as `show()` does. [docs/explorer.md](docs/explorer.md) has the design.
+
+## 0.3.0 — 2026-11-02
+
+table3 is view3 renamed: the table is how a frame prints in a notebook, as
+R's `print()`, and `view` is kept for a data explorer, as R's `View()`. Its
+versions continue view3's, whose entries are below; this is table3's first
+release on PyPI.
+
+### Changed from view3 0.2.0
+
+- `view3.view()` is `table3.show()`, and there is no `view()`. Nothing used
+  `view()` yet.
+- The hook is `__table3__`, not `__view3__`.
+- The footer no longer names `n=`: "1–10 of 100 rows (first 100 of 344)".
+  A package showing the table as its frames' notebook display sets *n*
+  itself.
+
+## view3 0.2.0 — 2026-11-02
+
+### Added
+
+- `digits=` chooses how floats print. `digits=6` keeps six significant
+  digits, as R's `signif()` does, so small numbers keep their precision
+  (`0.000123457`, `1.5e-7`) where the default shows `0.000123`;
+  `digits="full"` shows every stored digit. The default, `None`, prints as
+  polars' text preview does, as before.
+
+## view3 0.1.0 — 2026-11-02
+
+Phase 1 of [the design](docs/design.md).
+
+### Added
+
+- `view3.view(data)` shows up to `n` rows in a paged table and returns
+  `data`; `view3.html(data)` returns the HTML. Ten rows a page
+  (`page_size=`), column pages for wide tables, and a scroll box with pinned
+  names and types where output scripts don't run or with `pages=False`.
+- polars DataFrames, LazyFrames and Series, pandas DataFrames and Series, and
+  any object with a `__view3__(n)` method.

{table3-0.3.0/src/table3.egg-info → table3-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: table3
-Version: 0.3.0
+Version: 0.5.0
 Summary: Paged, theme-aware tables in notebook output: shared by tidy3, tidy3a and stats3
 Author: Rigoberto Leyva Salmeron
 License-Expression: MIT
@@ -19,6 +19,8 @@ Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: ipython>=8.0; extra == "dev"
 Requires-Dist: pandas>=2.1.4; extra == "dev"
 Requires-Dist: pyarrow>=15.0; extra == "dev"
+Provides-Extra: browser
+Requires-Dist: pytest-playwright>=0.5; extra == "browser"
 Dynamic: license-file
 
 # table3
@@ -51,7 +53,26 @@ full value on hover. Wide tables show as many columns as fit, with
 arrows to the rest. The table follows the notebook's light or dark theme in
 VS Code, JupyterLab and SolveIt.
 
-`show()` returns what it was given, so it can sit in the middle of a pipe.
+## Explore
+
+`table3.view(penguins)` opens a data explorer, as R's `View()` does: one
+grid of up to 10,000 rows with a search box, headers that sort on a click,
+and a filter under each column (from–to for numbers and dates, "contains"
+for text, a pick-list for columns of few values).
+
+```python
+table3.view(penguins);
+table3.view(penguins, n=50_000, height=600);  # more rows, a taller grid
+```
+
+In SolveIt, which sends every cell's code and output to its AI, `view()`
+hides its cell from the AI (the red eye), so the explorer's rows don't fill
+the model's context; the cell's code is hidden with them. `view(hide=False)`
+keeps a cell visible, and `table3.autohide(False)` stops hiding for the
+session.
+
+`show()` and `view()` return what they were given, so they can sit in the
+middle of a pipe.
 As a cell's last line the notebook also prints that value; end the line with
 `;` to hide it.
 
@@ -72,6 +93,6 @@ def _repr_html_(self):
 ## More
 
 [docs/design.md](docs/design.md) records the design and what each package
-adds. table3 was first released as view3 0.1 and 0.2, where `show()` was
-`view()`, and its versions continue from them. The name `view` is kept for a
-data explorer, as R's `View()` opens one.
+adds, and [docs/explorer.md](docs/explorer.md) the explorer's. table3 was
+first released as view3 0.1 and 0.2, where `show()` was `view()`; its
+versions continue from them, and `view()` is now the explorer.

{table3-0.3.0 → table3-0.5.0}/README.md

@@ -28,7 +28,26 @@ full value on hover. Wide tables show as many columns as fit, with
 arrows to the rest. The table follows the notebook's light or dark theme in
 VS Code, JupyterLab and SolveIt.
 
-`show()` returns what it was given, so it can sit in the middle of a pipe.
+## Explore
+
+`table3.view(penguins)` opens a data explorer, as R's `View()` does: one
+grid of up to 10,000 rows with a search box, headers that sort on a click,
+and a filter under each column (from–to for numbers and dates, "contains"
+for text, a pick-list for columns of few values).
+
+```python
+table3.view(penguins);
+table3.view(penguins, n=50_000, height=600);  # more rows, a taller grid
+```
+
+In SolveIt, which sends every cell's code and output to its AI, `view()`
+hides its cell from the AI (the red eye), so the explorer's rows don't fill
+the model's context; the cell's code is hidden with them. `view(hide=False)`
+keeps a cell visible, and `table3.autohide(False)` stops hiding for the
+session.
+
+`show()` and `view()` return what they were given, so they can sit in the
+middle of a pipe.
 As a cell's last line the notebook also prints that value; end the line with
 `;` to hide it.
 
@@ -49,6 +68,6 @@ def _repr_html_(self):
 ## More
 
 [docs/design.md](docs/design.md) records the design and what each package
-adds. table3 was first released as view3 0.1 and 0.2, where `show()` was
-`view()`, and its versions continue from them. The name `view` is kept for a
-data explorer, as R's `View()` opens one.
+adds, and [docs/explorer.md](docs/explorer.md) the explorer's. table3 was
+first released as view3 0.1 and 0.2, where `show()` was `view()`; its
+versions continue from them, and `view()` is now the explorer.

{table3-0.3.0 → table3-0.5.0}/docs/design.md

@@ -2,7 +2,7 @@
 
 Status: accepted 2026-11-02. Released first as view3 (0.1.0 phase 1 of §6,
 0.2.0 `digits=` of §2.1); renamed table3 for 0.3.0, with `show()` and the
-table as tidy3's notebook display (§5).
+table as tidy3's notebook display (§5), which tidy3 0.18.0 uses (phase 2).
 
 tidy3 previews showed ten rows. To see more, a notebook user had to `pull()`
 a column and call `.to_list()` on the parenthesized pipe, losing column
@@ -76,9 +76,13 @@ significant digits and converting the column would print its type as `str`.
   scripts don't run, the table stays a box `height` pixels tall (default
   300) that scrolls both ways under a pinned header. `pages=False` asks for
   that box everywhere.
-- **Size.** Every cell carries its style, about 100 bytes a cell: 1,000 rows
-  of 12 columns add about 1.2 MB to a saved notebook. The font is set once
-  on the table to halve that.
+- **Size.** A styled cell is about 100 bytes, and SolveIt sends a cell's
+  output to its AI, so a paged table writes only its first page as cells
+  and every row as compact JSON, which its script draws into the other
+  pages (0.5.0): `penguins`, 8 columns of 100 rows, is 23 KB, not 86 KB.
+  Without scripts the first page shows. `pages=False` writes every row as
+  cells, about 1.2 MB for 1,000 rows of 12 columns; the font is set once on
+  the table to halve that.
 
 ## 4. Interface
 
@@ -119,5 +123,6 @@ leaves the names alone.
 2. tidy3: dependency, `__table3__`, the table as `_repr_html_`, reference docs,
    release.
 3. stats3 and tidy3a: hooks and docs.
-4. Later: tidy3's ordinary notebook table formats through table3 (its floats
-   print in full today); loading further rows while paging.
+4. Later: loading further rows while paging.
+5. A data explorer, `table3.view()`, as R's `View()`: planned in
+   [explorer.md](explorer.md).

table3-0.5.0/docs/explorer.md

@@ -0,0 +1,145 @@
+# A data explorer: `table3.view()`
+
+Status: accepted 2026-11-03; phase 1 released in table3 0.4.0.
+
+A printed frame shows as a paged table (design.md). R has a second way to
+look at data: `View(df)` opens RStudio's data viewer, a spreadsheet-like
+grid where you search, sort and filter without writing code. This document
+plans that viewer for table3: `table3.view(data)`, and a `view()` verb in
+tidy3.
+
+## 1. What R's `View()` does
+
+- One grid of every row, scrolled rather than paged, with row numbers and a
+  pinned header.
+- **Search** across every column in one box.
+- **Sort** by clicking a column header: ascending, descending, off.
+- **Filter** per column: a range for numbers and dates, text match for
+  strings, a pick-list for factors.
+- A status line: "Showing 1 to 120 of 344 entries, 8 total columns".
+- It reads only what it shows from the R session, so millions of rows work.
+
+## 2. Where filtering runs
+
+**Phase 1: in the browser.** `view()` writes the first *n* rows into the
+output once, as compact JSON, and a script draws the grid and runs search,
+sort and filters on them.
+
+- It works where the paged table works: SolveIt runs output scripts and runs
+  them again when a dialog is reloaded (probed 2026-11-02); VS Code and
+  trusted Jupyter notebooks run them too. A saved notebook reopens with the
+  explorer working.
+- No new dependency, no kernel connection.
+- It explores only the rows it was given: `n=10_000` by default, about 1 MB
+  for a dozen columns. The status line says when *n* cut the rows ("120 of
+  10,000 rows (first 10,000 of 52,341)").
+- Rows are JSON, not HTML: 10,000 rows of HTML table cells with inline
+  styles would be about 12 MB. The script draws only the rows in view
+  (virtual scrolling), so the grid stays fast at 10,000 rows.
+
+**Phase 3 (later, if needed): through the kernel.** A live widget (anywidget)
+sends each search, sort or filter to polars and gets one screen of rows
+back, so it explores any number of rows lazily. It needs a live kernel and
+shows nothing in a saved notebook, and SolveIt's and CRAFT's support for
+widgets was unknown. It would be an optional extra (`table3[explore]`), and a
+probe like the script probe decided whether to build it.
+
+Probed 2026-11-03: SolveIt does not draw Jupyter widgets. An anywidget whose
+button sends a click to the kernel printed as its text,
+`<__main__.Probe object at 0x…>`, with no button, so a widget has no kernel
+connection there. The kernel-backed mode is not built: the in-browser
+explorer is the only one, and `n=` is how to explore more rows. A widget
+mode for VS Code and Jupyter alone would split the explorer by notebook, so
+it waits for a need that `n=` can't meet.
+
+## 3. Interface
+
+```python
+table3.view(data, *, n=10_000, height=500, digits=None, caption=None, hide=None)  # shows, returns data
+table3.autohide(on=True)  # whether view() hides its cell from SolveIt's AI
+```
+
+*data* is anything `html()` and `show()` take, `__table3__` objects
+included. It returns *data* unchanged, like `show()`; `;` hides the
+notebook's own print of it. Outside a notebook it prints the first rows as
+`show()` does.
+
+In SolveIt, which sends each cell's code and output to its AI, `view()`
+then marks its cell hidden from the AI (`dialoghelper.update_msg(skipped=1)`,
+SolveIt's red eye), as plot3 does for plots: the rows would fill the
+model's context. SolveIt has no flag for an output alone, so the cell's code
+is hidden too; a `view()` cell is usually one line. `show()` and printed
+tables are not hidden, since most analysis cells end in a frame and hiding
+those would hide their code. `hide=False`, or `autohide(False)` for the
+session, keeps cells visible. Added in 0.5.0.
+
+tidy3 adds `view()` as a verb and method, as `glimpse()`: `penguins >> view()`,
+`view(penguins)`, `penguins.view()`, passing the frame through. It is the
+only bare `view` in the family; tidy3a and stats3 document `table3.view(x)`.
+
+## 4. The grid
+
+- **Header**, pinned: name, type (`i64`, `str`), and a sort arrow; clicking
+  cycles ascending, descending, off. One sort column at a time, as R.
+- **Filter row** under the header, one control per column by type:
+  - numbers and dates: two boxes, from and to, either blank;
+  - strings: contains, case-insensitive;
+  - strings with at most 50 distinct values, booleans and categoricals: a
+    pick-list of their values, with `null` as one choice.
+- **Search box** above: rows where any cell's text contains it.
+- **Row numbers** on the left: the row's place in *data*, kept through sorts
+  and filters, as R shows them.
+- **Status line**: "120 of 344 rows | 8 columns", plus the *n* note.
+- **Cells** as the table formats them: `null`, floats by `digits=`, long
+  values cut with the full value on hover. Sorting and filters use the raw
+  values, so numbers sort as numbers and nulls go last.
+- **Wide frames** scroll sideways with the row numbers pinned at the left.
+- **Theme**: table3's colours and translucent greys, every style inline (set
+  by the script), no `<style>` block.
+
+**Without scripts** (an untrusted Jupyter notebook, perhaps CRAFT's
+republish) the output is `show()`'s table of the first 100 rows, with a line
+saying the explorer needs output scripts.
+
+## 5. Data in the output
+
+```json
+{"columns": [{"name": "species", "type": "str", "kind": "text", "choices": ["Adelie", "Chinstrap", "Gentoo"]},
+             {"name": "body_mass_g", "type": "i64", "kind": "number"}],
+ "rows": [["Adelie", 3750], ["Adelie", null]],
+ "shown": [null, ["3750"]],
+ "total": 344, "n": 10000}
+```
+
+- `rows` holds raw values for sorting and filtering: numbers as numbers,
+  dates and times as ISO text (which sorts in order), everything else as
+  text, `null` for missing.
+- `shown` holds a column's display text only where it differs from the raw
+  value: floats (`digits=`) and values cut at 40 characters. Other columns
+  show their raw text.
+- `kind` picks the filter: `number`, `date`, `text`, `choice`, `bool`.
+- The JSON goes in a `<script type="application/json">` element beside the
+  grid, escaped so a value holding `</script>` can't end it.
+
+## 6. Tests
+
+- **pytest**: the JSON (kinds, choices, raw and shown values, escaping, the
+  *n* cut, `__table3__` objects, pandas), `view()` returning its input, the
+  no-script fallback.
+- **pytest with Playwright** (headless Chromium): load the output in a page
+  and drive it: sort cycles, each filter kind, search, row numbers kept,
+  status line counts, virtual scrolling at 10,000 rows, a value holding
+  `</script>`. Its own CI job (`pip install pytest-playwright`, `playwright
+  install chromium`) and a `scripts/check.sh` step, as neither the Mac nor
+  gpudev has a headless browser installed.
+- **By eye**: `docs/check.ipynb` cells for the explorer, in SolveIt (dark
+  theme) and VS Code.
+
+## 7. Phases
+
+1. table3 0.4.0: `table3.view()` in the browser (§2, §4–§6).
+2. tidy3: the `view()` verb and method, reference docs, release.
+3. Probe SolveIt and CRAFT for widgets; if they work and in-browser limits
+   bite, a kernel-backed mode as `table3[explore]`. Done 2026-11-03: SolveIt
+   does not draw widgets (§2), so there is no kernel-backed mode.
+4. tidy3a and stats3: document `table3.view(x)`.

{table3-0.3.0 → table3-0.5.0}/pyproject.toml

@@ -27,6 +27,9 @@ dependencies = [
 [project.optional-dependencies]
 # pandas and pyarrow: the pandas input tests.
 dev = ["pytest>=7.0", "ipython>=8.0", "pandas>=2.1.4", "pyarrow>=15.0"]
+# The explorer's and the pages' scripts in headless Chromium (tests/test_*_browser.py);
+# also run: python -m playwright install chromium
+browser = ["pytest-playwright>=0.5"]
 
 [project.urls]
 Homepage = "https://github.com/rleyvasal/table3"

{table3-0.3.0 → table3-0.5.0}/src/table3/__init__.py

@@ -5,6 +5,8 @@ Previous / page / Next buttons and, for wide data, as many columns as fit
 the cell plus arrows to the rest: what a package returns from its frames'
 ``_repr_html_`` so they print as R notebooks print data frames.
 ``table3.show(data)`` displays the same table and returns *data* unchanged.
+``table3.view(data)`` opens a data explorer instead, as R's ``View()``: a
+grid of up to 10,000 rows to search, sort and filter.
 
 *data* is a polars DataFrame, LazyFrame or Series, a pandas DataFrame or
 Series, or any object with a ``__table3__`` method::
@@ -24,8 +26,10 @@ import polars as pl
 
 from table3.__version__ import __version__
 from table3._html import table_html
+from table3 import _solveit
+from table3._solveit import autohide
 
-__all__ = ["__version__", "html", "show"]
+__all__ = ["__version__", "autohide", "html", "show", "view"]
 
 
 def _from_pandas(df: Any) -> pl.DataFrame:
@@ -109,6 +113,19 @@ def html(
     )
 
 
+def _display(html_text: str) -> bool:
+    """Show *html_text* in a notebook; False outside one."""
+    try:
+        from IPython import get_ipython
+        from IPython.display import HTML, display
+    except ImportError:
+        return False
+    if get_ipython() is None:
+        return False
+    display(HTML(html_text))
+    return True
+
+
 def _text(data: Any, n: int, digits: int | str | None = None) -> str:
     df, total, caption = _parts(data, n)
     # Polars prints no significant digits; digits=k applies to the table only.
@@ -139,15 +156,53 @@ def show(
     the line with ``;`` to hide it.
     """
     _check(n, pages, page_size, height, digits)
-    try:
-        from IPython import get_ipython
-        from IPython.display import HTML, display
-    except ImportError:
-        get_ipython = None
-    if get_ipython is not None and get_ipython() is not None:
-        options = {"n": n, "pages": pages, "page_size": page_size, "height": height}
-        display(HTML(html(data, digits=digits, caption=caption, **options)))
-    else:
+    options = {"n": n, "pages": pages, "page_size": page_size, "height": height}
+    if not _display(html(data, digits=digits, caption=caption, **options)):
         print(_text(data, n, digits))
     return data
 
+
+def view(
+    data: Any,
+    *,
+    n: int = 10_000,
+    height: int = 500,
+    digits: int | str | None = None,
+    caption: str | None = None,
+    hide: bool | None = None,
+) -> Any:
+    """Open a data explorer over the first *n* rows of *data*, and return *data*.
+
+    As R's ``View()``: one grid to scroll, a search box, headers that sort
+    on a click, and a filter under each column (from-to for numbers and
+    dates, "contains" for text, a pick-list for columns of few values).
+    The rows go into the notebook's output, so the explorer works in a saved
+    notebook, about 1 MB for 10,000 rows of a dozen columns. *height* is the
+    grid's height in pixels; *digits* and *caption* as in ``html()``. Where
+    output scripts don't run, it shows the first 100 rows as ``show()``.
+    Outside a notebook it prints the first rows.
+
+    In SolveIt, which sends every cell's code and output to its AI, the
+    cell is then hidden from the AI (SolveIt's red eye), so the rows don't
+    fill its context. *hide* says whether to, for this call: ``True`` or
+    ``False``; ``None`` follows ``table3.autohide()``, on by default.
+    SolveIt hides the cell's code with its output.
+    """
+    _check(n, True, 10, height, digits)
+    if hide is not None and not isinstance(hide, bool):
+        raise TypeError("table3: hide must be True, False or None")
+    if height is None:
+        raise ValueError("table3: view() height must be a positive integer")
+    from table3._explore import explorer_html
+
+    df, total, own_caption = _parts(data, n)
+    page = explorer_html(
+        df, total, own_caption if caption is None else caption,
+        n=n, height=height, digits=digits,
+    )
+    if not _display(page):
+        print(_text(data, min(n, 20), digits))
+    elif _solveit.AUTOHIDE if hide is None else hide:
+        _solveit.hide_calling_cell()
+    return data
+

table3-0.5.0/src/table3/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.5.0"

table3-0.5.0/src/table3/_explore.py

@@ -0,0 +1,119 @@
+"""The explorer's output: its rows as JSON, a script that draws the grid, and a
+plain table for notebooks that don't run output scripts (docs/explorer.md)."""
+
+from __future__ import annotations
+
+import html as _html
+import math
+import uuid
+
+import polars as pl
+
+from table3._explorer_js import EXPLORER_JS
+from table3._format import dtype_short, float_text, json_for_script
+from table3._html import MONO, table_html
+
+CHOICES_MAX = 50  # a text column with at most this many values filters by pick-list
+FALLBACK_ROWS = 100
+_MAX_FLOAT = 1.7976931348623157e308  # inf's stand-in: JSON has no infinity
+_SAFE_INT = 2**53  # beyond this a JavaScript number loses digits
+
+
+def _kind(s: pl.Series) -> str:
+    t = s.dtype
+    if t == pl.Boolean:
+        return "bool"
+    if t.is_numeric():
+        return "number"
+    if t.is_temporal():
+        return "date"
+    if t in (pl.String, pl.Categorical) or isinstance(t, pl.Enum):
+        return "choice" if s.n_unique() <= CHOICES_MAX else "text"
+    return "text"
+
+
+def _float_raw(v: float | None) -> float | None:
+    if v is None or math.isnan(v):
+        return None
+    if math.isinf(v):
+        return _MAX_FLOAT if v > 0 else -_MAX_FLOAT
+    return v
+
+
+def _column(s: pl.Series, digits: int | str | None) -> tuple[dict, list, list | None]:
+    """The column's header entry, its raw values, and its display text where it differs."""
+    kind = _kind(s)
+    head = {"name": s.name, "type": dtype_short(s.dtype), "kind": kind}
+    values = s.to_list()
+    shown = None
+    if s.dtype.is_float():
+        raw = [_float_raw(v) for v in values]
+        shown = float_text(s, digits)
+    elif s.dtype.is_integer():
+        raw = values
+        if any(v is not None and abs(v) > _SAFE_INT for v in values):
+            raw = [None if v is None else float(v) for v in values]
+            shown = [None if v is None else str(v) for v in values]
+    elif s.dtype.is_decimal():
+        raw = [None if v is None else float(v) for v in values]
+        shown = [None if v is None else str(v) for v in values]
+    elif kind == "bool":
+        raw = values
+    else:
+        raw = [None if v is None else str(v) for v in values]
+    if kind == "choice":
+        head["choices"] = sorted({v for v in raw if v is not None})
+    return head, raw, shown
+
+
+def payload(df: pl.DataFrame, total: int | None, n: int, digits: int | str | None) -> dict:
+    """What the script needs: columns, rows of raw values, display text, counts."""
+    columns, raws, shown = [], [], []
+    for s in df.get_columns():
+        head, raw, text = _column(s, digits)
+        columns.append(head)
+        raws.append(raw)
+        shown.append(text)
+    return {
+        "columns": columns,
+        "rows": [list(r) for r in zip(*raws)] if raws else [],
+        "shown": shown,
+        "total": total,
+        "n": n,
+    }
+
+
+def explorer_html(
+    df: pl.DataFrame,
+    total: int | None,
+    caption: str | None,
+    *,
+    n: int,
+    height: int,
+    digits: int | str | None,
+) -> str:
+    uid = f"table3-explore-{uuid.uuid4().hex}"
+    fallback = table_html(
+        df.head(FALLBACK_ROWS), total, None, pages=False, page_size=10,
+        height=300, digits=digits,
+    )
+    note = (
+        f"<div style='font:{MONO};opacity:.65;margin:0 0 4px 0'>The explorer needs "
+        f"the notebook to run output scripts; the first {min(df.height, FALLBACK_ROWS):,} "
+        "rows show here instead.</div>"
+    )
+    cap = ""
+    if caption:
+        cap = (
+            f"<div style='font:{MONO};opacity:.85;margin:0 0 4px 0'>"
+            f"{_html.escape(caption)}</div>"
+        )
+    data = json_for_script(payload(df, total, n, digits))
+    return (
+        f"<div id='{uid}' data-height='{height}' style='font:{MONO}'>"
+        + cap
+        + f"<div data-fallback>{note}{fallback}</div>"
+        + f"<script type='application/json'>{data}</script>"
+        + "</div>"
+        + f"<script>{EXPLORER_JS.replace('__ID__', uid)}</script>"
+    )