@gjsify/adwaita-nativescript 0.64.13-next.283 → 0.64.14

package/lib/types/widgets/label-markup-native.d.ts

@@ -0,0 +1,19 @@
+import type { LabelMarkupNativeText } from './label-markup.js';
+/**
+ * Record the markup `label` must draw natively, or clear it with `null` — answers whether
+ * this host draws its own styled text at all, so a caller can take the `FormattedString`
+ * path on the same condition it would take it on.
+ *
+ * A host that answers `true` here MUST answer `true` from {@link labelMarkupDrawNative}
+ * for as long as something is held, and the caller may rely on that: nothing re-reads the
+ * markup between the hold and the write.
+ */
+export declare function labelMarkupHoldNative(_label: object, _text: LabelMarkupNativeText | null): boolean;
+/**
+ * Draw the held markup into `label`'s native text view — `false` when there is nothing held
+ * or this host has no such text, and then the caller lets `TextBase._setNativeText` run.
+ *
+ * `reset` is the platform's own "clear the text" call, which no styled text can answer:
+ * it is always refused so the base implementation clears the view.
+ */
+export declare function labelMarkupDrawNative(_label: object, _reset: boolean): boolean;

package/lib/types/widgets/label-markup-native.ios.d.ts

@@ -0,0 +1,5 @@
+import type { LabelMarkupNativeText } from './label-markup.js';
+/** Record what `label` must draw natively — iOS draws none. See {@link labelMarkupHoldNative}. */
+export declare function labelMarkupHoldNative(_label: object, _text: LabelMarkupNativeText | null): boolean;
+/** Draw the held markup — iOS holds none. See {@link labelMarkupDrawNative}. */
+export declare function labelMarkupDrawNative(_label: object, _reset: boolean): boolean;

package/lib/types/widgets/label-markup.d.ts

@@ -1,5 +1,66 @@
 import { FormattedString, Span } from '@nativescript/core';
-import { type LabelMarkupRender, type LabelMarkupRun } from '@gjsify/adwaita-core';
+import { type LabelMarkupRender, type LabelMarkupRun, type LabelMarkupStyle } from '@gjsify/adwaita-core';
+/**
+ * The native FACE one run asks for: the typeface, the two lines, the baseline and the font
+ * factor, with pango's tags and `<span>` attributes already resolved against each other.
+ *
+ * WHY A SECOND SHAPE BESIDE {@link labelMarkupSpan}. A `Span` IS the shape on the surfaces
+ * that go through a `FormattedString`, so there the resolution and the write are one
+ * function. Android's spans are not a shape at all — `TypefaceSpan`, `StyleSpan`,
+ * `UnderlineSpan`, `RelativeSizeSpan` are independent objects over a RANGE of one
+ * builder — so the decisions have to be readable before anything native exists, which is
+ * also what makes them assertable off a device. `label-markup-native.android.ts` turns one
+ * face into those spans and decides nothing else.
+ *
+ * THE SCALE IS RELATIVE, which is what pango's is. `<big>` is a FACTOR
+ * (`PANGO_SCALE_LARGE`), so a platform with a relative span needs no base size and drops
+ * nothing — where the `Span` path's `fontSize` is an absolute number of DIPs and has to
+ * resolve the factor against a size something has written, which is why it SKIPS the scale
+ * when nothing has (see the header). The same markup is therefore more faithful on the
+ * native path, not differently faithful; the measured corpus has no `<big>`/`<small>` at
+ * all, so no label in it renders differently either way.
+ *
+ * THE WEIGHT LADDER COLLAPSES TO BOLD, declared rather than approximated: Android picks a
+ * weight with `Typeface.create(family, weight, italic)` from API 28 and has nothing but
+ * `Typeface.BOLD` below it, and this port supports API 24. So pango's named and numeric
+ * weights are read and answered as bold from {@link BOLD_FROM} up. `semilight`, `book` and
+ * `ultraheavy` are dropped, which is the same answer {@link SPAN_WEIGHTS} gives them.
+ */
+export interface LabelMarkupFace {
+    /** The typeface family, or `undefined` for the view's own. `<tt>` is `monospace`. */
+    readonly family: string | undefined;
+    readonly bold: boolean;
+    readonly italic: boolean;
+    readonly underline: boolean;
+    readonly strikethrough: boolean;
+    /** `<sub>` / `<sup>` — a baseline shift, not a size. */
+    readonly script: 'sub' | 'sup' | null;
+    /** The font factor `<big>`, `<small>`, `<sub>` and `<sup>` multiply up to. 1 means none. */
+    readonly scale: number;
+}
+/**
+ * One run's style as the face a native span-setter writes.
+ *
+ * The `<span>` attributes are read OUTERMOST FIRST and the pango tags after, so a tag wins
+ * a collision — the same declared order {@link labelMarkupSpan} applies, for the same
+ * reason: the runs record the tags as booleans and the `<span>`s as a separate stack, so
+ * neither renderer can know which element was inner.
+ */
+export declare function labelMarkupFace(style: LabelMarkupStyle, link: boolean): LabelMarkupFace;
+/**
+ * A label's markup as the platform half of this package has to DRAW it — everything
+ * `label-markup-native.ts` needs and nothing a `FormattedString` would add.
+ *
+ * `onLinkTap` rather than the links themselves: following a link is the widget's decision
+ * (`GtkLabel._activateLink` runs `::activate-link` under GTK's handled accumulator), and a
+ * span-setter that reached for `render.links[i].href` would be making it a second time.
+ */
+export interface LabelMarkupNativeText {
+    readonly render: LabelMarkupRender;
+    /** `use-underline` — whether the mnemonic marker is stripped out of each run's text. */
+    readonly mnemonics: boolean;
+    onLinkTap(index: number): void;
+}
 /**
  * One run as one `Span`.
  *

package/lib/types/widgets/menu-slot.d.ts

@@ -0,0 +1,40 @@
+import type { AdwMenuTree, GioMenuModel } from '@gjsify/adwaita-core';
+export declare class MenuSlot {
+    private readonly widget;
+    private readonly onItemsChanged;
+    private readonly _authored;
+    private _model;
+    private _tree;
+    private _unwatch;
+    /**
+     * @param widget the class name {@link refuseMenuString} names in its refusal.
+     * @param onItemsChanged what to do when the HELD menu mutates under the widget.
+     */
+    constructor(widget: string, onItemsChanged: () => void);
+    /** The model itself, by identity — what `menuModel` answers. */
+    get model(): GioMenuModel | null;
+    /** The snapshot `planPopupMenu` reads. Re-taken on each `items-changed`, never aliased. */
+    get tree(): AdwMenuTree;
+    /**
+     * Whether there is anything to show — NOT whether there is a menu.
+     *
+     * `null` and an empty `Gio.Menu` are different menus, and on GTK they behave
+     * differently: an empty non-null model still builds a `GtkPopoverMenu` (measured,
+     * `MENU_MODEL_DOOR_VECTORS`). A `PopupMenu` with no items draws no window at all, so
+     * this is the question the TAP asks, and the widgets ask `model === null` where GTK asks
+     * about the model.
+     */
+    get isEmpty(): boolean;
+    /**
+     * A property write: a real model by identity, `null` for no menu — and a `TypeError` for
+     * a string, an array or anything else, which this door does not take (`buildMenu` is how
+     * an array becomes a model now).
+     *
+     * The refusal is a THROW because a property assignment is a call: whoever wrote the
+     * menu is on the stack and can hear it. There is no second, quieter door here the way
+     * the browser has one for markup.
+     */
+    write(value: unknown): void;
+    /** Hold `next`, snapshot it, and listen to it — the three that always happen together. */
+    private _adopt;
+}

package/lib/types/widgets/popup-menu-view.d.ts

@@ -1,8 +1,9 @@
-import type { AdwMenuActions, AdwMenuItem, AdwMenuModel, AdwMenuPath } from '@gjsify/adwaita-core';
+import type { AdwMenuActions, AdwMenuItem, AdwMenuPath, AdwMenuTree } from '@gjsify/adwaita-core';
 import { type ActionHost } from './actions.js';
 import { type PopupMenuSurface } from './popup-menu.js';
 export interface MenuPopupOptions {
-    readonly model: AdwMenuModel;
+    /** The SNAPSHOT of the menu model, as `MenuSlot.tree` holds it (ADR 0128 § 3). */
+    readonly tree: AdwMenuTree;
     /** What the application wrote itself; absent, the registry above `anchor` answers. */
     readonly actions?: AdwMenuActions | null;
     /** A leaf item was chosen, after its action fired. */

package/lib/types/widgets/popup-menu.d.ts

@@ -1,4 +1,4 @@
-import type { AdwMenuActions, AdwMenuModel, AdwMenuPath, PopupMenuLevelPlan, PopupMenuPlan } from '@gjsify/adwaita-core';
+import type { AdwMenuActions, AdwMenuPath, AdwMenuTree, PopupMenuLevelPlan, PopupMenuPlan } from '@gjsify/adwaita-core';
 /** The `MenuItem` calls the driver makes. */
 export interface PopupMenuItemLike {
     setEnabled(enabled: boolean): unknown;
@@ -33,7 +33,8 @@ export declare const GROUP_DIVIDER_API = 28;
 export declare function fillPopupMenu(menu: PopupMenuLike, level: PopupMenuLevelPlan, apiLevel: number): Map<number, AdwMenuPath>;
 export interface OpenPopupMenuOptions {
     readonly surface: PopupMenuSurface;
-    readonly model: AdwMenuModel;
+    /** The SNAPSHOT of the menu model, as `MenuSlot.tree` holds it (ADR 0128 § 3). */
+    readonly tree: AdwMenuTree;
     /** What {@link resolveMenuItemState} reads; from `menuActionsFor` it is the registry's. */
     readonly actions?: AdwMenuActions;
     /** A tap on a leaf item, with its model path. Fire the action here (`activateMenuItem`). */
@@ -46,14 +47,15 @@ export interface OpenPopupMenuOptions {
  */
 export declare function openPopupMenu(options: OpenPopupMenuOptions): PopupMenuPlan;
 /**
- * Throw if `model` holds what `PopupMenu` can never draw, at the ASSIGNMENT: a `custom` item or a
+ * Throw if `tree` holds what `PopupMenu` can never draw, at the ASSIGNMENT: a `custom` item or a
  * section label. A radio run that shares a group needs the actions to be known, so it throws when
  * the menu is opened.
  */
-export declare function assertPopupMenuAssignable(model: AdwMenuModel): void;
+export declare function assertPopupMenuAssignable(tree: AdwMenuTree): void;
 /**
  * A JSON string is not a menu model here: NativeScript's XML Builder writes an attribute straight
- * onto the property, so accepting one would open an XML door nothing can prove, and
- * `normalizeMenuModel` would turn it into an EMPTY menu with nothing saying why.
+ * onto the property, so accepting one would open an XML door nothing can prove. Since ADR 0128
+ * the core's door DOES parse one — that is how the browser's `menu-model` attribute works — so
+ * this stays in front of it rather than relying on a refusal the shared door no longer makes.
  */
 export declare function refuseMenuString(value: unknown, widget: string): void;

package/lib/types/widgets/signals.d.ts

@@ -22,9 +22,9 @@ type Declared<P> = P & {
      */
     readonly normalize?: (value: unknown, self: object) => unknown;
     /**
-     * Replaces the equal-write check for this property on the PURE leg: `written` is the value as
-     * the caller spelled it, `next` what {@link Declared.normalize} made of it, `held` what the
-     * store holds — and the answer decides whether the write notifies at all.
+     * Replaces the equal-write check for this property: `written` is the value as the caller
+     * spelled it, `next` what {@link Declared.normalize} made of it, `held` what the store holds
+     * — and the answer decides whether the write notifies at all.
      *
      * WHY. A C setter guards on `g_strcmp0 (value, adw_…_get_…(self))`, against the GETTER
      * READBACK rather than the stored field. Where storage normalises, the two differ and the
@@ -33,12 +33,19 @@ type Declared<P> = P & {
      * libadwaita 1.9.4). Comparing the held value says the opposite, and only the property whose
      * `normalize` collapses distinct writes onto one held value can tell the difference.
      *
-     * The real leg has no use for it — there the guard IS the C one.
+     * RUNS ON BOTH LEGS. It used to run on the pure one alone, on the reasoning that "there the
+     * guard IS the C one" — which holds for a widget wrapping a real C object and not for a
+     * foreign-parent class, which has no C setter at all. On route D node-gi's generated setter
+     * is an identity guard and nothing more (`installForeignPropertyAccessors` in `gi.js`), so a
+     * property that left this to the real leg got the identity answer there and the measured one
+     * off-device — the per-leg difference this seam exists to close.
      */
     readonly changed?: (next: unknown, held: unknown, written: unknown, self: object) => boolean;
     /**
-     * The rest of the C setter, on the PURE leg: runs once this property's own `notify::<name>`
-     * is out, so a setter that also drives OTHER properties emits in the order C does.
+     * The rest of the C setter: runs once this property's own `notify::<name>` is out, so a
+     * setter that also drives OTHER properties emits in the order C does. For a property with
+     * {@link ForeignScalarProperty.explicitNotify} it runs INSTEAD of that notify, and owes every
+     * emission the write makes, its own included.
      *
      * WHY IT IS NOT `normalize`. A normalizer runs AHEAD of the store, so a cross-write made
      * there notifies before the property that caused it. `Adw.SplitButton` measures the other way
@@ -46,8 +53,9 @@ type Declared<P> = P & {
      * after — and the two cannot both be one hook. The SHAPE of a value still belongs to
      * `normalize`; what the write does to its siblings belongs here.
      *
-     * Not run on the real leg, where the C setter does this itself: a second pass would write the
-     * cleared slot a second time, and C answers a redundant `null` with a CRITICAL.
+     * RUNS ON BOTH LEGS, for the reason {@link Declared.changed} states: the foreign-parent class
+     * route D registers has no C setter to do this instead. `adw-split-button`'s label/icon-name
+     * mutual clear is the one that was silently missing on Android because of it.
      */
     readonly afterNotify?: (self: object) => void;
 };
@@ -223,4 +231,21 @@ export declare function withProperties<TBase extends ObservableConstructor>(Base
     /** Only what this class ADDS; `emittedSignalsOf` merges it with the base's. */
     readonly emittedSignals: readonly string[];
 }) & TBase;
+/**
+ * Write a declared property's held value WITHOUT notifying, and without running `normalize`,
+ * `changed` or `afterNotify` — the PUSH half of a property whose widget owns the emission.
+ *
+ * WHY A WIDGET NEEDS IT. A property whose value also moves from UNDERNEATH — the selection of an
+ * `Adw.ComboRow` when its model is replaced, or when the held model splices — cannot be kept in
+ * sync by writing it, because the write is the thing that emits and the emission order is
+ * measured and is not the order a write would produce. `model = null` is the sharpest case:
+ * `selected` goes to the sentinel and `selected-item` to null with NO notify at all, and `model`
+ * alone notifies. So the widget pushes the new value in here and emits what it owes with
+ * `notify('<name>')`, in the order it measured.
+ *
+ * Only a {@link isSeamOwned} property may be pushed, and a name that is not one THROWS rather
+ * than writing a store route D would never read back: there the value lives in the GObject, and
+ * a silent push would be correct off-device and invisible on the device.
+ */
+export declare function pushDeclared(self: object, name: string, value: unknown): void;
 export {};

package/lib/types/widgets/single-child-base.d.ts

@@ -4,8 +4,13 @@ export declare abstract class AdwSingleChildBase extends AdwStyledLayoutBase {
     private _child;
     constructor();
     private _columnIsStar;
+    private _rowIsStar;
     onLoaded(): void;
+    onUnloaded(): void;
+    private _onWidthChangeSyncColumn;
+    private _onHeightChangeSyncRow;
     private _syncColumnToAlignment;
+    private _syncRowToAlignment;
     /** The child, or `null`. */
     get child(): View | null;
     set child(view: View | null);

package/lib/types/widgets/single-child-cell.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Whether the single cell of a one-child container is `star` rather than `auto`, on ONE axis.
+ *
+ * `star` when the container's extent along that axis is settled — either because it stretches
+ * to its parent, or because a definite `width` / `height` was written on it. `auto` otherwise,
+ * so the container can still report its child's natural size and be placed by its alignment.
+ *
+ * TAKES NO AXIS, because there is nothing axis-specific left once the question is phrased that
+ * way: `'stretch'` is the stretching value of BOTH `horizontalAlignment` and
+ * `verticalAlignment`, and a settled `width` reads exactly like a settled `height`. The column
+ * passes `horizontalAlignment` + `width`, the row `verticalAlignment` + `height`.
+ */
+export declare function singleChildCellIsStar(alignment: unknown, length: unknown): boolean;

package/lib/types/widgets/xml-values.d.ts

@@ -6,6 +6,18 @@
  * caller can keep validating a RANGE without also having to re-check the type.
  */
 export declare function xmlNumber(value: unknown, fallback: number): number;
+/**
+ * The integer GtkBuilder reads out of an enum property's value, or `undefined` when the
+ * value is a nick or name.
+ *
+ * `_gtk_builder_enum_from_string` (gtk/gtkbuilder.c) tries the number FIRST
+ * (`g_ascii_strtoull (string, &endptr, 0)`, so base 0: decimal, `0x` hex, leading-`0` octal)
+ * and only then the nick and the name — which is why `halign="1"` and `halign="start"` are
+ * the same attribute in a `.ui` file. A JS number is the same reading, already parsed.
+ * GTK also accepts a numeric PREFIX (`"2abc"` is 2); the whole string must be a number here,
+ * so a nick that merely starts with a digit stays a nick.
+ */
+export declare function gtkBuilderInteger(value: unknown): number | undefined;
 /**
  * An attribute as a boolean.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gjsify/adwaita-nativescript",
-    "version": "0.64.13-next.283",
+    "version": "0.64.14",
     "description": "Native Adwaita widgets for the NativeScript runtime — real NativeScript components (StackLayout/GridLayout/Switch/Label) styled like Libadwaita, not a webview",
     "type": "module",
     "module": "lib/esm/index.js",
@@ -73,15 +73,15 @@
         "design-system"
     ],
     "dependencies": {
-        "@gjsify/adwaita-core": "0.64.13-next.283",
-        "@gjsify/adwaita-fonts": "0.64.13-next.283",
-        "@gjsify/adwaita-icons": "0.64.13-next.283",
-        "@gjsify/canvas2d-core": "0.64.13-next.283",
-        "@gjsify/native-platform": "0.64.13-next.283"
+        "@gjsify/adwaita-core": "^0.64.14",
+        "@gjsify/adwaita-fonts": "^0.64.14",
+        "@gjsify/adwaita-icons": "^0.64.14",
+        "@gjsify/canvas2d-core": "^0.64.14",
+        "@gjsify/native-platform": "^0.64.14"
     },
     "peerDependencies": {
         "@nativescript/core": "*",
-        "@gjsify/app-settings": "0.64.13-next.283"
+        "@gjsify/app-settings": "^0.64.14"
     },
     "peerDependenciesMeta": {
         "@nativescript/core": {
@@ -92,11 +92,11 @@
         }
     },
     "devDependencies": {
-        "@gjsify/app-settings": "0.64.13-next.283",
-        "@gjsify/blueprint": "0.64.13-next.283",
-        "@gjsify/cli": "0.64.13-next.283",
-        "@gjsify/unit": "0.64.13-next.283",
-        "@gjsify/vite-plugin-blueprint": "0.64.13-next.283",
+        "@gjsify/app-settings": "^0.64.14",
+        "@gjsify/blueprint": "^0.64.14",
+        "@gjsify/cli": "^0.64.14",
+        "@gjsify/unit": "^0.64.14",
+        "@gjsify/vite-plugin-blueprint": "^0.64.14",
         "@types/node": "^25.9.2",
         "typescript": "^6.0.3"
     },
@@ -125,6 +125,5 @@
     "bugs": {
         "url": "https://github.com/gjsify/gjsify/issues"
     },
-    "homepage": "https://github.com/gjsify/gjsify/tree/main/packages/nativescript-bridge/adwaita#readme",
-    "gitHead": "05fae97125a374e84bf57c2d2d086fb53523f205"
+    "homepage": "https://github.com/gjsify/gjsify/tree/main/packages/nativescript-bridge/adwaita#readme"
 }

package/src/testing/ns-core.mts

@@ -177,6 +177,8 @@ export class Style extends Observable {
     fontSize?: number;
     readonly viewRef: WeakRef<View>;
     #visibility = 'visible';
+    #width: number | string = 'auto';
+    #height: number | string = 'auto';
 
     constructor(view: View) {
         super();
@@ -193,6 +195,33 @@ export class Style extends Observable {
         this.#visibility = value;
         this.notify({ eventName: 'visibilityChange', object: this, propertyName: 'visibility', value, oldValue });
     }
+
+    /**
+     * The inline width, in DIPs or as a percentage string, `'auto'` until written — and the
+     * `widthChange` a one-child container listens for. A CSS property notifies on the style
+     * and not on the view, which is the whole reason this pair lives here.
+     */
+    get width(): number | string {
+        return this.#width;
+    }
+
+    set width(value: number | string) {
+        const oldValue = this.#width;
+        if (value === oldValue) return;
+        this.#width = value;
+        this.notify({ eventName: 'widthChange', object: this, propertyName: 'width', value, oldValue });
+    }
+
+    get height(): number | string {
+        return this.#height;
+    }
+
+    set height(value: number | string) {
+        const oldValue = this.#height;
+        if (value === oldValue) return;
+        this.#height = value;
+        this.notify({ eventName: 'heightChange', object: this, propertyName: 'height', value, oldValue });
+    }
 }
 
 export class View extends Observable {
@@ -234,8 +263,32 @@ export class View extends Observable {
      * missing so the first `className` write died inside a constructor.
      */
     readonly cssClasses: Set<string> = new Set();
-    width: number | string = 'auto';
-    height: number | string = 'auto';
+    /**
+     * `'auto'` until written, and HELD ON THE {@link Style} as `widthProperty` /
+     * `heightProperty` are (`ui/styling/style-properties.ts` registers both on `Style`;
+     * `view-common.ts`'s `get width()` is a one-line forward to `this.style.width`).
+     *
+     * This double held them as plain fields on the view, which made it STRUCTURALLY BLIND to
+     * the one thing a reader needs from them: the notification. `AdwSingleChildBase` learns
+     * that a parent settled its width from `widthChange` on the style — on a device the only
+     * place it is emitted — and against a field there is no event at all, so a spec would
+     * have passed while the widget sat waiting for a message that never came.
+     */
+    get width(): number | string {
+        return this._style.width;
+    }
+
+    set width(value: number | string) {
+        this._style.width = value;
+    }
+
+    get height(): number | string {
+        return this._style.height;
+    }
+
+    set height(value: number | string) {
+        this._style.height = value;
+    }
     horizontalAlignment = 'stretch';
     verticalAlignment = 'stretch';
     /**
@@ -614,11 +667,22 @@ export class GridLayout extends LayoutBase {
         if (at !== -1) this._rows.splice(at, 1);
     }
 
+    /** `GridLayoutBase.removeColumn` — BY SPEC, like `removeRow`, not by index. */
+    removeColumn(itemSpec: ItemSpec): void {
+        const at = this._cols.indexOf(itemSpec);
+        if (at !== -1) this._cols.splice(at, 1);
+    }
+
     /** `GridLayoutBase.getColumns` — a copy, as on a device. */
     getColumns(): ItemSpec[] {
         return [...this._cols];
     }
 
+    /** `GridLayoutBase.getRows` — the same read on the other axis. */
+    getRows(): ItemSpec[] {
+        return [...this._rows];
+    }
+
     removeColumns(): void {
         this._cols.length = 0;
     }
@@ -840,6 +904,14 @@ export class Label extends View {
         this._text = value?.toString() ?? '';
     }
 
+    /**
+     * `TextBase._setNativeText` — the framework's sink for every text write, and the seam
+     * the native markup path draws at (`widgets/label-markup-native.ts`). There is no
+     * native text view off a device, so this records nothing: it exists because the port
+     * overrides it and `super._setNativeText()` has to be callable.
+     */
+    _setNativeText(_reset = false): void {}
+
     textWrap = false;
     textAlignment = 'initial';
     textOverflow = 'initial';

package/src/theme/adwaita.css

@@ -506,13 +506,22 @@ Page.adw-window {
 
 /* ===== Button (variants) ===== */
 
+/* A FLOOR AND NOT A BOX. 38 is libadwaita's `min-height: 24px` plus its 5px of vertical
+ * padding twice (_buttons.scss, pin 42f647ff) — a MINIMUM there, and GTK has no CSS
+ * `height` at all. Writing it as NativeScript's `height`, which is exact, made every
+ * button in the port exactly 38 tall and silently swallowed `height-request`, which the
+ * bridge maps to `minHeight` and which GTK treats as a second floor: Learn6502's d-pad
+ * asks each of its five cells for 50×50 and got 50×38, so the cross came out as a row of
+ * flattened buttons. `min-height` is the property that means what the SCSS means, it
+ * composes with `height-request` the way GTK composes its two floors — the larger wins —
+ * and a caller that really wants an exact box can still write `height` itself. */
 .adw-button {
     background-color: rgba(0, 0, 0, 0.08);
     color: rgba(0, 0, 0, 0.8);
     border-radius: 9;
     font-weight: 700;
     padding: 5 16 5 16;
-    height: 38;
+    min-height: 38;
 }
 
 .adw-button.suggested-action {
@@ -534,10 +543,10 @@ Page.adw-window {
  * pin 42f647ff). The padding is the whole variant, and it is why this rule HAS to
  * restate the height.
  *
- * `.adw-button` above pins `height: 38`, and a NativeScript `height` is an EXACT box
- * where GTK's `min-height` is a floor — the same non-equivalence ADR 0034 measured for
- * `adw-spinner.size`. So a variant that doubles the vertical padding cannot grow the
- * box it sits in: the base budgets 38 − (5 + 5) = 28 for the label, and this one left
+ * `.adw-button` above pins a 38 floor, and this variant doubles the vertical padding
+ * inside it. While that floor was written as an EXACT NativeScript `height` — the
+ * non-equivalence ADR 0034 measured for `adw-spinner.size` — the variant could not grow
+ * the box it sat in: the base budgets 38 − (5 + 5) = 28 for the label, and this one left
  * 38 − (10 + 10) = 18 for a `.adw-button-label` at `font-size: 15`, whose line box does
  * not fit in 18. The pill was clipped, and every consumer that wanted one had to
  * override the height itself — which is how the defect surfaced, in Learn6502.
@@ -547,13 +556,17 @@ Page.adw-window {
  * 34, + 10px twice is 44 — so the pill is taller than the plain button there too.
  *
  * THE RULE THIS VARIANT BROKE, stated because the next variant will meet it: in this
- * stylesheet a class that changes vertical padding on a widget whose base pins an exact
- * `height` must restate that height. `.adw-button.circular` does (34), and both split
- * button halves do (38) beside their own padding. This one did not, and nothing said so. */
+ * stylesheet a class that changes vertical padding on a widget whose base states a
+ * `min-height` must restate that floor at its own padding. `.adw-button.circular` does
+ * (34), and both split button halves do (38) beside their own padding. This one did not,
+ * and nothing said so. The floors are `min-*` rather than `height` / `width` since the
+ * d-pad incident above, so a `height-request` larger than the floor now wins as it does
+ * in GTK — but a floor that is too SMALL for its own padding still clips, which is the
+ * half this comment is about and the reason the number is restated here. */
 .adw-button.pill {
     border-radius: 9999;
     padding: 10 32 10 32;
-    height: 48;
+    min-height: 48;
 }
 
 /* `%circular_button` — the explicit exception to the 9px rounded square: a full
@@ -563,8 +576,8 @@ Page.adw-window {
  * at all", and a class with no rule would have drawn a rounded rectangle instead. The
  * 34 is the same number `.adw-image-button` above carries, from the same line. */
 .adw-button.circular {
-    width: 34;
-    height: 34;
+    min-width: 34;
+    min-height: 34;
     border-radius: 9999;
     padding: 0;
 }