@mono-lit/helper 0.0.6 → 0.0.7

package/dist/{mono-form-controller-BkMR8g14.js → mono-form-controller-BrA10erm.js}

@@ -179,6 +179,9 @@ function monoForm(options) {
 	const state = {};
 	/** Props pushed at runtime by the `setProp()` METHOD (watchers / outside code). */
 	const dynamicProps = {};
+	const mergedProps = {};
+	/** Keys whose `dynamicProps` moved since their merged props were cached. */
+	const propsDirty = /* @__PURE__ */ new Set();
 	const elements = {};
 	for (const key of keys) {
 		const initial = inputs[key].value;
@@ -212,10 +215,14 @@ function monoForm(options) {
 	* it is merged LAST over whatever the `setProp()` method has accumulated.
 	*/
 	function propsFor(key) {
+		const hit = mergedProps[key];
+		if (hit && !propsDirty.has(key)) return hit;
 		const merged = {
 			...dynamicProps[key] ?? {},
 			...inputs[key]?.props ?? {}
 		};
+		mergedProps[key] = merged;
+		propsDirty.delete(key);
 		state[key] && (state[key].props = merged);
 		return merged;
 	}
@@ -320,7 +327,10 @@ function monoForm(options) {
 			bag[p] = v;
 			changed = true;
 		}
-		if (changed) notify();
+		if (changed) {
+			propsDirty.add(arg.key);
+			notify();
+		}
 	}
 	function setValidation(arg) {
 		const item = state[arg?.key];
@@ -352,6 +362,7 @@ function monoForm(options) {
 			};
 			state[key].touched = false;
 			dynamicProps[key] = {};
+			propsDirty.add(key);
 		}
 		notify();
 	}

package/dist/{mono-ui-KOBJcnXk.js → mono-ui-kvLVIf1V.js}

@@ -479,9 +479,11 @@ function headerWidth(cell, host) {
 * One auto-sized column, owned by its `mono-table-th`. `schedule()` coalesces every trigger (a
 * controller notify, a body mutation, typing in an editor) into one measurement per frame.
 */
-var ColumnAutoSize = class {
+var ColumnAutoSize = class ColumnAutoSize {
 	constructor(host) {
 		this.host = host;
+		this.growOnly = false;
+		this._floor = 0;
 		this._raf = 0;
 		this._onInput = (e) => {
 			const t = e.target;
@@ -492,16 +494,37 @@ var ColumnAutoSize = class {
 			this.schedule();
 		};
 	}
+	static {
+		this._queued = /* @__PURE__ */ new Set();
+	}
+	static {
+		this._frame = 0;
+	}
+	static _flush() {
+		ColumnAutoSize._frame = 0;
+		const batch = [...ColumnAutoSize._queued];
+		ColumnAutoSize._queued.clear();
+		const writes = batch.map((s) => {
+			s._raf = 0;
+			return s._measure();
+		});
+		for (const write of writes) write?.();
+	}
 	schedule() {
 		if (this._raf) return;
-		this._raf = requestAnimationFrame(() => {
-			this._raf = 0;
-			this._run();
-		});
+		this._raf = 1;
+		ColumnAutoSize._queued.add(this);
+		ColumnAutoSize._frame ||= requestAnimationFrame(() => ColumnAutoSize._flush());
+	}
+	/** Forget the grow-only floor (new rows) and re-measure. */
+	resetFloor() {
+		if (!this._floor) return;
+		this._floor = 0;
+		this.schedule();
 	}
 	/** Stop watching, and hand the column back to whatever width it is given next. */
 	stop(clear = false) {
-		if (this._raf) cancelAnimationFrame(this._raf);
+		ColumnAutoSize._queued.delete(this);
 		this._raf = 0;
 		this._unwatch();
 		if (clear && this._wrote) {
@@ -533,10 +556,11 @@ var ColumnAutoSize = class {
 		document.fonts?.removeEventListener?.("loadingdone", this._onFonts);
 		this._table = void 0;
 	}
-	_run() {
+	/** Measure now (reads only); returns the write to apply after every sizer has measured. */
+	_measure() {
 		const cell = this.host.closest("th, td");
 		const table = cell?.closest("table");
-		if (!cell || !table || !this.host.isConnected) return;
+		if (!cell || !table || !this.host.isConnected) return null;
 		this._watch(table);
 		const index = headerColumnIndex(cell);
 		let width = headerWidth(cell, this.host);
@@ -546,13 +570,17 @@ var ColumnAutoSize = class {
 			if (target) width = Math.max(width, contentWidth(target));
 		}
 		width = Math.ceil(clampWidth(width + 1, this.min, this.max));
+		if (this.growOnly) width = this._floor = Math.max(width, this._floor);
+		else this._floor = 0;
 		const value = `${width}px`;
 		const col = colAt(table, index);
-		if (cell.style.width !== value) cell.style.width = value;
-		if (col && col.style.width !== value) col.style.width = value;
-		this._wrote = {
-			col,
-			cell
+		return () => {
+			if (cell.style.width !== value) cell.style.width = value;
+			if (col && col.style.width !== value) col.style.width = value;
+			this._wrote = {
+				col,
+				cell
+			};
 		};
 	}
 };
@@ -621,10 +649,10 @@ function startMonoSizeAttributes() {
 					applyMonoSizeAttributes(r.target);
 					continue;
 				}
-				for (const node of Array.from(r.addedNodes)) if (node.nodeType === 1) scan(node);
+				for (const node of Array.from(r.addedNodes)) if (node.nodeType === 1 && node.isConnected) scan(node);
 				if (r.removedNodes.length) removed = true;
 			}
-			if (removed) sweep();
+			if (removed && sizers.size) sweep();
 		});
 		observer.observe(document.documentElement, {
 			subtree: true,

package/dist/{popup-portal-C8ttHDRX.js → popup-portal-CINuVjNY.js}

@@ -233,6 +233,8 @@ var PopupPortalController = class {
 		this._classObserver = null;
 		this._viewportBound = false;
 		this._viewportFrame = 0;
+		this._wasOpen = false;
+		this._sizeObserver = null;
 		this._onViewport = () => {
 			if (!this.opts.isOpen() || this._viewportFrame) return;
 			this._viewportFrame = requestAnimationFrame(() => {
@@ -254,24 +256,65 @@ var PopupPortalController = class {
 	hostDisconnected() {
 		this._unbindViewport();
 		this._leaveStack();
+		this._unobserveSize();
+		this._wasOpen = false;
 		this._classObserver?.disconnect();
 		this._classObserver = null;
 		if (this._portal?.parentNode) this._portal.parentNode.removeChild(this._portal);
 		this._portal = null;
 		this._adopted = false;
 	}
+	/**
+	* Position SYNCHRONOUSLY only on the open edge; every later update of an open popup is
+	* coalesced into one frame (`scheduleReposition`), and the custom-property carry-over
+	* (`_syncPortalVars`, two `getComputedStyle`) runs on the open edge only.
+	*
+	* `reposition()` is a write-then-read forced layout, and hosts update constantly while open —
+	* every keystroke in a search box, every arrow-key cursor move, every controller notify — so
+	* running it per update cost one synchronous layout each. A frame callback still runs before
+	* that frame paints, so nothing visibly lags; a panel whose content resizes WITHOUT a host
+	* update (a consumer re-rendering its rows) is caught by the ResizeObserver instead.
+	*/
 	hostUpdated() {
 		if (isServer) return;
 		if (this.opts.isOpen()) {
+			const opening = !this._wasOpen;
+			this._wasOpen = true;
 			this._adopt();
 			this._enterStack();
-			this._syncPortalClass();
-			this.reposition();
+			if (opening) {
+				this._syncPortalClass();
+				this.reposition();
+				this._observeSize();
+			} else {
+				this._syncPortalClass(false);
+				this.scheduleReposition();
+			}
 		} else {
+			this._wasOpen = false;
+			this._unobserveSize();
 			this._leaveStack();
-			this._syncPortalClass();
+			this._syncPortalClass(false);
 		}
 	}
+	/** Reposition when the panel or its anchor changes size while open (content, chips wrapping). */
+	_observeSize() {
+		if (this._sizeObserver || typeof ResizeObserver === "undefined") return;
+		const panel = this._panel ?? this.opts.getPanel();
+		const anchor = this.opts.getAnchor();
+		if (!panel && !anchor) return;
+		this._sizeObserver = new ResizeObserver(() => this.scheduleReposition());
+		if (panel) this._sizeObserver.observe(panel);
+		if (anchor) this._sizeObserver.observe(anchor);
+	}
+	_unobserveSize() {
+		this._sizeObserver?.disconnect();
+		this._sizeObserver = null;
+	}
+	/** Reposition on the next frame, coalesced with any viewport movement already pending. */
+	scheduleReposition() {
+		this._onViewport();
+	}
 	/**
 	* Only relocate to `<body>` when the host renders into light DOM
 	* (`renderRoot === host`). Shadow hosts keep the panel in their shadow root.
@@ -307,8 +350,12 @@ var PopupPortalController = class {
 		this._panel = panel;
 		this._adopted = true;
 	}
-	/** Mirror the style-scope element's classes and `mono-*` attributes onto the portal. */
-	_syncPortalClass() {
+	/**
+	* Mirror the style-scope element's classes and `mono-*` attributes onto the portal.
+	* `withVars` also carries the custom properties across — a computed-style read, so only on
+	* the open edge and on a scope attribute change, not on every host update.
+	*/
+	_syncPortalClass(withVars = true) {
 		if (!this._portal) return;
 		const scope = this.opts.getStyleScope();
 		const cls = scope?.getAttribute("class") ?? "";
@@ -320,7 +367,7 @@ var PopupPortalController = class {
 		}
 		for (const a of Array.from(this._portal.attributes)) if (mirrored(a.name) && !wanted.has(a.name)) this._portal.removeAttribute(a.name);
 		for (const [name, value] of wanted) if (this._portal.getAttribute(name) !== value) this._portal.setAttribute(name, value);
-		this._syncPortalVars(scope);
+		if (withVars) this._syncPortalVars(scope);
 	}
 	/**
 	* Carry the component's public custom properties across the portal (see

package/dist/src/components/accordion/mono-accordion.d.ts

@@ -15,7 +15,6 @@ declare const MonoAccordion_base: Constructor<MonoAccordionCoreInterface> & type
  * Both register `mono-accordion`, so a document loads only one.
  */
 export declare class MonoAccordion extends MonoAccordion_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotObserver?;
   private _slotTitle;

package/dist/src/components/alert/mono-alert.d.ts

@@ -18,7 +18,6 @@ declare const MonoAlert_base: Constructor<MonoAlertCoreInterface> & typeof LitEl
  * rendered, and their captured nodes are parked (kept parented, invisible).
  */
 export declare class MonoAlert extends MonoAlert_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotsCaptured;
   private _buckets;

package/dist/src/components/breadcrumb/mono-breadcrumb-list.d.ts

@@ -16,7 +16,6 @@ declare const MonoBreadcrumbList_base: Constructor<MonoBreadcrumbListCoreInterfa
  *     (`@mono-lit/helper/ui/shadow/breadcrumb`) supports standalone only.
  */
 export declare class MonoBreadcrumbList extends MonoBreadcrumbList_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _parent;
   connectedCallback(): void;

package/dist/src/components/breadcrumb/mono-breadcrumb.d.ts

@@ -18,7 +18,6 @@ declare const MonoBreadcrumb_base: Constructor<MonoBreadcrumbCoreInterface> & ty
  * so a document loads only one.
  */
 export declare class MonoBreadcrumb extends MonoBreadcrumb_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotsCaptured;
   private _hasBodySlot;

package/dist/src/components/button/mono-button-dropdown.d.ts

@@ -17,7 +17,6 @@ declare const MonoButtonDropdown_base: Constructor<MonoButtonDropdownCoreInterfa
  * build shares it and only swaps the embedded button's tag.
  */
 export declare class MonoButtonDropdown extends MonoButtonDropdown_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   /**
    * The panel is a STATIC element here, not something a helper returns.

package/dist/src/components/button/mono-button.d.ts

@@ -22,7 +22,6 @@ declare const MonoButton_base: Constructor<MonoButtonCoreInterface> & typeof Lit
  * document loads only one.
  */
 export declare class MonoButton extends MonoButton_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _buckets;
   private _slotsCaptured;

package/dist/src/components/card/mono-card.d.ts

@@ -24,7 +24,6 @@ declare const MonoCard_base: Constructor<MonoCardCoreInterface> & typeof LitElem
  * same document.
  */
 export declare class MonoCard extends MonoCard_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotsCaptured;
   private _buckets;

package/dist/src/components/chart/mono-chart-presets.d.ts

@@ -6,7 +6,6 @@ import { LitElement, TemplateResult } from "lit";
 declare const MonoChartBar_base: Constructor<MonoChartCoreInterface> & typeof LitElement;
 /** `<mono-chart-bar>` — vertical bars. */
 export declare class MonoChartBar extends MonoChartBar_base {
-  static styles: import("lit").CSSResult[];
   protected _presetType: MonoChartType;
   protected createRenderRoot(): HTMLElement;
   protected render(): TemplateResult;
@@ -14,7 +13,6 @@ export declare class MonoChartBar extends MonoChartBar_base {
 declare const MonoChartLine_base: Constructor<MonoChartCoreInterface> & typeof LitElement;
 /** `<mono-chart-line>` — a line series. */
 export declare class MonoChartLine extends MonoChartLine_base {
-  static styles: import("lit").CSSResult[];
   protected _presetType: MonoChartType;
   protected createRenderRoot(): HTMLElement;
   protected render(): TemplateResult;
@@ -22,7 +20,6 @@ export declare class MonoChartLine extends MonoChartLine_base {
 declare const MonoChartPie_base: Constructor<MonoChartCoreInterface> & typeof LitElement;
 /** `<mono-chart-pie>` — pie slices. */
 export declare class MonoChartPie extends MonoChartPie_base {
-  static styles: import("lit").CSSResult[];
   protected _presetType: MonoChartType;
   protected createRenderRoot(): HTMLElement;
   protected render(): TemplateResult;
@@ -30,7 +27,6 @@ export declare class MonoChartPie extends MonoChartPie_base {
 declare const MonoChartDoughnut_base: Constructor<MonoChartCoreInterface> & typeof LitElement;
 /** `<mono-chart-doughnut>` — a pie with a hole. */
 export declare class MonoChartDoughnut extends MonoChartDoughnut_base {
-  static styles: import("lit").CSSResult[];
   protected _presetType: MonoChartType;
   protected createRenderRoot(): HTMLElement;
   protected render(): TemplateResult;

package/dist/src/components/chart/mono-chart.d.ts

@@ -21,7 +21,6 @@ declare const MonoChart_base: Constructor<MonoChartCoreInterface> & typeof LitEl
  * ```
  */
 export declare class MonoChart extends MonoChart_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   protected render(): TemplateResult;
 }

package/dist/src/components/checkbox/mono-checkbox.d.ts

@@ -17,7 +17,6 @@ declare const MonoCheckbox_base: Constructor<MonoCheckboxCoreInterface> & typeof
  * document loads only one.
  */
 export declare class MonoCheckbox extends MonoCheckbox_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotsCaptured;
   private _slotIcon;

package/dist/src/components/chip/mono-chip.d.ts

@@ -21,7 +21,6 @@ declare const MonoChip_base: Constructor<MonoChipCoreInterface> & typeof LitElem
  * only one.
  */
 export declare class MonoChip extends MonoChip_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _buckets;
   private _slotsCaptured;

package/dist/src/components/date/mono-date.d.ts

@@ -14,7 +14,6 @@ declare const MonoDate_base: Constructor<MonoDateCoreInterface> & typeof LitElem
  * `mono-date`, so a document loads one.
  */
 export declare class MonoDate extends MonoDate_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
 }
 declare global {

package/dist/src/components/drawer/mono-drawer.d.ts

@@ -17,7 +17,6 @@ declare const MonoDrawer_base: Constructor<MonoDrawerCoreInterface> & typeof Lit
  * `mono-drawer.shadow.ts`; all logic is shared via `MonoDrawerCore`.
  */
 export declare class MonoDrawer extends MonoDrawer_base {
-  static styles: import("lit").CSSResult[];
   private _portal;
   private _appliedPortalClasses;
   private _slotHeader;

package/dist/src/components/dropdown/mono-dropdown.d.ts

@@ -15,7 +15,6 @@ declare const MonoDropdown_base: Constructor<MonoDropdownCoreInterface> & typeof
  * `<slot>`. Both register `mono-dropdown`, so a document loads only one.
  */
 export declare class MonoDropdown extends MonoDropdown_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _hasBodySlotState;
   private _slotsCaptured;

package/dist/src/components/dropdown-table/mono-dropdown-table.d.ts

@@ -30,7 +30,6 @@ declare const MonoDropdownTable_base: Constructor<MonoDropdownTableCoreInterface
  * </mono-dropdown-table>
  */
 export declare class MonoDropdownTable extends MonoDropdownTable_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotsCaptured;
   private _slotSearch;

package/dist/src/components/file-upload/mono-file-upload.d.ts

@@ -17,7 +17,6 @@ declare const MonoFileUpload_base: Constructor<MonoFileUploadCoreInterface> & ty
  * `mono-file-upload`, so a document loads only one.
  */
 export declare class MonoFileUpload extends MonoFileUpload_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotsCaptured;
   private _slots;

package/dist/src/components/filter/mono-filter-builder.d.ts

@@ -11,7 +11,6 @@ declare const MonoFilterBuilder_base: Constructor<MonoFilterBuilderCoreInterface
  * the same global `dist/ui/index.css` — so no extra stylesheet is needed here.
  */
 export declare class MonoFilterBuilder extends MonoFilterBuilder_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   protected renderIcon(name: FilterIconName): TemplateResult;
 }

package/dist/src/components/input/mono-input.d.ts

@@ -15,7 +15,6 @@ declare const MonoInput_base: Constructor<MonoInputCoreInterface> & typeof LitEl
  * `<slot>`. Both register `mono-input`, so a document loads only one.
  */
 export declare class MonoInput extends MonoInput_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotPrefix;
   private _slotSuffix;

package/dist/src/components/menu/mono-menu.d.ts

@@ -13,7 +13,6 @@ declare const MonoMenu_base: Constructor<MonoMenuCoreInterface> & typeof LitElem
  * lives in `MonoMenuCore`.
  */
 export declare class MonoMenu extends MonoMenu_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotsCaptured;
   private _hasBodySlot;

package/dist/src/components/modal/mono-modal.d.ts

@@ -17,7 +17,6 @@ declare const MonoModal_base: Constructor<MonoModalCoreInterface> & typeof LitEl
  * `mono-modal.shadow.ts`; all logic is shared via `MonoModalCore`.
  */
 export declare class MonoModal extends MonoModal_base {
-  static styles: import("lit").CSSResult[];
   private _portal;
   private _appliedPortalClasses;
   private _slotHead;

package/dist/src/components/nav/mono-nav.d.ts

@@ -17,7 +17,6 @@ declare const MonoNav_base: Constructor<MonoNavCoreInterface> & typeof LitElemen
  * given document must load only one of the two builds.
  */
 export declare class MonoNav extends MonoNav_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotsCaptured;
   private _slotNodes;

package/dist/src/components/otp/mono-otp.d.ts

@@ -12,7 +12,6 @@ declare const MonoOtp_base: Constructor<MonoOtpCoreInterface> & typeof LitElemen
  * build (`mono-shadow-otp`) shares it with native `<slot>`s.
  */
 export declare class MonoOtp extends MonoOtp_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slots;
   private _slotObserver?;

package/dist/src/components/radio/mono-radio.d.ts

@@ -16,7 +16,6 @@ declare const MonoRadio_base: Constructor<MonoRadioCoreInterface> & typeof LitEl
  * document loads only one.
  */
 export declare class MonoRadio extends MonoRadio_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotsCaptured;
   private _slotLabel;

package/dist/src/components/rich-text-editor/mono-rich-text-editor.d.ts

@@ -16,7 +16,6 @@ declare const MonoRichTextEditor_base: Constructor<MonoRichTextEditorCoreInterfa
  * `MonoRichTextEditorCore`.
  */
 export declare class MonoRichTextEditor extends MonoRichTextEditor_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotsCaptured;
   private _slotLabel;

package/dist/src/components/select/mono-select.d.ts

@@ -15,7 +15,6 @@ declare const MonoSelect_base: Constructor<MonoSelectCoreInterface> & typeof Lit
  * register `mono-select`, so a document loads only one build.
  */
 export declare class MonoSelect extends MonoSelect_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotsCaptured;
   private _slotLabel;

package/dist/src/components/sidebar/mono-sidebar.d.ts

@@ -16,7 +16,6 @@ declare const MonoSidebar_base: Constructor<MonoSidebarCoreInterface> & typeof L
  * Both register `mono-sidebar`, so a document loads only one.
  */
 export declare class MonoSidebar extends MonoSidebar_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotsCaptured;
   private _slotHeader;

package/dist/src/components/slider/mono-slider.d.ts

@@ -12,7 +12,6 @@ declare const MonoSlider_base: Constructor<MonoSliderCoreInterface> & typeof Lit
  * `MonoSliderCore`; the shadow build (`mono-shadow-slider`) shares it with native `<slot>`s.
  */
 export declare class MonoSlider extends MonoSlider_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotLabel;
   private _slotHelper;

package/dist/src/components/switch/mono-switch.d.ts

@@ -16,7 +16,6 @@ declare const MonoSwitch_base: Constructor<MonoSwitchCoreInterface> & typeof Lit
  * Both register `mono-switch`, so a document loads only one.
  */
 export declare class MonoSwitch extends MonoSwitch_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotsCaptured;
   private _slotLabel;

package/dist/src/components/table/column-autosize.d.ts

@@ -53,6 +53,14 @@ export declare class ColumnAutoSize {
   private readonly host;
   min?: number;
   max?: number;
+  /**
+   * Never shrink — for a virtual-scroll table, whose body holds only the WINDOW of the rows: each
+   * window shift measured a different slice, so the column grew and shrank as the list scrolled and
+   * every change relaid the whole table. The column settles at the widest value seen instead, until
+   * `resetFloor()` (a new result set).
+   */
+  growOnly: boolean;
+  private _floor;
   private _raf;
   private _table?;
   private _observer?;
@@ -64,11 +72,25 @@ export declare class ColumnAutoSize {
    */
   private readonly _onFonts;
   constructor(host: HTMLElement);
+  /**
+   * Every sizer on the page shares ONE frame callback (`_flush`), which measures all of them
+   * first and writes all of them after.
+   *
+   * Each used to run in its own frame callback, measure-then-write: column A wrote its width,
+   * so column B's measurement (`getBoundingClientRect` on header icons, an SVG) forced a
+   * synchronous layout of the whole table — one per auto column, per frame.
+   */
+  private static _queued;
+  private static _frame;
+  private static _flush;
   schedule(): void;
+  /** Forget the grow-only floor (new rows) and re-measure. */
+  resetFloor(): void;
   /** Stop watching, and hand the column back to whatever width it is given next. */
   stop(clear?: boolean): void;
   private _watch;
   private _unwatch;
-  private _run;
+  /** Measure now (reads only); returns the write to apply after every sizer has measured. */
+  private _measure;
 }
 //#endregion

package/dist/src/components/table/mono-data-grid.d.ts

@@ -484,6 +484,12 @@ export interface MonoCheckHandle<T = any> {
   selectAll(): Promise<void>;
   /** Empty the selection. */
   clear(): void;
+  /**
+   * Increments on every selection notify — tick, untick (even a rejected one), page / all
+   * select, replace, clear, and the drain's start / end. Compare it to tell "the selection
+   * moved" from the grid's other notifies (a load, a virtual-scroll window shift).
+   */
+  readonly version: number;
   /** Whether a `selectAll()` drain is in flight. */
   readonly pending: boolean;
   /** Every loaded row is selected (and there is at least one). */

package/dist/src/components/table/mono-table-checkbox.d.ts

@@ -26,7 +26,6 @@ declare const MonoTableCheckbox_base: Constructor<MonoTableCheckboxCoreInterface
  * table.check().getAll()   // [{ Id: 8 }, { Id: 12 }, … ]
  */
 export declare class MonoTableCheckbox extends MonoTableCheckbox_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
 }
 declare global {

package/dist/src/components/table/mono-table-detail.d.ts

@@ -24,7 +24,6 @@ declare const MonoTableDetail_base: Constructor<MonoTableDetailCoreInterface> &
  * </tr>
  */
 export declare class MonoTableDetail extends MonoTableDetail_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
 }
 declare global {

package/dist/src/components/table/mono-table-empty.d.ts

@@ -22,7 +22,6 @@ declare const MonoTableEmpty_base: Constructor<MonoTableEmptyCoreInterface> & ty
  * INTO the host and would otherwise overwrite it.
  */
 export declare class MonoTableEmpty extends MonoTableEmpty_base {
-  static styles: import("lit").CSSResult[];
   private _buckets;
   private _slotsCaptured;
   protected createRenderRoot(): HTMLElement;

package/dist/src/components/table/mono-table-error.d.ts

@@ -20,7 +20,6 @@ declare const MonoTableError_base: Constructor<MonoTableErrorCoreInterface> & ty
  * which is exactly what a light build can use and a shadow one cannot.
  */
 export declare class MonoTableError extends MonoTableError_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
 }
 declare global {

package/dist/src/components/table/mono-table-info.d.ts

@@ -11,7 +11,6 @@ declare const MonoTableInfo_base: Constructor<MonoTableInfoCoreInterface> & type
  * so a document loads only one.
  */
 export declare class MonoTableInfo extends MonoTableInfo_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
 }
 declare global {

package/dist/src/components/table/mono-table-loading.d.ts

@@ -42,7 +42,6 @@ declare const MonoTableLoading_base: Constructor<MonoTableLoadingCoreInterface>
  * </div>
  */
 export declare class MonoTableLoading extends MonoTableLoading_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
 }
 declare global {

package/dist/src/components/table/mono-table-page-size.d.ts

@@ -8,7 +8,6 @@ declare const MonoTablePageSize_base: Constructor<MonoTablePageSizeCoreInterface
  * All logic lives in `MonoTablePageSizeCore`; the shadow build shares the mixin.
  */
 export declare class MonoTablePageSize extends MonoTablePageSize_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
 }
 declare global {