@adia-ai/web-components 0.8.46 → 0.8.48

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). */

package/components/table-footer/table-footer.yaml

@@ -55,14 +55,22 @@ props:
       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):
+      `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 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;
+      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` /
@@ -71,9 +79,34 @@ props:
       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
+    reflect: true
+  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
     reflect: true
+  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: ""
+    reflect: true
   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
@@ -166,6 +199,13 @@ a2ui:
       range label's own position, without a layout shift versus the normal
       range text. Only fires on an EXPLICIT range-total="0" — omitting
       range-total entirely (loading) never shows it.
+    - >-
+      gh#1877, ADR-0082 Amendment — cursor/hasMore server paging (no
+      server-reported row count, only "more rows exist or not") sets
+      [range-total="?"] instead of a real number: the range label reads
+      "Showing 51–100" with no "of N", and the pager keeps `next` enabled
+      until a later response supplies a real [range-total], at which point
+      the footer renders the normal finite text automatically.
 anti_patterns:
   - wrong: '<table-footer-ui range-start="1" range-end="10" range-total="128"></table-footer-ui>'
     why: >-
@@ -185,6 +225,17 @@ examples:
         {"id": "tests", "component": "Table", "raw": true},
         {"id": "ftr", "component": "TableFooter", "for": "tests", "page": 1, "page-size": 10, "range-total": 128}
       ]
+  - name: table-footer-open-total
+    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: >-
+      [
+        {"id": "root", "component": "Column", "gap": "0", "children": ["subs", "ftr"]},
+        {"id": "subs", "component": "Table", "raw": true},
+        {"id": "ftr", "component": "TableFooter", "for": "subs", "page": 1, "page-size": 50, "range-total": "?", "range-noun": "subscriptions"}
+      ]
   - name: table-footer-client-mode
     description: Client-mode footer bound to a [paginate]d table-ui with its own internal pager suppressed via [no-pager].
     a2ui: >-

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

@@ -70,16 +70,39 @@
       "type": "number",
       "default": 0
     },
+    "rangeNoun": {
+      "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 summary and the open/unproven-total summary (\"Showing 51–100 users\" with no \"of N\"). Unset (the default) changes nothing. Named identically to table-footer-ui's own [range-noun] (ADR-0082 §\"same name on both companions\").",
+      "type": "string",
+      "default": ""
+    },
+    "rangeOf": {
+      "description": "gh#1877, ADR-0082 Amendment — secondary whole-set total for the \"filtered-of-whole\" shape: a client-side facet narrows [rangeTotal] (a filtered count) while rangeOf names the unfiltered set size, e.g. \"Showing 1–4 of 4 traversals (6 total)\". Appends \"(of <rangeOf> total)\" onto the normal finite range summary; unset (the default) changes nothing. Never applies while the summary is in its open (\"?\") or opted-out (all-zero) state. Named identically to table-footer-ui's own [range-of] (ADR-0082 §\"same name on both companions\").",
+      "type": "number",
+      "default": 0
+    },
     "rangeStart": {
       "description": "1-indexed first row number of the current page, for the \"Showing X–Y of N\" range summary (e.g. `1` in \"Showing 1–25 of 320\"). Renders alongside — never in place of — [text]/[count]; the range summary is its own cluster, independent of the title cluster. All three of rangeStart/rangeEnd/rangeTotal must be set (> 0) for the summary to render; omit all three (the default) to opt out entirely.",
       "type": "number",
       "default": 0
     },
     "rangeTotal": {
-      "description": "Total row count across all pages, for the range summary (e.g. `320` in \"Showing 1–25 of 320\"). Distinct from pagination-ui's `total` (total PAGES) — this is total ROWS; deliberately not spelled `total` to avoid that cross-sibling name collision (ADR-0063 B5). See rangeStart.",
-      "type": "number",
+      "description": "Total row count across all pages, for the range summary (e.g. `320` in \"Showing 1–25 of 320\"). Distinct from pagination-ui's `total` (total PAGES) — this is total ROWS; deliberately not spelled `total` to avoid that cross-sibling name collision (ADR-0063 B5). See rangeStart. 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 summary reads \"Showing X–Y\" with no \"of N\", requiring only [range-start]/[range-end] (> 0) to render, not rangeTotal too. Resolves to the normal finite summary the moment a real number replaces the \"?\". Named identically to table-footer-ui's own [range-total] (ADR-0082 §\"same name on both companions\").",
+      "type": [
+        "number",
+        "string"
+      ],
       "default": 0
     },
+    "size": {
+      "description": "Toolbar scale, via sizing.css's universal [size=\"sm|md|lg\"] ambient tokens. Not table-toolbar-specific chrome — the same attribute that scales any component. Set it once on the toolbar instead of on each slotted scope/actions-leading/actions control individually; anything slotted with no [size] of its own inherits the ambient value. Default (empty) = md.",
+      "type": "string",
+      "enum": [
+        "sm",
+        "md",
+        "lg"
+      ],
+      "default": ""
+    },
     "stage": {
       "description": "Explicit compaction-stage override (ADR-0076). Unset (the default, empty string) means auto-snap: the toolbar's own inline-size container query picks the nearest stage from its live width against the three --table-toolbar-bp-* breakpoints, snapping discretely, never interpolating. Setting stage explicitly pins that stage's rendering regardless of the container's actual width — overriding the container query, mirroring chart-ui's ratio override shape. Primary use: visual-eval fixtures that need a deterministic stage without resizing a real container, and a consumer embedding the toolbar inside a known-narrow panel who wants to skip auto-detection entirely. All four stages' CSS is now live (ADR-0076): search-tight steps the search field down (step 2); icon-only drops control labels and compacts/hides the range summary (steps 3+4); overflow collapses Filter/Sort/Columns into one \"More\" trigger routed through the same menu-ui/menu-item-ui pattern used elsewhere in the corpus (step 5). The resolved stage — the pin if set, otherwise the live width classification — also reflects onto the host as `data-stage-resolved` (step 7, informational only, mirrors chart-ui's `data-ratio-resolved` convention — never drives table-toolbar's own rendering, which stays 100% CSS-driven).",
       "type": "string",
@@ -97,6 +120,11 @@
       "type": "string",
       "default": ""
     },
+    "titleAlways": {
+      "description": "Opt out of the scope-reconciliation title hide: by default, a filled [slot=\"scope\"] region (a select/menu whose own displayed value already names the entity being listed) hides the separate [text]/[count] title cluster next to it, since together they'd say the same thing twice. Set [title-always] to keep the title cluster visible alongside a filled scope slot — e.g. a scope select PLUS an explicit text/count title on the same row (gh#1879).",
+      "type": "boolean",
+      "default": false
+    },
     "variant": {
       "description": "Toolbar visual variant. `default` renders bare on parent surface; `card` adds the same chrome as a card-ui header.",
       "type": "string",
@@ -169,6 +197,11 @@
         "description": "The ratified adiav2 list-page toolbar row (ADIA2-9123, gh#1649): scope menu, range summary, app-owned Filter/Columns triggers (their own filter drawer, not the native popovers — [no-filter]/[no-columns]/ [no-sort]/[no-search] drop the native affordances), page-size select, and a primary CTA — [slot=\"actions-leading\"] carries the Filter/Columns triggers so they land BEFORE the page-size select, while [slot=\"actions\"] carries the CTA so it lands after.",
         "a2ui": "[\n  {\"id\": \"root\", \"component\": \"Column\", \"gap\": \"3\", \"children\": [\"bar\", \"card\"]},\n  {\"id\": \"bar\", \"component\": \"TableToolbar\", \"for\": \"accounts\", \"no-filter\": true, \"no-sort\": true, \"no-columns\": true, \"no-search\": true, \"range-start\": 1, \"range-end\": 25, \"range-total\": 320, \"page-size\": 25, \"page-size-options\": [10, 25, 50, 100], \"children\": [\"btn-filter\", \"btn-columns\", \"btn-new\"]},\n  {\"id\": \"btn-filter\", \"component\": \"Button\", \"text\": \"Filter\", \"variant\": \"ghost\", \"slot\": \"actions-leading\"},\n  {\"id\": \"btn-columns\", \"component\": \"Button\", \"text\": \"Columns\", \"variant\": \"ghost\", \"slot\": \"actions-leading\"},\n  {\"id\": \"btn-new\", \"component\": \"Button\", \"text\": \"New account\", \"variant\": \"primary\", \"slot\": \"actions\"},\n  {\"id\": \"card\", \"component\": \"Card\", \"children\": [\"sec\"]},\n  {\"id\": \"sec\", \"component\": \"Section\", \"bleed\": true, \"children\": [\"tbl\"]},\n  {\"id\": \"tbl\", \"component\": \"Table\", \"id\": \"accounts\", \"sortable\": true, \"raw\": true}\n]",
         "name": "adiav2-list-page-toolbar-row"
+      },
+      {
+        "description": "gh#1877, ADR-0082 Amendment — cursor/hasMore server paging with no known row count yet: [range-total=\"?\"] renders \"Showing 1–50 subscriptions\" (via [range-noun]) with no \"of N\", resolving to the normal finite summary once a real total arrives.",
+        "a2ui": "[\n  {\"id\": \"root\", \"component\": \"Column\", \"gap\": \"3\", \"children\": [\"bar\", \"card\"]},\n  {\"id\": \"bar\", \"component\": \"TableToolbar\", \"for\": \"subs\", \"range-start\": 1, \"range-end\": 50, \"range-total\": \"?\", \"range-noun\": \"subscriptions\"},\n  {\"id\": \"card\", \"component\": \"Card\", \"children\": [\"sec\"]},\n  {\"id\": \"sec\", \"component\": \"Section\", \"bleed\": true, \"children\": [\"tbl\"]},\n  {\"id\": \"tbl\", \"component\": \"Table\", \"id\": \"subs\", \"raw\": true}\n]",
+        "name": "table-toolbar-open-total"
       }
     ],
     "keywords": [

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

@@ -153,11 +153,31 @@ function collectUniqueValues(col, data) {
 export class UITableToolbar extends UIElement {
   static properties = {
     for:         { type: String,  default: '',         reflect: true },
+    // Not consumed by any table-toolbar-specific CSS — sizing.css's
+    // universal [size="sm|md|lg"] (unscoped attribute selector, ambient
+    // inheriting tokens) already governs the host AND every slotted
+    // consumer content (scope select-ui, actions-leading/actions
+    // button-ui) that carries no [size] of its own, same as
+    // `<div size="sm">…</div>`. Declared (reflect: true) purely so this
+    // A2UI-modeled prop survives the docs-transpiler's schema-scoped
+    // attribute walk (unmodeled attributes are silently dropped there —
+    // verified live: `<table-toolbar-ui size="sm">` authored in
+    // table-toolbar.examples.html rendered with no [size] attribute at
+    // all on the generated site-a2ui page until this was added) and so
+    // `el.size = 'sm'` works from JS, matching card-ui/button-ui's own
+    // `size` property shape.
+    size:        { type: String,  default: '',         reflect: true },
     text:        { type: String,  default: '',         reflect: false },
     count:       { type: String,  default: '',         reflect: false },
     rangeStart:  { type: Number,  default: 0,          reflect: true, attribute: 'range-start' },
     rangeEnd:    { type: Number,  default: 0,          reflect: true, attribute: 'range-end' },
     rangeTotal:  { type: Number,  default: 0,          reflect: true, attribute: 'range-total' },
+    // gh#1877/ADR-0082 Amendment — same-name mirrors of table-footer-ui's
+    // own range-of/range-noun (ADR-0082 §"same name on both companions"):
+    // range-of is the secondary whole-set total ("filtered-of-whole"),
+    // range-noun the optional per-slice noun. Both presence-gated.
+    rangeOf:     { type: Number,  default: 0,          reflect: true, attribute: 'range-of' },
+    rangeNoun:   { type: String,  default: '',         reflect: true, attribute: 'range-noun' },
     pageSize:    { type: Number,  default: 0,          reflect: true, attribute: 'page-size' },
     noFilter:    { type: Boolean, default: false,      reflect: true, attribute: 'no-filter' },
     noSort:      { type: Boolean, default: false,      reflect: true, attribute: 'no-sort' },
@@ -167,6 +187,13 @@ export class UITableToolbar extends UIElement {
     // above. Pure, absolute OR: see #updateControlVisibility(), which is the
     // single place that combines chromeOnly with each granular no-* value.
     chromeOnly:  { type: Boolean, default: false,      reflect: true, attribute: 'chrome-only' },
+    // gh#1879 — opt-out for the scope-reconciliation title hide
+    // (table-toolbar.css's `:scope:not([title-always]):has([data-scope]:not(:empty))
+    // [data-title] { display: none; }`). Presence-only: the CSS rule reads
+    // the reflected attribute directly, so no JS branch is needed here
+    // beyond the standard Boolean reflect declaration (same shape as
+    // noFilter/noSort/noColumns/noSearch/chromeOnly above).
+    titleAlways: { type: Boolean, default: false,      reflect: true, attribute: 'title-always' },
     placeholder: { type: String,  default: 'Search...', reflect: false },
     variant:     { type: String,  default: 'default',  reflect: true },
     // ADR-0076 REQ-O-001 — explicit compaction-stage override. Unset (the
@@ -233,6 +260,27 @@ export class UITableToolbar extends UIElement {
 
   connected() {
     this.setAttribute('role', 'toolbar');
+    // `size` (declared above, reflect: true) defaults to '' — the base
+    // property system's own reflect pass (core/element.js) deliberately
+    // does NOT auto-stamp a non-empty string/number default onto the DOM
+    // (gh#961: scoped to Boolean-true defaults only, to avoid a
+    // framework-wide `attr=""`-stamping cascade), so a bare
+    // `<table-toolbar-ui>` never actually gets a `[size]` attribute from
+    // the default alone. Stamped explicitly, once, HERE — sizing.css's
+    // `[size="sm"]` is a plain unscoped attribute selector that needs the
+    // literal attribute present to set the ambient `--a-size`/`--a-ui-size`
+    // tokens at all. Every native control this component stamps below
+    // (badge, search, page-size select, granular buttons, overflow
+    // trigger) is a light-DOM descendant with no `[size]` of its own, so
+    // it inherits those tokens the same way any plain
+    // `<div size="sm">…</div>` cascades to its children — no per-child
+    // `size=` stamping needed (tried first, reverted: redundant with what
+    // inheritance already does for every element still in this light-DOM
+    // subtree, and actively wrong once a consumer sets an explicit
+    // `size="lg"` after connect — the per-child copies would go stale
+    // since nothing re-stamps them on a later property change, while
+    // inheritance updates live).
+    if (!this.hasAttribute('size')) this.setAttribute('size', this.size || 'sm');
     this.#warnUnknownOptOutAttrs();
     // gh#1615 — hydrate `page-size-options="[10,25,50]"` once at connect,
     // same pattern as table-ui's `data`/`columns` JSON-array attributes
@@ -307,7 +355,7 @@ export class UITableToolbar extends UIElement {
   // value 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.#updateSummary();
+    if (name === 'range-total' || name === 'range-of' || name === 'range-noun') this.#updateSummary();
     // ADR-0076 REQ-M-005 — the SECOND of the two triggers `data-stage-
     // resolved` must react to: a live resize (the ResizeObserver callback
     // above) AND a `stage` attribute change alone, with no resize needed.
@@ -479,6 +527,26 @@ export class UITableToolbar extends UIElement {
 
   // ── DOM stamp ────────────────────────────────────────────────────────────
 
+  // Used ONLY for the two stamped elements that end up OUTSIDE
+  // table-toolbar-ui's own light DOM — the popover-panel action buttons
+  // (#mkPopoverAction) and the filter-input (#fillFilterPanel), both
+  // appended to `document.body` for the Popover API's top-layer promotion
+  // (#togglePopover) — so ambient CSS inheritance from the host's own
+  // `[size]` attribute (stamped once in connected(), above) can never
+  // reach them. Every OTHER stamped control (badge, search, page-size
+  // select, granular Filter/Sort/Columns buttons, the overflow trigger)
+  // stays in the host's own light DOM and inherits that ambient value
+  // directly — no per-element `size=` copy needed, and no risk of one
+  // going stale after a later `.size =` change the way an explicit copy
+  // would (tried first, reverted: every in-tree control hardcoded
+  // `size="sm"` unconditionally, which not only ignored a consumer's
+  // `size="lg"` but also fought its OWN copy going stale on any later
+  // property change nothing re-stamped). Falls back to "sm" (the
+  // pre-existing hardcoded default) when `size` is unset.
+  #stampSize() {
+    return this.size || 'sm';
+  }
+
   #stamp() {
     if (this.querySelector(':scope > [data-toolbar]')) return;
 
@@ -509,7 +577,8 @@ export class UITableToolbar extends UIElement {
 
     const badge = document.createElement('badge-ui');
     badge.setAttribute('data-toolbar-count-badge', '');
-    badge.setAttribute('size', 'sm');
+    // No own [size] — inherits the host's ambient --a-size (stamped in
+    // connected(), above).
     badge.setAttribute('tone', 'muted');
     badge.hidden = true;
     title.appendChild(badge);
@@ -577,7 +646,7 @@ export class UITableToolbar extends UIElement {
     // name renders as literal text before the icon registry resolves.
     const search = document.createElement('search-ui');
     search.setAttribute('data-search', '');
-    search.setAttribute('size', 'sm');  // match toolbar buttons + badge + filter chips
+    // No own [size] — inherits the host's ambient --a-size, same as badge.
     search.setAttribute('placeholder', this.placeholder);
     search.setAttribute('debounce', String(SEARCH_DEBOUNCE));
     search.addEventListener('search', this.#onSearch);
@@ -590,7 +659,7 @@ export class UITableToolbar extends UIElement {
     // existing default behavior for consumers that never set pageSizeOptions.
     const pageSize = document.createElement('select-ui');
     pageSize.setAttribute('data-page-size', '');
-    pageSize.setAttribute('size', 'sm');
+    // No own [size] — inherits the host's ambient --a-size, same as badge.
     pageSize.setAttribute('aria-label', 'Rows per page');
     pageSize.hidden = true;
     pageSize.addEventListener('change', this.#onPageSizeChange);
@@ -645,7 +714,12 @@ export class UITableToolbar extends UIElement {
     btn.setAttribute('data-popover-action', '');
     btn.setAttribute('text', label);
     btn.setAttribute('variant', 'ghost');
-    btn.setAttribute('size', 'sm');
+    // Explicit [size] IS still needed here, unlike the in-tree stamped
+    // controls above — #togglePopover appends this button's panel straight
+    // to `document.body` (Popover API top-layer promotion), not nested
+    // inside table-toolbar-ui in the DOM, so ambient CSS inheritance from
+    // the host's own [size] never reaches it.
+    btn.setAttribute('size', this.#stampSize());
     btn.setAttribute('stretch', '');
     btn.addEventListener('click', onClick);
     return btn;
@@ -657,7 +731,7 @@ export class UITableToolbar extends UIElement {
     btn.setAttribute('icon', icon);
     btn.setAttribute('text', label);
     btn.setAttribute('variant', 'outline');
-    btn.setAttribute('size', 'sm');
+    // No own [size] — inherits the host's ambient --a-size, same as badge.
     btn.setAttribute('aria-haspopup', 'menu');
     // ADR-0076 REQ-X-002 — unconditional (harmless at full-text stages,
     // becomes the hover-tooltip affordance at the icon-only stage once
@@ -689,7 +763,7 @@ export class UITableToolbar extends UIElement {
     trigger.setAttribute('slot', 'trigger');
     trigger.setAttribute('icon', 'dots-three-vertical');
     trigger.setAttribute('variant', 'outline');
-    trigger.setAttribute('size', 'sm');
+    // No own [size] — inherits the host's ambient --a-size, same as badge.
     // REQ-X-003 — a genuinely new interactive element (not a repurposed
     // existing button), so it needs its own static accessible name rather
     // than an inherited one. No [text] attribute — always icon-only,
@@ -788,13 +862,45 @@ export class UITableToolbar extends UIElement {
     const end = Number(this.rangeEnd) || 0;
     const total = Number(this.rangeTotal) || 0;
 
+    // gh#1877/ADR-0082 Amendment — same open/unproven-total discipline as
+    // table-footer-ui's own #draw(): 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) — 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), and that's what tells "unknown yet" apart from a
+    // confirmed range-total="0" (a finite 0).
+    const rangeOpen = !Number.isFinite(Number(this.rangeTotal));
+    // gh#1877/ADR-0082 Amendment — additive suffixes onto the normal
+    // finite "of N" text; range-of (secondary whole-set total) never
+    // applies to the open-total branch (no finite total to append against).
+    const hasRangeOf = this.hasAttribute('range-of');
+    const rangeOfVal = hasRangeOf ? (Number(this.rangeOf) || 0) : 0;
+    const rangeOfSuffix = hasRangeOf && rangeOfVal > 0 ? ` (of ${rangeOfVal} total)` : '';
+    const nounSuffix = this.rangeNoun ? ` ${this.rangeNoun}` : '';
+
+    if (rangeOpen && start > 0 && end > 0) {
+      // REQ-open (gh#1877/ADR-0082 Amendment) — "Showing X–Y" with no
+      // "of N"; the short-form mirrors it minus the "Showing " prefix,
+      // same paired-population discipline as the finite branch below.
+      if (text) text.textContent = `Showing ${start}–${end}${nounSuffix}`;
+      if (text) text.hidden = false;
+      if (compact) compact.textContent = `${start}–${end}`;
+      if (compact) compact.hidden = false;
+      if (empty) empty.hidden = true;
+      summary.hidden = false;
+      return;
+    }
+
     if (start > 0 && end > 0 && total > 0) {
       // Normal range text — always wins over the empty slot (AC-014).
       // Both the full ("Showing X–Y of N") and short-form ("X–Y/N", ADR-0076
       // REQ-S-003) strings are populated together — which one paints is a
       // pure CSS decision (icon-only @container rule / [stage] pin), never
       // a JS branch (REQ-M-002).
-      if (text) text.textContent = `Showing ${start}–${end} of ${total}`;
+      if (text) text.textContent = `Showing ${start}–${end} of ${total}${nounSuffix}${rangeOfSuffix}`;
       if (text) text.hidden = false;
       if (compact) compact.textContent = `${start}–${end}/${total}`;
       if (compact) compact.hidden = false;
@@ -1085,7 +1191,9 @@ export class UITableToolbar extends UIElement {
       } else {
         const input = document.createElement('input-ui');
         input.setAttribute('type', 'text');
-        input.setAttribute('size', 'sm');
+        // Explicit [size] needed — this panel is appended straight to
+        // document.body (see #mkPopoverAction's comment above).
+        input.setAttribute('size', this.#stampSize());
         input.setAttribute('data-filter-input', '');
         input.setAttribute('placeholder', '—');
         if (current?.op === 'contains') input.value = current.value ?? '';