@gjsify/adwaita-nativescript 0.64.13 → 0.64.15-next.287

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

@@ -1,26 +1,30 @@
-import { GridLayout, TextField, type EventData } from '@nativescript/core';
+import { GridLayout, TextField } from '@nativescript/core';
 import { type ConstructProps } from './construct-props.js';
+import { type GObjectNotify } from './signals.js';
 /** Event name emitted when {@link GtkEntry.text} changes. Mirrors GObject `notify::text`. */
 export declare const NOTIFY_TEXT = "notify::text";
+/** Event name emitted when {@link GtkEntry.textLength} changes. Mirrors `notify::text-length`. */
+export declare const NOTIFY_TEXT_LENGTH = "notify::text-length";
+/** Event name emitted when {@link GtkEntry.maxLength} changes. Mirrors `notify::max-length`. */
+export declare const NOTIFY_MAX_LENGTH = "notify::max-length";
+/** Event name emitted when {@link GtkEntry.placeholderText} changes. */
+export declare const NOTIFY_PLACEHOLDER_TEXT = "notify::placeholder-text";
+/** Event name emitted when {@link GtkEntry.editable} changes. */
+export declare const NOTIFY_EDITABLE = "notify::editable";
 /** Event name emitted when the return key is pressed — `Gtk.Entry::activate`. */
 export declare const ACTIVATE = "activate";
 /** `Gtk.Editable::changed` — every change of the text, typed or set. */
 export declare const CHANGED = "changed";
-/** Payload of the `notify::text` event. */
-export interface NotifyEntryTextEventData extends EventData {
-    /** The new text value (already truncated to `maxLength`). */
-    text: string;
-    /** The new number of CHARACTERS (not UTF-16 units). */
-    textLength: number;
-}
 declare const GtkEntry_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;
-    connect(eventName: string, callback: (self: /*elided*/ any, data: EventData) => unknown): number;
+    addEventListener(eventName: string, callback: (data: import("@nativescript/core").EventData) => void, thisArg?: unknown, once?: boolean): void;
+    removeEventListener(eventName: string, callback?: (data: import("@nativescript/core").EventData) => void, thisArg?: unknown): void;
+    connect(eventName: string, callback: (self: /*elided*/ any, data: import("@nativescript/core").EventData) => unknown): number;
     disconnect(handlerId: number): void;
     emit(eventName: string, ...args: unknown[]): void;
     get_property(name: string): unknown;
     set_property(name: string, value: unknown): void;
+    get cssType(): string | undefined;
+    set cssType(value: string | undefined);
     get halign(): string;
     set halign(value: string | number);
     get valign(): string;
@@ -71,7 +75,7 @@ declare const GtkEntry_base: ((abstract new (...args: any[]) => {
     set_focus_on_click(focusOnClick: boolean): void;
     grab_focus(): boolean;
     _emit(eventName: string): void;
-    notify<T extends EventData>(data: T): void;
+    notify<T extends import("@nativescript/core").EventData>(data: T): void;
     notifyPropertyChange(name: string, value: unknown, oldValue?: unknown): void;
     set(name: string, value: unknown): void;
     get(name: string): unknown;
@@ -80,35 +84,61 @@ declare const GtkEntry_base: ((abstract new (...args: any[]) => {
 }) & typeof GridLayout;
 export declare class GtkEntry extends GtkEntry_base {
     static readonly GTypeName: string;
-    /** The GTK signals this widget emits through `connect` — read by the shared-tree builder (ADR 0093). */
-    static readonly emittedSignals: readonly string[];
     /** The real input. Chrome-less: the box around it paints the Adwaita surface. */
     protected readonly _field: TextField;
-    private _text;
-    private _maxLength;
-    constructor(props?: ConstructProps<GtkEntry>);
     /**
-     * Truncate, write the field, and notify on a real change.
+     * Whether the write being applied came from the keyboard. It decides the ORDER
+     * {@link _applyText} emits in, and nothing else — see the module header's measurement.
+     */
+    private _typing;
+    /** The entry's contents, truncated to {@link maxLength}. Declared above; the seam installs it. */
+    text: string;
+    /**
+     * `Gtk.Entry:text-length` — the number of CHARACTERS, not UTF-16 units, so `'🔒é'` is 2.
      *
-     * Writing the field re-enters through `textChange`; the nested call finds the
-     * text already applied and settles it, and the outer one then sees its own
-     * value in `_text` and stops — so a truncated keystroke notifies exactly once.
+     * READ-ONLY, as upstream declares it: a write is normalized back to the count derived from
+     * this entry's own {@link text} and so changes nothing (see the declaration). Not `readonly`
+     * in TypeScript, because the seam installs one accessor pair per declared property and this
+     * widget is what writes the derived value.
      */
-    private _applyText;
-    /** The editable text. */
-    get text(): string;
-    set text(value: string);
-    /** The number of CHARACTERS in {@link text}, not UTF-16 units. */
-    get textLength(): number;
-    /** Maximum number of characters, `0` = unlimited. */
-    get maxLength(): number;
-    set maxLength(raw: number | string);
+    textLength: number;
+    /** `Gtk.Entry:max-length` — maximum number of characters, `0` = unlimited. */
+    maxLength: number;
     /** Placeholder shown while the entry is empty (`Gtk.Entry:placeholder-text`). */
-    get placeholderText(): string;
-    set placeholderText(value: string);
+    placeholderText: string;
     /** Whether the entry accepts edits (`GtkEditable:editable`). */
-    get editable(): boolean;
-    set editable(raw: boolean | string);
+    editable: boolean;
+    /** GJS's `notify('<prop>')` beside NativeScript's `notify({ eventName })`; see the seam. */
+    notify: GObjectNotify;
+    constructor(props?: ConstructProps<GtkEntry>);
+    /**
+     * What a `text` write does once the seam holds the normalized value: push the field, move
+     * the derived length, and emit in the MEASURED order.
+     *
+     * Writing the field re-enters through `textChange`, which writes this very value back; the
+     * seam's equal-write rule drops it, and that is what retired the old re-entrancy funnel.
+     * The origin is read BEFORE that write, because the handler it re-enters assigns `_typing`
+     * and the flag is no longer this call's once the field has been touched.
+     */
+    private _applyText;
+    /**
+     * What a `max-length` write does: re-run the held text against the new ceiling, so a
+     * SHRINKING limit truncates what is already there, and only then announce the limit —
+     * `changed`, `notify::text`, `notify::max-length`, as measured.
+     */
+    private _applyMaxLength;
+    /** `placeholder-text` reaches the field's hint and nothing else. */
+    private _applyPlaceholderText;
+    /** `editable` gates the keyboard only — see the declaration. */
+    private _applyEditable;
+    /** `gtk_editable_get_text`. */
+    get_text(): string;
+    /** `gtk_editable_set_text`. */
+    set_text(text: string): void;
+    /** `gtk_entry_get_max_length`. */
+    get_max_length(): number;
+    /** `gtk_entry_set_max_length`. */
+    set_max_length(max: number): void;
     /** The inner `TextField` — for focus, selection and host-specific keyboard options. */
     get field(): TextField;
 }

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

@@ -19,6 +19,8 @@ declare const GtkImage_base: ((abstract new (...args: any[]) => {
     emit(eventName: string, ...args: unknown[]): void;
     get_property(name: string): unknown;
     set_property(name: string, value: unknown): void;
+    get cssType(): string | undefined;
+    set cssType(value: string | undefined);
     get halign(): string;
     set halign(value: string | number);
     get valign(): string;

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;
@@ -11,6 +28,8 @@ declare const GtkLabel_base: ((abstract new (...args: any[]) => {
     emit(eventName: string, ...args: unknown[]): void;
     get_property(name: string): unknown;
     set_property(name: string, value: unknown): void;
+    get cssType(): string | undefined;
+    set cssType(value: string | undefined);
     get halign(): string;
     set halign(value: string | number);
     get valign(): string;
@@ -204,6 +223,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';
@@ -18,9 +18,36 @@ export interface MenuItemActivatedEventData extends EventData {
     /** The chosen item's detailed action name, when the item carried one. */
     action?: string;
 }
-export declare class GtkMenuButton extends AdwImageButton {
+declare const GtkMenuButton_base: ((abstract new (...args: any[]) => {
+    _emit(eventName: string): void;
+    addEventListener(eventName: string, callback: (data: EventData) => void, thisArg?: unknown, once?: boolean): void;
+    removeEventListener(eventName: string, callback?: (data: EventData) => void, thisArg?: unknown): void;
+    notify<T extends EventData>(data: T): void;
+    notifyPropertyChange(name: string, value: unknown, oldValue?: unknown): void;
+    set(name: string, value: unknown): void;
+    get(name: string): unknown;
+}) & {
+    readonly emittedSignals: readonly string[];
+}) & typeof AdwImageButton;
+export declare class GtkMenuButton extends GtkMenuButton_base {
     static readonly GTypeName: string;
-    private _model;
+    /**
+     * The menu — a real `Gio.MenuModel` since ADR 0128 — opened as an Android `PopupMenu`
+     * on tap. `null` is the one spelling of "no menu".
+     *
+     * 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.
+     *
+     * A CHANGE IS `notify::menu-model` through {@link connect}, not the NativeScript
+     * `menuModelChange` this property emitted while it was hand-rolled.
+     */
+    menuModel: AdwMenuModel | null;
+    /** The menu this button holds, with its `items-changed` watcher and the tree the popup reads. */
+    private readonly _slot;
     private _actions;
     private _menuTitle;
     private _primary;
@@ -28,21 +55,8 @@ export declare class GtkMenuButton extends AdwImageButton {
     private readonly _baseClassName;
     private _styleClasses;
     constructor(props?: ConstructProps<GtkMenuButton>);
-    /**
-     * The menu, normalised (ADR 0042) — opened as an Android `PopupMenu` on tap.
-     *
-     * 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.
-     */
-    get menuModel(): AdwMenuModel;
-    set menuModel(value: AdwMenuInput);
-    /** `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): 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
@@ -80,3 +94,4 @@ export declare class GtkMenuButton extends AdwImageButton {
     private _setClasses;
     private _openMenu;
 }
+export {};

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. */
@@ -12,6 +12,8 @@ declare const GtkPopoverMenu_base: ((abstract new (...args: any[]) => {
     emit(eventName: string, ...args: unknown[]): void;
     get_property(name: string): unknown;
     set_property(name: string, value: unknown): void;
+    get cssType(): string | undefined;
+    set cssType(value: string | undefined);
     get halign(): string;
     set halign(value: string | number);
     get valign(): string;
@@ -71,16 +73,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/gtk-scrolled-window.d.ts

@@ -10,6 +10,11 @@ export declare class GtkScrolledWindow extends AdwSingleChildBase {
     private readonly _scroll;
     /** The box the child really goes in — see "THE CHILD IS NOT THE CONTENT" in the header. */
     private readonly _viewport;
+    /** The horizontal half of a two-axis window — see "TWO AXES" in the header. */
+    private readonly _hscroll;
+    /** The box the child goes in once `_hscroll` is in play, for the same margin reason. */
+    private readonly _hbox;
+    private _nested;
     private _hscrollbarPolicy;
     private _vscrollbarPolicy;
     private _hasFrame;
@@ -46,6 +51,10 @@ export declare class GtkScrolledWindow extends AdwSingleChildBase {
     /** `Gtk.ScrolledWindow:has-frame` — held and read back; no frame is drawn (see the header). */
     get hasFrame(): boolean;
     set hasFrame(raw: boolean | string);
+    /** The view that scrolls sideways: the inner one of a two-axis window, else the only one. */
+    private get _horizontalScroller();
+    /** Where the child sits: the viewport box, or the horizontal scroller's box inside it. */
+    private get _holder();
     protected _adopt(view: View): void;
     protected _release(view: View): void;
     private _applyOrientation;

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

@@ -19,6 +19,8 @@ declare const GtkStack_base: ((abstract new (...args: any[]) => {
     emit(eventName: string, ...args: unknown[]): void;
     get_property(name: string): unknown;
     set_property(name: string, value: unknown): void;
+    get cssType(): string | undefined;
+    set cssType(value: string | undefined);
     get halign(): string;
     set halign(value: string | number);
     get valign(): string;

package/lib/types/widgets/gtk-text-view.d.ts

@@ -21,6 +21,8 @@ declare const GtkTextView_base: ((abstract new (...args: any[]) => {
     emit(eventName: string, ...args: unknown[]): void;
     get_property(name: string): unknown;
     set_property(name: string, value: unknown): void;
+    get cssType(): string | undefined;
+    set cssType(value: string | undefined);
     get halign(): string;
     set halign(value: string | number);
     get valign(): string;

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,51 @@
+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;
+    /**
+     * READ a property write without holding it: 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.
+     *
+     * SPLIT FROM {@link adopt} for the seam: a declared property reads the write in `normalize`,
+     * ahead of the store and of the equal-write check, and takes the value on in `afterNotify`,
+     * which runs only for a write that moved (`signals.ts`). A single `write` would snapshot and
+     * re-watch on every write including an equal one, which is a notify the measurement says
+     * `Adw.SplitButton` does not make.
+     */
+    read(value: unknown): GioMenuModel | null;
+    /**
+     * {@link read} and {@link adopt} in one — the door for a widget whose `menuModel` the seam
+     * does NOT own (`gtk-popover-menu.ts`).
+     */
+    write(value: unknown): void;
+    /** Hold `next`, snapshot it, and listen to it — the three that always happen together. */
+    adopt(next: GioMenuModel | null): void;
+}

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/scrolled-window-policy.d.ts

@@ -9,9 +9,11 @@ export declare function policyScrolls(policy: GtkPolicyNick): boolean;
 /**
  * The one axis the `ScrollView` scrolls on, for a pair of policies.
  *
- * Vertical wins a tie, because that is the axis a page of content grows on; a window that
- * scrolls ONLY horizontally is the one case that flips it. Neither axis scrolling still
+ * Vertical wins a tie, because that is the axis a page of content grows on and the outer view
+ * of a two-axis window; a window that scrolls ONLY horizontally is the one case that flips it. Neither axis scrolling still
  * answers `vertical` — a `ScrollView` cannot refuse to scroll, so the child is simply held
  * at its natural size by the surrounding layout.
  */
 export declare function scrollOrientationFor(hscrollbarPolicy: GtkPolicyNick, vscrollbarPolicy: GtkPolicyNick): 'horizontal' | 'vertical';
+/** Whether both axes scroll, which is when the window needs the second, nested `ScrollView`. */
+export declare function scrollsBothAxes(hscrollbarPolicy: GtkPolicyNick, vscrollbarPolicy: GtkPolicyNick): boolean;

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

@@ -147,6 +147,8 @@ export declare function withSignals<TBase extends ObservableConstructor>(Base: T
     emit(eventName: string, ...args: unknown[]): void;
     get_property(name: string): unknown;
     set_property(name: string, value: unknown): void;
+    get cssType(): string | undefined;
+    set cssType(value: string | undefined);
     get halign(): string;
     set halign(value: string | number);
     get valign(): string;

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/lib/types/widgets/split-view-base.d.ts

@@ -18,6 +18,8 @@ declare const AdwSplitViewBase_base: ((abstract new (...args: any[]) => {
     emit(eventName: string, ...args: unknown[]): void;
     get_property(name: string): unknown;
     set_property(name: string, value: unknown): void;
+    get cssType(): string | undefined;
+    set cssType(value: string | undefined);
     get halign(): string;
     set halign(value: string | number);
     get valign(): string;