@adia-ai/web-components 0.8.47 → 0.8.48

package/CHANGELOG.md

@@ -1,7 +1,41 @@
 # Changelog — @adia-ai/web-components
 
+## [0.8.48] — 2026-08-23
+
+### Added
+- **`table-ui`/`table-footer-ui`/`table-toolbar-ui` range grammar — `open-total`, `range-of`, `range-noun` (gh#1877), ADR-0082 Amendment.** Server-side pagination's range summary ("1–20 of 200") gets three composable authoring knobs: `open-total` drops the known-total suffix for unbounded/streamed counts, `range-of` swaps the connector word, `range-noun` supplies the counted-thing label — wired through `components/table/table.css`, `components/table-footer/table-footer.js`, and `components/table-toolbar/table-toolbar.js` (#1890).
+- **`table-toolbar-ui[title-always]` opt-out for the scope-reconciliation title hide (gh#1879).** The `:has([data-scope]:not(:empty)) [data-title]` reconciliation rule (landed in 0.8.47) drops the title whenever a scope chip is present; `title-always` opts a toolbar out so the title survives alongside scope chips (#1880).
+
+### Changed
+- **`link-ui`/`anchor-ui`-bearing surfaces get hover tokens, transitions, and a new `--link-fg-disabled` (gh#1881).** Every anchor-bearing component now declares `--link-fg-hover`/`--link-fg-active` plus a `color`/`text-decoration-color` transition instead of relying on inherited defaults; `--link-fg-disabled` fills the missing disabled-state role (#1887).
+- **`[prose]`/`[verse]` live usages swept to `scale=` (gh#1822).** Component demos and yaml examples using the deprecated `[prose]`/`[verse]` attribute pair migrated to the `scale=` contract ratified in an earlier cut (#1874).
+
+### Fixed
+- **`card-ui` preserves footer top inset in content-sized cards (gh#1866).** A content-sized (non-fixed-height) card's footer lost its top inset because the inset was conditioned on a fixed-height layout branch that content-sized cards never take; the inset now applies unconditionally (`components/card/card.css`) (#1875).
+- **A2UI runtime stops stamping synthetic `.id` onto elements with no authored id.** `resolve-node.js`'s synthetic-id path was firing for every unauthored element, polluting the DOM with runtime-only ids that leaked into snapshot tests and event targeting; now only elements that need an id for event wiring get one (#1872).
+- **A2UI runtime reflects `JS_PROPS` as JSON attributes alongside property writes (gh#1858).** `prop-apply.js` wrote JS property values but skipped the matching attribute reflection for `JS_PROPS`-classified props, so attribute-based selectors and SSR snapshots saw a stale value; both now update together (#1870).
+- **`themes.css`/`material-static.css` theme-scoped semantic alias resolution under descendant `[theme]` scopes (gh#1863).** A `--a-*` semantic alias resolved against the wrong `[theme]` ancestor when a themed subtree nested inside another themed subtree; two new gates guard the resolution order (#1873).
+
+### Docs
+- **`site/components/table-toolbar` canonical sample composes the toolbar as a `card-ui` header (#1884).** Replaces the prior bare-toolbar sample with the pattern most consumers actually use.
+- **`components/chart/chart.yaml` `ratio=` comment repaired** — the per-type wave landed in an earlier cut; the yaml comment still described the old single-ratio contract (#1871).
+
+### Maintenance
+- **`dist/` bundles rebuilt** in this cut's window — regenerated from the source changes described above, not independent edits.
+- **`styles/` touched in this release window** (`colors/material-static.css`, `themes.css`) — carried by the theme-scoped alias fix above (gh#1863, #1873).
+
 ## [0.8.47] — 2026-08-22
 
+### Changed
+- **`nav-group-ui`/`nav-item-ui`/`nav-ui` token simplification (gh#1740, gh#459, gh#1736).** `nav-group-ui` header text settles on one unconditional NEUTRAL-HIGH (`--nav-group-fg-active` deleted; `--nav-group-fg-selected` kept for the popover's current-option row); `nav-ui[data-nav-label]` moves from `--a-fg-muted` to plain NEUTRAL with retuned padding (top 16 / sides 4 / bottom 8). Dev server: `vite.config.js` gets an explicit `server.fs.allow`/`deny` — fixes vite's default `**/.git/**` deny blocking its own `/@vite/client` after resolving pnpm symlinks into a bootstrapped worktree's shared store (#1853).
+
+### Fixed
+- **`material-static.css`'s identical-leg `light-dark()` roles dropped; stale `themes.css` dead-code claim corrected (gh#1852).** ~224 solid-fill/hover/active/on-*/alpha-family `--md-sys-color-*` roles wrapped in a no-op `light-dark()` (both legs identical) — unwrapped. The header's second claim, that `themes.css` ships a dead divergent neutral ramp, was a false premise on investigation (a themed ancestor's override wins via ordinary custom-property inheritance, verified in Playwright) — corrected in place rather than deleting live theming infrastructure (#1854).
+- **`table-toolbar-ui[size]` prop, overflow-trigger cascade tie, and three min-width floor fights.** New `size` prop wired via ambient CSS inheritance; the `[data-toolbar-overflow]` cascade tie with `menu-ui`'s base rule (redundant "More" trigger re-render) fixed; `:has([data-scope]:not(:empty)) [data-title]` reconciliation drops a duplicate title/count cluster; toolbar/input/select/menu min-width floors reconciled (#1855).
+- **`core/anchor.js` popover-anchor reuse guard (all 12 consumers).** A trigger reused as the anchor for a second popover had its anchor-name clobbered by the first popover's async close-cleanup, landing the second popover at the viewport origin — fixed with an ownership guard in the cleanup closure (284 consumer tests green) (#1855).
+
+### Docs
+- **`site/components/table-toolbar` side-by-side docs demos.** `[data-preview-split]` opt-in pairs a demo's live render with its authored HTML side by side; table-toolbar visual goldens re-baselined after the verified layout fixes (#1855).
 
 ### Maintenance
 - **`components/` touched in this release window** (12 file(s), e.g. `nav-group/nav-group.css`) — carried by the entries above.

package/components/card/card.css

@@ -76,8 +76,30 @@
     display: flex;
     flex-direction: column;
   }
+  /* Explicit (not left to the base `& > footer` rule further down) so this
+     value is the one that wins regardless of declaration order — kept
+     alongside the bottom-pin spacer it replaces, gh#1866. */
   :scope > footer {
-    margin-top: auto;
+    margin-block-start: var(--card-inset);
+  }
+
+  /* Bottom-pin (gh#559), preserved WITHOUT sacrificing the footer's own
+     top inset (gh#1866). The old approach put `margin-top: auto` directly
+     on the footer: that absorbs FREE SPACE in an equal-height grid/flex
+     row (the pin), but a content-sized card has none to absorb, so the
+     auto margin resolved to 0 and the footer lost its --card-inset gap
+     entirely — every OTHER region kept its inset, only the footer didn't.
+     Moving the auto margin to the region immediately before the footer
+     keeps both behaviors distinct: that region still soaks up any
+     leftover height (still bottom-pinning the footer in an equal-height
+     card), while the footer's own margin-block-start above stays the
+     ordinary --card-inset in every card, content-sized included.
+     `:has(+ footer)` (not `:last-of-type`) so exactly the ONE region
+     directly adjacent to the footer gets the spacer — `:last-of-type` would
+     match the last header AND the last section independently when both are
+     present, splitting the auto margin across two elements instead of one. */
+  :scope:has(> footer) > :is(header, section):has(+ footer) {
+    margin-block-end: auto;
   }
 
   /* Flex containers never collapse adjacent margins the way block flow
@@ -87,7 +109,8 @@
      single inset block flow would have collapsed them to. The leading
      region's own margin-bottom already supplies that inset; zero the
      trailing region's margin-top. footer is excluded — its margin-top is
-     handled above (bottom-pin `auto`) or by [divider] below. */
+     handled above (its own explicit --card-inset, gh#1866) or by
+     [divider] below. */
   :scope:has(> footer) > :is(header, section) + :is(header, section) {
     margin-block-start: 0;
   }

package/components/chart/chart.a2ui.json

@@ -118,7 +118,7 @@
       "default": false
     },
     "ratio": {
-      "description": "Chart 2.0 aspect-ratio bucket (ADR-0074). Unset (default) auto-snaps to the nearest of the three studied ratios by comparing the chart's own live box aspect against two midpoint boundaries (5:4 between 3:2/1:1, 4:5 between 1:1/2:3) — never interpolated; the resolved bucket reflects onto the host as `data-ratio-resolved`. Setting `ratio` explicitly pins that bucket regardless of the box's actual aspect, overriding the auto-snap. Orthogonal to `size` (overall scale) and `type`/`color` (ADR-0064's family axis) — this attribute lands the grammar + snap plumbing only; per-type studied renderings per bucket are later waves (gh#1624 plan steps 2-4).",
+      "description": "Chart 2.0 aspect-ratio bucket (ADR-0074). Unset (default) auto-snaps to the nearest of the three studied ratios by comparing the chart's own live box aspect against two midpoint boundaries (5:4 between 3:2/1:1, 4:5 between 1:1/2:3) — never interpolated; the resolved bucket reflects onto the host as `data-ratio-resolved`. Setting `ratio` explicitly pins that bucket regardless of the box's actual aspect, overriding the auto-snap. Orthogonal to `size` (overall scale) and `type`/`color` (ADR-0064's family axis) — per-type studied renderings per bucket shipped across Waves A-C (gh#1624 plan steps 2-4: #1658 bar/line/area/pie/donut/sparkline, #1659 radar/scatter/ radial-bar/gauge/segments/stacked-bar/grouped-bar/multi-line, #1662 funnel/treemap/sankey/composed) — all 18 types have dedicated per-ratio render paths.",
       "type": "string",
       "enum": [
         "3:2",

package/components/chart/chart.d.ts

@@ -40,7 +40,7 @@ export class UIChart extends UIElement {
   noGrid: boolean;
   /** Hide value labels. Canonical spelling (ADR-0063, gh#1563) — the deprecated `hideValues` dual-read shim was cut in 0.8.43 (gh#1617). */
   noValues: boolean;
-  /** Chart 2.0 aspect-ratio bucket (ADR-0074). Unset (default) auto-snaps to the nearest of the three studied ratios by comparing the chart's own live box aspect against two midpoint boundaries (5:4 between 3:2/1:1, 4:5 between 1:1/2:3) — never interpolated; the resolved bucket reflects onto the host as `data-ratio-resolved`. Setting `ratio` explicitly pins that bucket regardless of the box's actual aspect, overriding the auto-snap. Orthogonal to `size` (overall scale) and `type`/`color` (ADR-0064's family axis) — this attribute lands the grammar + snap plumbing only; per-type studied renderings per bucket are later waves (gh#1624 plan steps 2-4). */
+  /** Chart 2.0 aspect-ratio bucket (ADR-0074). Unset (default) auto-snaps to the nearest of the three studied ratios by comparing the chart's own live box aspect against two midpoint boundaries (5:4 between 3:2/1:1, 4:5 between 1:1/2:3) — never interpolated; the resolved bucket reflects onto the host as `data-ratio-resolved`. Setting `ratio` explicitly pins that bucket regardless of the box's actual aspect, overriding the auto-snap. Orthogonal to `size` (overall scale) and `type`/`color` (ADR-0064's family axis) — per-type studied renderings per bucket shipped across Waves A-C (gh#1624 plan steps 2-4: #1658 bar/line/area/pie/donut/sparkline, #1659 radar/scatter/ radial-bar/gauge/segments/stacked-bar/grouped-bar/multi-line, #1662 funnel/treemap/sankey/composed) — all 18 types have dedicated per-ratio render paths. */
   ratio: '3:2' | '1:1' | '2:3';
   /** Multi-line only. Names one series key (matching a `y` key) to render at full strength — area fill + full-opacity line. Every other series drops its area fill and renders line-only at --chart-deemphasized-opacity. Empty (default) applies full treatment to every series, unchanged from pre-gh#561 behavior. */
   seriesEmphasis: string;

package/components/chart/chart.yaml

@@ -105,9 +105,12 @@ props:
       bucket reflects onto the host as `data-ratio-resolved`. Setting
       `ratio` explicitly pins that bucket regardless of the box's actual
       aspect, overriding the auto-snap. Orthogonal to `size` (overall
-      scale) and `type`/`color` (ADR-0064's family axis) — this attribute
-      lands the grammar + snap plumbing only; per-type studied renderings
-      per bucket are later waves (gh#1624 plan steps 2-4).
+      scale) and `type`/`color` (ADR-0064's family axis) — per-type studied
+      renderings per bucket shipped across Waves A-C (gh#1624 plan steps
+      2-4: #1658 bar/line/area/pie/donut/sparkline, #1659 radar/scatter/
+      radial-bar/gauge/segments/stacked-bar/grouped-bar/multi-line, #1662
+      funnel/treemap/sankey/composed) — all 18 types have dedicated
+      per-ratio render paths.
     type: string
     default: ""
     enum:

package/components/link/link.css

@@ -10,6 +10,7 @@
     --link-fg:              var(--a-link);
     --link-fg-hover:        var(--a-link-hover);
     --link-fg-visited:      var(--a-link-visited);
+    --link-fg-disabled:     var(--md-sys-color-neutral-on-surface-disabled);
     --link-underline-offset: 2px;
     --link-focus-ring:      var(--a-focus-ring);
   }
@@ -89,9 +90,9 @@
   /* ── Disabled ── */
 
   :scope[disabled] > a {
-    color: var(--md-sys-color-neutral-on-surface-disabled);
+    color: var(--link-fg-disabled);
     cursor: not-allowed;
-    text-decoration-color: var(--md-sys-color-neutral-on-surface-disabled);
+    text-decoration-color: var(--link-fg-disabled);
     pointer-events: none;
   }
 }

package/components/richtext/richtext.css

@@ -21,8 +21,8 @@
        page and inverted inside cards. Same tier as --a-bg-muted/hover. */
     --richtext-code-bg:        var(--md-sys-color-neutral-container-low);
     --richtext-border:         var(--md-sys-color-neutral-outline-variant);
-    --richtext-link:           var(--a-primary-bg);
-    --richtext-link-hover:     var(--md-sys-color-primary);
+    --richtext-link:           var(--a-link);
+    --richtext-link-hover:     var(--a-link-hover);
 
     /* ── Typography ── */
     --richtext-font:           var(--a-font-family);

package/components/table/table.a2ui.json

@@ -60,8 +60,11 @@
       "default": 0
     },
     "range-total": {
-      "description": "Total row count across ALL server pages (gh#1754, ADR-0082) — the table-authoritative server-mode data contract. Presence-gated: the attribute's PRESENCE, not its value, is the mode switch (checked via hasAttribute, never the coerced value alone — the same discipline table-footer-ui's own [range-total] ships). Absent (the default) means client mode: today's behavior exactly, [paginate] slices `.data` as always. Present with [paginate] > 0 means server mode: no local slicing (`.data` IS the current page and renders whole, after local search/sort/filter), the internal pager's page count becomes `max(1, ceil(range-total / paginate))` (one calc site, consolidated), and the internal page-reset sites (`data` set, `setFilter`, `clearFilters`) are suppressed so a fetch write-back never fights the pager back to page 0 — page state then moves only via pager interaction, the `footer-page` command, or `setState()`. The existing `page` event (0-based, unchanged) becomes the fetch trigger: the consumer listens for it, fetches that server page, and writes `.data` back. Explicit `range-total=\"0\"` is server-confirmed empty (pager hidden), never conflated with absent. With [paginate] absent/0, [range-total] is inert for this table's own rendering but stays readable by a bound table-footer-ui (REQ-W-006 branch 2) for its count-only label — see the footer-authoritative shape below, which remains lawful and is unaffected by this attribute. Named identically to table-toolbar-ui's and table-footer-ui's own [range-total] (rows, never `pagination-ui[total]`'s pages — the ADR-0063 B5 collision rule); a third instance of one name for one concept.",
-      "type": "number",
+      "description": "Total row count across ALL server pages (gh#1754, ADR-0082) — the table-authoritative server-mode data contract. Presence-gated: the attribute's PRESENCE, not its value, is the mode switch (checked via hasAttribute, never the coerced value alone — the same discipline table-footer-ui's own [range-total] ships). Absent (the default) means client mode: today's behavior exactly, [paginate] slices `.data` as always. Present with [paginate] > 0 means server mode: no local slicing (`.data` IS the current page and renders whole, after local search/sort/filter), the internal pager's page count becomes `max(1, ceil(range-total / paginate))` (one calc site, consolidated), and the internal page-reset sites (`data` set, `setFilter`, `clearFilters`) are suppressed so a fetch write-back never fights the pager back to page 0 — page state then moves only via pager interaction, the `footer-page` command, or `setState()`. The existing `page` event (0-based, unchanged) becomes the fetch trigger: the consumer listens for it, fetches that server page, and writes `.data` back. Explicit `range-total=\"0\"` is server-confirmed empty (pager hidden), never conflated with absent. With [paginate] absent/0, [range-total] is inert for this table's own rendering but stays readable by a bound table-footer-ui (REQ-W-006 branch 2) for its count-only label — see the footer-authoritative shape below, which remains lawful and is unaffected by this attribute. Named identically to table-toolbar-ui's and table-footer-ui's own [range-total] (rows, never `pagination-ui[total]`'s pages — the ADR-0063 B5 collision rule); a third instance of one name for one concept. Explicit `range-total=\"?\"` (gh#1877, ADR-0082 Amendment) is the OPEN/unproven-total state — cursor/hasMore server paging with no known row count yet: still server mode (still presence-gated), but the internal pager's page count stays exactly one page ahead of wherever the pager currently sits (never a fixed ceil(...) total), keeping `next` enabled indefinitely instead of hiding the pager the way a confirmed `range-total=\"0\"` would. Resolves to the normal finite server-mode behavior the instant a real number replaces the \"?\" — every reader downstream (table-toolbar-ui, table-footer-ui) shares this same distinction. Note: since this prop is Number-typed and reflected, the framework's own attribute-reflection immediately rewrites the DOM attribute to the literal string \"NaN\" once \"?\" is parsed (`+\"?\"` → NaN, then stringified back onto the attribute) — the coerced numeric PROPERTY is what carries the open/unproven signal (non-finite), never a literal \"?\" surviving as the live DOM attribute value.",
+      "type": [
+        "number",
+        "string"
+      ],
       "default": 0
     },
     "raw": {

package/components/table/table.class.js

@@ -41,6 +41,16 @@
  *                conflated with absent. With [paginate] absent/0, [range-total] is
  *                inert for this table's own rendering but stays readable by a
  *                bound table-footer-ui for its count-only label.
+ *   range-total="?" — gh#1877/ADR-0082 Amendment (2026-08-22) — the OPEN/
+ *                unproven-total state: server mode with no known total yet
+ *                (cursor/hasMore paging). Still presence-gated into server
+ *                mode like any other [range-total] value; #pageCount stays
+ *                one page ahead of the current page (never a fixed number)
+ *                so the pager's `next` stays enabled indefinitely, and
+ *                pagination visibility no longer requires a positive
+ *                #safeRangeTotal() while open. Resolves to a normal finite
+ *                server-mode table the moment a real range-total replaces
+ *                the "?".
  *   loading    — show loading overlay
  *   search     — global search filter string
  *
@@ -326,6 +336,20 @@ export class UITable extends UIElement {
   // reset-suppression call sites for why that widened scope is safe).
   get #serverMode() { return this.hasAttribute('range-total'); }
 
+  // gh#1877/ADR-0082 Amendment — the open/unproven-total state. NOT keyed
+  // on the raw attribute string: `rangeTotal` is a Number-typed reflected
+  // prop (installProps in core/element.js), so setting range-total="?" is
+  // parsed via `+"?"` → NaN and immediately reflected straight back onto
+  // the DOM attribute as the literal string "NaN" (reflect() in
+  // element.js stringifies any non-null coerced value) — by the time
+  // #draw()/render() runs, `getAttribute('range-total')` already reads
+  // "NaN", never the authored "?". The coerced PROPERTY still holds NaN
+  // stably, though (Object.is(NaN, NaN) is true, so the reflect's own
+  // re-parse never re-writes it) — that's the one signal that survives,
+  // and it's what #pageCount/showPagination below need to tell "no total
+  // yet" apart from "confirmed empty" (range-total="0", a finite 0).
+  get #rangeOpen() { return this.#serverMode && !Number.isFinite(Number(this.rangeTotal)); }
+
   // gh#1754/ADR-0082 REQ-D-003 (CodeRabbit, PR #1828) — a raw
   // `Number(x) || 0` accepts negative and non-finite values verbatim (both
   // are truthy), which can drive #pageCount/the footer's own range text
@@ -933,6 +957,13 @@ export class UITable extends UIElement {
     // derived, not the loaded page's own length (the exact dual-math drift
     // gh#1754's evidence quoted — this is now the ONE calc site;
     // #renderPagination reads this getter instead of recomputing).
+    // gh#1877/ADR-0082 Amendment — open/unproven total: no real total to
+    // derive from, so pageCount stays exactly one page ahead of wherever
+    // the pager currently is. That keeps `next` enabled indefinitely
+    // (never a false "last page") without inventing a fake total; the
+    // moment range-total resolves to a real number, this branch stops
+    // firing and the real ceil(...) math above takes over.
+    if (this.#rangeOpen) return this.#page + 2;
     if (this.#serverMode) return Math.max(1, Math.ceil(this.#safeRangeTotal() / this.paginate));
     // pageCount should reflect filtered data, not raw data
     const filteredCount = this.#getProcessedIndices().length;
@@ -1054,8 +1085,12 @@ export class UITable extends UIElement {
     // `data.length > 0` term: an in-flight fetch (momentarily empty `.data`)
     // must not flicker the pager away, so visibility gates on `range-total`
     // instead.
+    // gh#1877/ADR-0082 Amendment — an open/unproven total (REQ-D-003
+    // widened) always shows the pager while server mode is active: there's
+    // no confirmed-zero signal to gate on yet, and hiding it would read as
+    // "no more rows" when the real answer is "unknown, keep going".
     const showPagination = this.paginate > 0 && !this.noPager
-      && (this.#serverMode ? this.#safeRangeTotal() > 0 : this.#data.length > 0);
+      && (this.#serverMode ? (this.#rangeOpen || this.#safeRangeTotal() > 0) : this.#data.length > 0);
     let footer = this.querySelector(':scope > [data-footer]');
 
     if (showPagination) {

package/components/table/table.d.ts

@@ -104,8 +104,8 @@ export class UITable extends UIElement {
   noPager: boolean;
   /** Rows per page. 0 = show all rows without pagination. When > 0, renders the internal pagination bar below the table — UNLESS [no-pager] is also set (gh#1807, ADR-0080), which keeps [paginate]'s slicing/page-state/`page`-event/`footer-page`-listener behavior but suppresses only the bar itself (the anti-doubled-pager path for a table-footer-ui composition). When [range-total] is also set (gh#1754, ADR-0082), [paginate] becomes purely presentational — it supplies only the page-size for pager math; no local slicing runs. */
   paginate: number;
-  /** Total row count across ALL server pages (gh#1754, ADR-0082) — the table-authoritative server-mode data contract. Presence-gated: the attribute's PRESENCE, not its value, is the mode switch (checked via hasAttribute, never the coerced value alone — the same discipline table-footer-ui's own [range-total] ships). Absent (the default) means client mode: today's behavior exactly, [paginate] slices `.data` as always. Present with [paginate] > 0 means server mode: no local slicing (`.data` IS the current page and renders whole, after local search/sort/filter), the internal pager's page count becomes `max(1, ceil(range-total / paginate))` (one calc site, consolidated), and the internal page-reset sites (`data` set, `setFilter`, `clearFilters`) are suppressed so a fetch write-back never fights the pager back to page 0 — page state then moves only via pager interaction, the `footer-page` command, or `setState()`. The existing `page` event (0-based, unchanged) becomes the fetch trigger: the consumer listens for it, fetches that server page, and writes `.data` back. Explicit `range-total="0"` is server-confirmed empty (pager hidden), never conflated with absent. With [paginate] absent/0, [range-total] is inert for this table's own rendering but stays readable by a bound table-footer-ui (REQ-W-006 branch 2) for its count-only label — see the footer-authoritative shape below, which remains lawful and is unaffected by this attribute. Named identically to table-toolbar-ui's and table-footer-ui's own [range-total] (rows, never `pagination-ui[total]`'s pages — the ADR-0063 B5 collision rule); a third instance of one name for one concept. */
-  rangeTotal: number;
+  /** Total row count across ALL server pages (gh#1754, ADR-0082) — the table-authoritative server-mode data contract. Presence-gated: the attribute's PRESENCE, not its value, is the mode switch (checked via hasAttribute, never the coerced value alone — the same discipline table-footer-ui's own [range-total] ships). Absent (the default) means client mode: today's behavior exactly, [paginate] slices `.data` as always. Present with [paginate] > 0 means server mode: no local slicing (`.data` IS the current page and renders whole, after local search/sort/filter), the internal pager's page count becomes `max(1, ceil(range-total / paginate))` (one calc site, consolidated), and the internal page-reset sites (`data` set, `setFilter`, `clearFilters`) are suppressed so a fetch write-back never fights the pager back to page 0 — page state then moves only via pager interaction, the `footer-page` command, or `setState()`. The existing `page` event (0-based, unchanged) becomes the fetch trigger: the consumer listens for it, fetches that server page, and writes `.data` back. Explicit `range-total="0"` is server-confirmed empty (pager hidden), never conflated with absent. With [paginate] absent/0, [range-total] is inert for this table's own rendering but stays readable by a bound table-footer-ui (REQ-W-006 branch 2) for its count-only label — see the footer-authoritative shape below, which remains lawful and is unaffected by this attribute. Named identically to table-toolbar-ui's and table-footer-ui's own [range-total] (rows, never `pagination-ui[total]`'s pages — the ADR-0063 B5 collision rule); a third instance of one name for one concept. Explicit `range-total="?"` (gh#1877, ADR-0082 Amendment) is the OPEN/unproven-total state — cursor/hasMore server paging with no known row count yet: still server mode (still presence-gated), but the internal pager's page count stays exactly one page ahead of wherever the pager currently sits (never a fixed ceil(...) total), keeping `next` enabled indefinitely instead of hiding the pager the way a confirmed `range-total="0"` would. Resolves to the normal finite server-mode behavior the instant a real number replaces the "?" — every reader downstream (table-toolbar-ui, table-footer-ui) shares this same distinction. Note: since this prop is Number-typed and reflected, the framework's own attribute-reflection immediately rewrites the DOM attribute to the literal string "NaN" once "?" is parsed (`+"?"` → NaN, then stringified back onto the attribute) — the coerced numeric PROPERTY is what carries the open/unproven signal (non-finite), never a literal "?" surviving as the live DOM attribute value. */
+  rangeTotal: number | string;
   /** Visual-only passthrough — applies `<table-ui>`'s chrome reset (background / border / border-radius all transparent) AND short-circuits the data lifecycle entirely. The consumer owns the body shape: no header injection, no row reconciliation from `.data`, no empty-state / loading overlays, no aggregation or pagination footers. Use raw when embedding `<table-ui>` inside surfaces that supply their own chrome (e.g. `<card-ui><section bleed>`), or when wrapping a consumer-authored native `<table>` for design-token styling without the framework's data semantics. Note: a `<table-ui>` placed directly inside `<card-ui><section bleed>` drops the table's visual chrome automatically (card.css, gh#796) even without `raw` — `raw` is still required to also short-circuit the data lifecycle. Pre-v0.6.33 (FB-53 §2) `raw` was visual-only and the data lifecycle still ran — wrapping a `.data`-unset native table produced a phantom "No data" overlay. v0.6.33+ matches the documented contract. */
   raw: boolean;
   /** Global search/filter string. Filters visible rows across all columns using case-insensitive substring matching. Does NOT reset the current page (verified against source at the gh#1754/ADR-0082 build — unlike setFilter()/clearFilters(), no internal page reset ever ran for a search change; this description previously claimed "resets to page 1 on change," which the source never did). Aligning the doc to observed behavior here, not a behavior change — a page reset on search, if wanted, is a separate client-mode ticket. */

package/components/table/table.yaml

@@ -98,7 +98,23 @@ props:
       to table-toolbar-ui's and table-footer-ui's own [range-total]
       (rows, never `pagination-ui[total]`'s pages — the ADR-0063 B5
       collision rule); a third instance of one name for one concept.
-    type: number
+      Explicit `range-total="?"` (gh#1877, ADR-0082 Amendment) is the
+      OPEN/unproven-total state — cursor/hasMore server paging with no
+      known row count yet: still server mode (still presence-gated), but
+      the internal pager's page count stays exactly one page ahead of
+      wherever the pager currently sits (never a fixed ceil(...) total),
+      keeping `next` enabled indefinitely instead of hiding the pager the
+      way a confirmed `range-total="0"` would. Resolves to the normal
+      finite server-mode behavior the instant a real number replaces the
+      "?" — every reader downstream (table-toolbar-ui, table-footer-ui)
+      shares this same distinction. Note: since this prop is Number-typed
+      and reflected, the framework's own attribute-reflection immediately
+      rewrites the DOM attribute to the literal string "NaN" once "?" is
+      parsed (`+"?"` → NaN, then stringified back onto the attribute) —
+      the coerced numeric PROPERTY is what carries the open/unproven
+      signal (non-finite), never a literal "?" surviving as the live DOM
+      attribute value.
+    type: [number, string]
     default: 0
     reflect: true
   filteredCount:

package/components/table-footer/table-footer.a2ui.json

@@ -31,11 +31,24 @@
       "type": "number",
       "default": 0
     },
-    "range-total": {
-      "description": "Total ROWS across all pages. Absent (the default) means \"not yet known\" (loading) — never \"zero\"; both the range label and the pager stay hidden until this is set. Explicit range-total=\"0\" is the confirmed-empty state (pager hidden; the `empty` slot renders in the range label's position when supplied). Named identically to table-toolbar-ui's [range-total] and table-ui's own [range-total] (gh#1754, ADR-0082) and deliberately NOT `total` (pagination-ui's `total` is total PAGES — the ADR-0063 B5 collision rule). When this attribute is unset, the footer derives it from the resolved target via a two-branch ladder (REQ-W-006, amended 0.2.0/ADR-0082): (1) the target's own [range-total] attribute, when present — the table-authoritative SERVER mode (gh#1754 Shape 1's second lawful composition); the identity rule: the footer's range-total derives from the table's range-total, never the table's filteredCount, and this branch wins even when the target's [paginate] is also > 0; (2) otherwise, when the target has [paginate] > 0, CLIENT mode: the target's filtered row count (search + column filters applied, before pagination). Refreshes on the target's `page` / `filter-change` / `sort` events in either branch. Widened named staleness edge: a programmatic `.data` swap on the target — or a `range-total` update on the target without an accompanying page move — emits no event; either re-set this footer's own attributes after such a change, or accept staleness until the target's next event.",
+    "range-noun": {
+      "description": "gh#1877, ADR-0082 Amendment — optional per-slice noun appended after the range total (\"of 80 users\") so consumers stop hand-painting the noun themselves. Applies in both the normal finite range text and the open/unproven-total text (\"Showing 51–100 users\" with no \"of N\"). Unset (the default) changes nothing. Named identically on table-toolbar-ui (ADR-0082 §\"same name on both companions\").",
+      "type": "string",
+      "default": ""
+    },
+    "range-of": {
+      "description": "gh#1877, ADR-0082 Amendment — secondary whole-set total for the \"filtered-of-whole\" shape: a client-side facet narrows [range-total] (a filtered count) while range-of names the unfiltered set size, e.g. \"Showing 1–4 of 4 traversals (6 total)\". Appends \"(of <range-of> total)\" onto the normal finite range text; unset (the default) changes nothing. Never applies while [range-total] is absent (loading) or \"?\" (open/unproven) — there's no finite range text to append onto yet. Named identically on table-toolbar-ui (ADR-0082 §\"same name on both companions\").",
       "type": "number",
       "default": 0
     },
+    "range-total": {
+      "description": "Total ROWS across all pages. Absent (the default) means \"not yet known\" (loading) — never \"zero\"; both the range label and the pager stay hidden until this is set. Explicit range-total=\"0\" is the confirmed-empty state (pager hidden; the `empty` slot renders in the range label's position when supplied). Named identically to table-toolbar-ui's [range-total] and table-ui's own [range-total] (gh#1754, ADR-0082) and deliberately NOT `total` (pagination-ui's `total` is total PAGES — the ADR-0063 B5 collision rule). Explicit range-total=\"?\" (gh#1877, ADR-0082 Amendment) is the OPEN/unproven- total state — cursor/hasMore server paging with no known row count yet: the range label renders \"Showing X–Y\" with no \"of N\", and the pager stays in has-more mode (next enabled) rather than hiding — distinct from both \"loading\" (attribute absent) and \"confirmed empty\" (range-total=\"0\"). Resolves to the normal finite behavior the moment a real number replaces the \"?\". When this attribute is unset, the footer derives it from the resolved target via a two-branch ladder (REQ-W-006, amended 0.2.0/ADR-0082): (1) the target's own [range-total] attribute, when present — the table-authoritative SERVER mode (gh#1754 Shape 1's second lawful composition; the target's own \"?\" carries through identically); the identity rule: the footer's range-total derives from the table's range-total, never the table's filteredCount, and this branch wins even when the target's [paginate] is also > 0; (2) otherwise, when the target has [paginate] > 0, CLIENT mode: the target's filtered row count (search + column filters applied, before pagination). Refreshes on the target's `page` / `filter-change` / `sort` events in either branch. Widened named staleness edge: a programmatic `.data` swap on the target — or a `range-total` update on the target without an accompanying page move — emits no event; either re-set this footer's own attributes after such a change, or accept staleness until the target's next event.",
+      "type": [
+        "number",
+        "string"
+      ],
+      "default": 0
+    },
     "siblings": {
       "description": "Passed through to the composed pagination-ui's own [siblings] (page-number window size on each side of the current page).",
       "type": "number",
@@ -77,6 +90,11 @@
         "a2ui": "[\n  {\"id\": \"root\", \"component\": \"Column\", \"gap\": \"0\", \"children\": [\"tests\", \"ftr\"]},\n  {\"id\": \"tests\", \"component\": \"Table\", \"raw\": true},\n  {\"id\": \"ftr\", \"component\": \"TableFooter\", \"for\": \"tests\", \"page\": 1, \"page-size\": 10, \"range-total\": 128}\n]",
         "name": "table-footer-server-mode"
       },
+      {
+        "description": "gh#1877, ADR-0082 Amendment — cursor/hasMore server mode with no known row count yet: [range-total=\"?\"] renders \"Showing 1–50 subscriptions\" (via [range-noun]) with `next` kept enabled until a real total resolves.",
+        "a2ui": "[\n  {\"id\": \"root\", \"component\": \"Column\", \"gap\": \"0\", \"children\": [\"subs\", \"ftr\"]},\n  {\"id\": \"subs\", \"component\": \"Table\", \"raw\": true},\n  {\"id\": \"ftr\", \"component\": \"TableFooter\", \"for\": \"subs\", \"page\": 1, \"page-size\": 50, \"range-total\": \"?\", \"range-noun\": \"subscriptions\"}\n]",
+        "name": "table-footer-open-total"
+      },
       {
         "description": "Client-mode footer bound to a [paginate]d table-ui with its own internal pager suppressed via [no-pager].",
         "a2ui": "[\n  {\"id\": \"root\", \"component\": \"Column\", \"gap\": \"0\", \"children\": [\"tests-c\", \"ftr\"]},\n  {\"id\": \"tests-c\", \"component\": \"Table\", \"paginate\": 10, \"no-pager\": true, \"raw\": true},\n  {\"id\": \"ftr\", \"component\": \"TableFooter\", \"for\": \"tests-c\"}\n]",

package/components/table-footer/table-footer.class.js

@@ -33,12 +33,23 @@
  *
  * Degradation (REQ-S):
  *   - range-total ABSENT            → indeterminate/loading: both regions hidden.
+ *   - range-total EXPLICIT "?"      → gh#1877/ADR-0082 Amendment — OPEN/unproven
+ *                                      total (cursor/hasMore paging): "Showing
+ *                                      X–Y" with no "of N", pager stays in
+ *                                      has-more mode (next enabled) until a
+ *                                      real range-total resolves.
  *   - range-total EXPLICIT "0"      → pager hidden; [slot="empty"] renders in
  *                                      the range region if supplied, else hides.
  *   - page-size ABSENT or "0"       → count-only label ("128 items"), no pager
  *                                      (REQ-S-005 — the ordinary DEFAULT state,
  *                                      since page-size defaults to 0).
  *   - derived pages ≤ 1             → pager hidden, range label still renders.
+ *   - range-of="<whole>"            → gh#1877/ADR-0082 Amendment — secondary
+ *                                      whole-set total, appends "(of <whole>
+ *                                      total)"; unset changes nothing.
+ *   - range-noun="<noun>"           → gh#1877/ADR-0082 Amendment — appends the
+ *                                      per-slice noun ("of 80 users"); unset
+ *                                      changes nothing.
  *
  * Target derivation (REQ-W-006, amended 0.2.0/ADR-0082) — a two-branch
  * ladder when range-total is unset, per-attribute:
@@ -94,6 +105,15 @@ export class UITableFooter extends UIElement {
     page:       { type: Number, default: 1,    reflect: true },
     pageSize:   { type: Number, default: 0,    reflect: true, attribute: 'page-size' },
     rangeTotal: { type: Number, default: 0,    reflect: true, attribute: 'range-total' },
+    // gh#1877/ADR-0082 Amendment — secondary whole-set total (the
+    // "filtered-of-whole" gap: a client-side-narrowed range-total plus the
+    // unfiltered set size), and the optional per-slice noun consumers used
+    // to hand-paint ("of 80 users"). Both presence-gated like range-total —
+    // hasAttribute decides whether the suffix renders, never the coerced
+    // value alone (an author-set range-of="0" is nonsensical and treated
+    // as absent by #draw()'s safeRangeTotal reuse).
+    rangeOf:    { type: Number, default: 0,    reflect: true, attribute: 'range-of' },
+    rangeNoun:  { type: String, default: '',   reflect: true, attribute: 'range-noun' },
     // Pass-throughs to the composed pagination-ui (REQ-F-002) — the
     // defaults below deliberately mirror pagination-ui's own defaults, so
     // an unset pass-through is a no-op mirror, not a silent override.
@@ -133,7 +153,7 @@ export class UITableFooter extends UIElement {
   // one, so it needs the raw attribute callback, not the signal diff.
   attributeChangedCallback(name, oldVal, newVal) {
     super.attributeChangedCallback(name, oldVal, newVal);
-    if (name === 'range-total') this.#draw();
+    if (name === 'range-total' || name === 'range-of' || name === 'range-noun') this.#draw();
   }
 
   // ── DOM stamp ────────────────────────────────────────────────────────────
@@ -316,11 +336,29 @@ export class UITableFooter extends UIElement {
       const n = Number(raw);
       return Number.isFinite(n) && n > 0 ? Math.trunc(n) : 0;
     };
-    const rangeTotal = hasRangeTotal
-      ? safeRangeTotal(this.rangeTotal)
-      : targetServer
-        ? safeRangeTotal(target.rangeTotal)
-        : (clientMode ? (Number(target.filteredCount) || 0) : 0);
+    // gh#1877/ADR-0082 Amendment — the open/unproven-total state: the
+    // resolved source of range-total (local attribute if set, else the
+    // server-mode target's own) coerces to a non-finite number. NOT keyed
+    // on the raw attribute string — rangeTotal is a Number-typed reflected
+    // prop, so range-total="?" parses via `+"?"` → NaN and the property
+    // setter's own reflect() immediately rewrites the DOM attribute to the
+    // literal string "NaN" (core/element.js) before this ever runs;
+    // getAttribute('range-total') would read "NaN", never "?". The
+    // coerced PROPERTY still holds NaN stably (Object.is(NaN, NaN) is
+    // true, so the reflect's re-parse never re-writes it) — that's the
+    // one signal that survives, and what tells "unknown yet" apart from
+    // "confirmed zero" (a finite 0) once safeRangeTotal has clamped both
+    // to 0.
+    const rangeOpen = hasRangeTotal
+      ? !Number.isFinite(Number(this.rangeTotal))
+      : (targetServer && !Number.isFinite(Number(target.rangeTotal)));
+    const rangeTotal = rangeOpen
+      ? null
+      : hasRangeTotal
+        ? safeRangeTotal(this.rangeTotal)
+        : targetServer
+          ? safeRangeTotal(target.rangeTotal)
+          : (clientMode ? (Number(target.filteredCount) || 0) : 0);
     // page-size still derives from target.paginate in EITHER derived mode
     // (server or client) — unchanged behavior, just widened to cover the
     // targetServer branch too (a server-mode target's paginate is its
@@ -329,6 +367,15 @@ export class UITableFooter extends UIElement {
       ? (Number(this.pageSize) || 0)
       : ((targetServer || clientMode) ? (Number(target.paginate) || 0) : (Number(this.pageSize) || 0));
 
+    // gh#1877/ADR-0082 Amendment — range-of (secondary whole-set total) and
+    // range-noun (per-slice noun) are both additive suffixes onto the
+    // normal finite "of N" text; neither applies to the loading, confirmed-
+    // empty, or open-total branches below.
+    const hasRangeOf = this.hasAttribute('range-of');
+    const rangeOfVal = hasRangeOf ? safeRangeTotal(this.rangeOf) : 0;
+    const rangeOfSuffix = hasRangeOf && rangeOfVal > 0 ? ` (of ${rangeOfVal} total)` : '';
+    const nounSuffix = this.rangeNoun ? ` ${this.rangeNoun}` : '';
+
     if (!rangeEl) return;
 
     if (!totalKnown) {
@@ -342,6 +389,45 @@ export class UITableFooter extends UIElement {
 
     rangeEl.hidden = false;
 
+    if (rangeOpen) {
+      // gh#1877/ADR-0082 Amendment REQ-open — "Showing X–Y" with no
+      // "of N", pager stays in has-more mode (next enabled) until a real
+      // range-total resolves. Deterministic window math off page/page-size
+      // alone, same shape as the finite branch below — no clamp against a
+      // total we don't have yet (adiav2 ehr-subscriptions-paging.ts).
+      if (rangeEmpty) rangeEmpty.hidden = true;
+      if (pageSize <= 0) {
+        // No page-size known yet either — nothing to derive a window from.
+        if (rangeText) {
+          rangeText.hidden = false;
+          rangeText.textContent = nounSuffix ? `Loading${nounSuffix}…` : 'Loading…';
+        }
+        if (pagerWrap) pagerWrap.hidden = true;
+        return;
+      }
+      const page = Math.max(1, Number(this.page) || 1);
+      const start = (page - 1) * pageSize + 1;
+      const end = page * pageSize;
+      if (rangeText) {
+        rangeText.hidden = false;
+        rangeText.textContent = `Showing ${start}–${end}${nounSuffix}`;
+      }
+      if (pagerWrap) {
+        pagerWrap.hidden = false;
+      }
+      if (pag) {
+        // Keeps `next` enabled indefinitely (never a false "last page") —
+        // mirrors table.class.js's own #pageCount open-mode math
+        // (gh#1877/ADR-0082 Amendment): total is always one page ahead of
+        // wherever the pager currently sits.
+        pag.setAttribute('page', String(page));
+        pag.setAttribute('total', String(page + 1));
+        pag.setAttribute('siblings', String(Math.max(0, Number(this.siblings) || 0)));
+        pag.setAttribute('size', this.size || 'md');
+      }
+      return;
+    }
+
     if (rangeTotal === 0) {
       // REQ-S-002 — confirmed-empty. The empty slot always wins over the
       // range text whenever range-total is confirmed zero, mutually
@@ -361,7 +447,7 @@ export class UITableFooter extends UIElement {
       // "Showing 1–0 of N" math an unbounded pager would otherwise need.
       if (rangeText) {
         rangeText.hidden = false;
-        rangeText.textContent = `${rangeTotal} items`;
+        rangeText.textContent = `${rangeTotal} items${rangeOfSuffix}`;
       }
       if (pagerWrap) pagerWrap.hidden = true;
       return;
@@ -374,7 +460,7 @@ export class UITableFooter extends UIElement {
 
     if (rangeText) {
       rangeText.hidden = false;
-      rangeText.textContent = `Showing ${start}–${end} of ${rangeTotal}`;
+      rangeText.textContent = `Showing ${start}–${end} of ${rangeTotal}${nounSuffix}${rangeOfSuffix}`;
     }
 
     if (pagerWrap) {

package/components/table-footer/table-footer.d.ts

@@ -22,8 +22,12 @@ export class UITableFooter extends UIElement {
   page: number;
   /** Rows per page. Default 0 (unknown) is the ORDINARY default state, not an exotic edge case: with page-size absent/0 and range-total present, the range label renders in count-only form ("128 items") and the pager does not render — the derivation math (pages = range-total / page-size) is undefined without a page size. In a client-mode composition (the resolved target has [paginate] > 0) and this attribute is unset, the footer derives page-size from the target's own [paginate] value. */
   pageSize: number;
-  /** Total ROWS across all pages. Absent (the default) means "not yet known" (loading) — never "zero"; both the range label and the pager stay hidden until this is set. Explicit range-total="0" is the confirmed-empty state (pager hidden; the `empty` slot renders in the range label's position when supplied). Named identically to table-toolbar-ui's [range-total] and table-ui's own [range-total] (gh#1754, ADR-0082) and deliberately NOT `total` (pagination-ui's `total` is total PAGES — the ADR-0063 B5 collision rule). When this attribute is unset, the footer derives it from the resolved target via a two-branch ladder (REQ-W-006, amended 0.2.0/ADR-0082): (1) the target's own [range-total] attribute, when present — the table-authoritative SERVER mode (gh#1754 Shape 1's second lawful composition); the identity rule: the footer's range-total derives from the table's range-total, never the table's filteredCount, and this branch wins even when the target's [paginate] is also > 0; (2) otherwise, when the target has [paginate] > 0, CLIENT mode: the target's filtered row count (search + column filters applied, before pagination). Refreshes on the target's `page` / `filter-change` / `sort` events in either branch. Widened named staleness edge: a programmatic `.data` swap on the target — or a `range-total` update on the target without an accompanying page move — emits no event; either re-set this footer's own attributes after such a change, or accept staleness until the target's next event. */
-  rangeTotal: number;
+  /** gh#1877, ADR-0082 Amendment — optional per-slice noun appended after the range total ("of 80 users") so consumers stop hand-painting the noun themselves. Applies in both the normal finite range text and the open/unproven-total text ("Showing 51–100 users" with no "of N"). Unset (the default) changes nothing. Named identically on table-toolbar-ui (ADR-0082 §"same name on both companions"). */
+  rangeNoun: string;
+  /** gh#1877, ADR-0082 Amendment — secondary whole-set total for the "filtered-of-whole" shape: a client-side facet narrows [range-total] (a filtered count) while range-of names the unfiltered set size, e.g. "Showing 1–4 of 4 traversals (6 total)". Appends "(of <range-of> total)" onto the normal finite range text; unset (the default) changes nothing. Never applies while [range-total] is absent (loading) or "?" (open/unproven) — there's no finite range text to append onto yet. Named identically on table-toolbar-ui (ADR-0082 §"same name on both companions"). */
+  rangeOf: number;
+  /** Total ROWS across all pages. Absent (the default) means "not yet known" (loading) — never "zero"; both the range label and the pager stay hidden until this is set. Explicit range-total="0" is the confirmed-empty state (pager hidden; the `empty` slot renders in the range label's position when supplied). Named identically to table-toolbar-ui's [range-total] and table-ui's own [range-total] (gh#1754, ADR-0082) and deliberately NOT `total` (pagination-ui's `total` is total PAGES — the ADR-0063 B5 collision rule). Explicit range-total="?" (gh#1877, ADR-0082 Amendment) is the OPEN/unproven- total state — cursor/hasMore server paging with no known row count yet: the range label renders "Showing X–Y" with no "of N", and the pager stays in has-more mode (next enabled) rather than hiding — distinct from both "loading" (attribute absent) and "confirmed empty" (range-total="0"). Resolves to the normal finite behavior the moment a real number replaces the "?". When this attribute is unset, the footer derives it from the resolved target via a two-branch ladder (REQ-W-006, amended 0.2.0/ADR-0082): (1) the target's own [range-total] attribute, when present — the table-authoritative SERVER mode (gh#1754 Shape 1's second lawful composition; the target's own "?" carries through identically); the identity rule: the footer's range-total derives from the table's range-total, never the table's filteredCount, and this branch wins even when the target's [paginate] is also > 0; (2) otherwise, when the target has [paginate] > 0, CLIENT mode: the target's filtered row count (search + column filters applied, before pagination). Refreshes on the target's `page` / `filter-change` / `sort` events in either branch. Widened named staleness edge: a programmatic `.data` swap on the target — or a `range-total` update on the target without an accompanying page move — emits no event; either re-set this footer's own attributes after such a change, or accept staleness until the target's next event. */
+  rangeTotal: number | string;
   /** Passed through to the composed pagination-ui's own [siblings] (page-number window size on each side of the current page). */
   siblings: number;
   /** Passed through to the composed pagination-ui's own [size] (sm | md | lg, the universal size system). */