@gjsify/adwaita-nativescript 0.64.13 → 0.64.14

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

@@ -3,6 +3,23 @@ import { type LabelEllipsizeMode, type LabelJustification } from '@gjsify/adwait
 import { type ConstructProps } from './construct-props.js';
 /** Event name emitted when a link in the markup is tapped, before it is opened. */
 export declare const ACTIVATE_LINK = "activate-link";
+/**
+ * `Gtk.Label:xalign` on a TEMPLATE CHILD — a plain `@nativescript/core` `Label` an Adw widget
+ * builds inside itself, standing in for a `<object class="GtkLabel">` in the upstream `.ui`.
+ *
+ * WHY IT EXISTS AND WHY IT IS NOT A NO-OP AT 0. The platform's own default is start-aligned, so
+ * `0` writes the word the view already had; the point is that the widget now STATES the alignment
+ * its upstream template states, instead of agreeing with it by accident. Upstream rows read
+ * left-aligned because `adw-action-row.ui` and its siblings each say `<property name="xalign">0`,
+ * not because GTK's default is 0 — it is 0.5 — and a port that leaves them implicit cannot be read
+ * against the `.ui` file that is its specification.
+ *
+ * START IS `'initial'`, NOT `'left'`: GTK's 0 is the START edge and mirrors in RTL, and `'initial'`
+ * is the platform's own direction-aware start. Only `0` and `0.5` are here, which is every value
+ * libadwaita's templates put on a label; `1` belongs to `adw-spin-row.ui`'s `GtkSpinButton`, an
+ * entry's `xalign` and not this one.
+ */
+export declare function applyTemplateXalign(label: Label, xalign: 0 | 0.5): void;
 declare const GtkLabel_base: ((abstract new (...args: any[]) => {
     addEventListener(eventName: string, callback: (data: EventData) => void, thisArg?: unknown, once?: boolean): void;
     removeEventListener(eventName: string, callback?: (data: EventData) => void, thisArg?: unknown): void;
@@ -204,6 +221,13 @@ export declare class GtkLabel extends GtkLabel_base {
     set_css_classes(names: readonly string[]): void;
     private _setClasses;
     private _render;
+    /**
+     * `TextBase._setNativeText` — the one place every text write ends in, and therefore the
+     * seam the native markup path draws at. Refused by every host but Android, which then
+     * leaves the framework's own `formattedText`/`text` implementation in charge:
+     * `label-markup-native.ts`.
+     */
+    _setNativeText(reset?: boolean): void;
     /**
      * `emit_activate_link` for the link at `index`: the user's handlers under GTK's handled
      * accumulator, then — only if none handled it — the default launch.

package/lib/types/widgets/gtk-menu-button.d.ts

@@ -1,4 +1,4 @@
-import type { AdwMenuActions, AdwMenuInput, AdwMenuModel } from '@gjsify/adwaita-core';
+import type { AdwMenuActions, AdwMenuModel } from '@gjsify/adwaita-core';
 import type { EventData } from '@nativescript/core';
 import { AdwImageButton } from './adw-image-button.js';
 import { type ConstructProps } from './construct-props.js';
@@ -20,7 +20,13 @@ export interface MenuItemActivatedEventData extends EventData {
 }
 export declare class GtkMenuButton extends AdwImageButton {
     static readonly GTypeName: string;
-    private _model;
+    /**
+     * `Gtk.MenuButton` has NO identity guard on `menu-model` — measured: every write
+     * notifies, including the same model twice and `null` over `null`
+     * (`MENU_MODEL_NOTIFY_VECTORS`), which is the opposite of what `Adw.SplitButton` next
+     * door does. So the notify below is unconditional, and the slot does not gate it.
+     */
+    private readonly _slot;
     private _actions;
     private _menuTitle;
     private _primary;
@@ -29,20 +35,23 @@ export declare class GtkMenuButton extends AdwImageButton {
     private _styleClasses;
     constructor(props?: ConstructProps<GtkMenuButton>);
     /**
-     * The menu, normalised (ADR 0042) — opened as an Android `PopupMenu` on tap.
+     * The menu — a real `Gio.MenuModel` since ADR 0128 — opened as an Android `PopupMenu`
+     * on tap. `null` is the one spelling of "no menu".
      *
-     * Accepts every input form the portable model does, a bare `string[]` included —
-     * but NOT a JSON string; see `AdwSplitButton.menuModel` for why the XML door stays
-     * shut until a probe can prove it, and why being shut is not the same as being
-     * silent.
+     * IT TAKES A MODEL AND NOTHING ELSE: `Gio.Menu` from this package's `Gio` namespace, or
+     * `buildMenu([…])` for the authored shorthands (a bare `string[]` included). An array
+     * written straight here is refused by the GObject value check, word for word as GJS
+     * refuses it. A JSON STRING is refused too, with its own message — see
+     * `AdwSplitButton.menuModel` for why the XML door stays shut until a probe can prove
+     * it, and why being shut is not the same as being silent.
      */
-    get menuModel(): AdwMenuModel;
-    set menuModel(value: AdwMenuInput);
+    get menuModel(): AdwMenuModel | null;
+    set menuModel(value: AdwMenuModel | null);
     /** `Gtk.MenuButton:menu-model` — the GIR spelling of {@link menuModel}. */
-    get menu_model(): AdwMenuModel;
-    set menu_model(value: AdwMenuInput);
-    get_menu_model(): AdwMenuModel;
-    set_menu_model(value: AdwMenuInput): void;
+    get menu_model(): AdwMenuModel | null;
+    set menu_model(value: AdwMenuModel | null);
+    get_menu_model(): AdwMenuModel | null;
+    set_menu_model(value: AdwMenuModel | null): void;
     /**
      * What the action group publishes about the actions this menu names — the portable
      * stand-in for a `GActionGroup`. Left `null`, the registry above the button answers

package/lib/types/widgets/gtk-popover-menu.d.ts

@@ -1,5 +1,5 @@
 import { Observable, type EventData } from '@nativescript/core';
-import type { AdwMenuActions, AdwMenuInput, AdwMenuModel } from '@gjsify/adwaita-core';
+import type { AdwMenuActions, AdwMenuModel } from '@gjsify/adwaita-core';
 import type { ActionHost } from './actions.js';
 import { type ConstructProps } from './construct-props.js';
 /** `GtkPopover::closed`, emitted when the menu goes away. */
@@ -71,16 +71,16 @@ declare const GtkPopoverMenu_base: ((abstract new (...args: any[]) => {
 }) & typeof Observable;
 export declare class GtkPopoverMenu extends GtkPopoverMenu_base {
     static readonly GTypeName: string;
-    private _model;
+    private readonly _slot;
     private _actions;
     private _parent;
     private _open;
     constructor(props?: ConstructProps<GtkPopoverMenu>);
-    /** `Gtk.PopoverMenu:menu-model`. */
-    get menuModel(): AdwMenuModel;
-    set menuModel(value: AdwMenuInput);
-    set_menu_model(model: AdwMenuInput | null): void;
-    get_menu_model(): AdwMenuModel;
+    /** `Gtk.PopoverMenu:menu-model` — a real `Gio.MenuModel`, or `null` (ADR 0128). */
+    get menuModel(): AdwMenuModel | null;
+    set menuModel(value: AdwMenuModel | null);
+    set_menu_model(model: AdwMenuModel | null): void;
+    get_menu_model(): AdwMenuModel | null;
     /** What the action group publishes about the actions this menu names; see `GtkMenuButton.actions`. */
     get actions(): AdwMenuActions | null;
     set actions(value: AdwMenuActions | null);

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

@@ -4,8 +4,7 @@ export { AdwActionRow } from './adw-action-row.js';
 export { AdwSwitchRow, NOTIFY_ACTIVE } from './adw-switch-row.js';
 export { AdwEntryRow, NOTIFY_TEXT, NOTIFY_TEXT_LENGTH, NOTIFY_MAX_LENGTH, NOTIFY_EDITABLE, NOTIFY_SHOW_APPLY_BUTTON, NOTIFY_ACTIVATES_DEFAULT, SIGNAL_APPLY, SIGNAL_ENTRY_ACTIVATED, } from './adw-entry-row.js';
 export { AdwPasswordEntryRow } from './adw-password-entry-row.js';
-export { GtkEntry, ACTIVATE as ENTRY_ACTIVATE, NOTIFY_TEXT as NOTIFY_ENTRY_TEXT } from './gtk-entry.js';
-export type { NotifyEntryTextEventData } from './gtk-entry.js';
+export { GtkEntry, ACTIVATE as ENTRY_ACTIVATE, CHANGED as ENTRY_CHANGED, NOTIFY_TEXT as NOTIFY_ENTRY_TEXT, NOTIFY_TEXT_LENGTH as NOTIFY_ENTRY_TEXT_LENGTH, NOTIFY_MAX_LENGTH as NOTIFY_ENTRY_MAX_LENGTH, NOTIFY_PLACEHOLDER_TEXT, NOTIFY_EDITABLE as NOTIFY_ENTRY_EDITABLE, } from './gtk-entry.js';
 export { AdwComboRow, ComboState, NOTIFY_SELECTED } from './adw-combo-row.js';
 export type { AdwComboOption, ComboStateChange, ComboStateListener } from './adw-combo-row.js';
 export { GtkDropDown, NOTIFY_SELECTED as NOTIFY_DROP_DOWN_SELECTED } from './gtk-drop-down.js';

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

@@ -0,0 +1,5 @@
+import { type LabelMarkupNativeText } from './label-markup.js';
+/** Rationale and contract: `label-markup-native.ts`. */
+export declare function labelMarkupHoldNative(label: object, text: LabelMarkupNativeText | null): boolean;
+/** Rationale and contract: `label-markup-native.ts`. */
+export declare function labelMarkupDrawNative(label: object, reset: boolean): boolean;

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/single-child-base.d.ts

@@ -4,10 +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

@@ -1,8 +1,13 @@
 /**
- * Whether the single cell of a one-child container is `star` rather than `auto`.
+ * Whether the single cell of a one-child container is `star` rather than `auto`, on ONE axis.
  *
- * `star` when the container's width is settled — either because it stretches to its parent,
- * or because a definite `width` was written on it. `auto` otherwise, so the container can
- * still report its child's natural width and be placed by its alignment.
+ * `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(horizontalAlignment: unknown, width: unknown): boolean;
+export declare function singleChildCellIsStar(alignment: unknown, length: unknown): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gjsify/adwaita-nativescript",
-    "version": "0.64.13",
+    "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",
-        "@gjsify/adwaita-fonts": "^0.64.13",
-        "@gjsify/adwaita-icons": "^0.64.13",
-        "@gjsify/canvas2d-core": "^0.64.13",
-        "@gjsify/native-platform": "^0.64.13"
+        "@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"
+        "@gjsify/app-settings": "^0.64.14"
     },
     "peerDependenciesMeta": {
         "@nativescript/core": {
@@ -92,11 +92,11 @@
         }
     },
     "devDependencies": {
-        "@gjsify/app-settings": "^0.64.13",
-        "@gjsify/blueprint": "^0.64.13",
-        "@gjsify/cli": "^0.64.13",
-        "@gjsify/unit": "^0.64.13",
-        "@gjsify/vite-plugin-blueprint": "^0.64.13",
+        "@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"
     },

package/src/testing/ns-core.mts

@@ -667,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;
     }
@@ -893,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;
 }