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

package/lib/types/widgets/adw-combo-row.d.ts

@@ -1,4 +1,4 @@
-import { Label, type EventData, type View } from '@nativescript/core';
+import { Label, type View } from '@nativescript/core';
 import type { AdwComboOption, ComboWatchableModel } from '@gjsify/adwaita-core';
 import { AdwActionRow } from './adw-action-row.js';
 import { GtkImage } from './gtk-image.js';
@@ -7,14 +7,18 @@ export { ComboState } from '@gjsify/adwaita-core';
 export type { AdwComboOption, ComboStateChange, ComboStateListener } from '@gjsify/adwaita-core';
 /** Event name emitted when {@link AdwComboRow.selected} changes. Mirrors GObject `notify::selected`. */
 export declare const NOTIFY_SELECTED = "notify::selected";
-/** Payload of the `notify::selected` event. */
-export interface NotifySelectedEventData extends EventData {
-    /** The newly-selected index. */
-    selected: number;
-    /** The newly-selected option's `value`. */
-    value: string;
-}
-export declare class AdwComboRow extends AdwActionRow {
+declare const AdwComboRow_base: ((abstract new (...args: any[]) => {
+    _emit(eventName: string): void;
+    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;
+    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;
+}) & {
+    readonly emittedSignals: readonly string[];
+}) & typeof AdwActionRow;
+export declare class AdwComboRow extends AdwComboRow_base {
     static readonly GTypeName: string;
     /**
      * The action row's edges, plus `model`: `model: Gtk.StringList { strings [ … ] }` in a
@@ -42,7 +46,35 @@ export declare class AdwComboRow extends AdwActionRow {
      * writes `model:` first — the order GtkBuilder needs too.
      */
     private _pendingSelected;
+    /** `Adw.ComboRow:model` — the list, by identity. Declared above; the seam installs it. */
+    model: ComboWatchableModel | null;
+    /**
+     * `Adw.ComboRow:selected` — the selected position, or {@link ADW_COMBO_NO_SELECTION}.
+     * Declared above; not `readonly` in TypeScript because the seam installs one accessor pair
+     * per declared property and this row is what writes the derived value.
+     */
+    selected: number;
+    /**
+     * `Adw.ComboRow:selected-item` — the model's OWN object at {@link selected}, so the identity
+     * comparison a `selected-item` consumer writes holds. `null` for the sentinel and for no
+     * model. Read-only by derivation (see the declaration).
+     */
+    selectedItem: unknown;
+    /**
+     * What a `model` write DOES, once the seam has stored the normalized value.
+     *
+     * A method on the class and not a body inside the declaration, because the descriptor sits
+     * outside the class and reaches the state through a cast — and a reader keyed on
+     * `this.<field>` cannot tell `ComboState.setModel` from `ListViewState.setModel` through
+     * one (`check-adwaita-collection-reactivity.mjs`). Guessing there would merge two different
+     * collections into one comparison, so the call is made where the field's type is declared.
+     */
+    private _applyModel;
+    /** What a `selected` write does: emits `selected` then `selected-item` through the relay. */
+    private _applySelected;
     constructor(props?: ConstructProps<AdwComboRow>);
+    /** What the relay pushes for each of the three — the state's reading, never the store's. */
+    private _valueOf;
     /**
      * `model_changed` (adw-combo-row.c:187-195) — one option or none is not a
      * choice, so the chevron goes and the row stops being activatable.
@@ -54,13 +86,6 @@ export declare class AdwComboRow extends AdwActionRow {
     private _syncChooser;
     /** Open the native action chooser and apply the picked option. */
     private _openChooser;
-    /**
-     * The list model (`Adw.ComboRow:model`) — the OBJECT that was assigned, by identity, as
-     * `row.model === model` is measured to hold in libadwaita (ADR 0122 § 4). The normalised
-     * descriptors are {@link options}.
-     */
-    get model(): ComboWatchableModel | null;
-    set model(value: ComboWatchableModel | string | null);
     /** The held model's items as `{ value, label }` descriptors. */
     get options(): AdwComboOption[];
     /** `adw_combo_row_set_model`. */
@@ -73,21 +98,12 @@ export declare class AdwComboRow extends AdwActionRow {
      * row edge, as on any action row.
      */
     _addChildFromBuilder(name: string, child: View): void;
-    /** The selected option index. Updates the inline value label. */
-    get selected(): number;
-    set selected(raw: number | string);
+    /** `adw_combo_row_get_selected`. */
     get_selected(): number;
     set_selected(position: number): void;
     /** The selected option's `value`, or `''` when out of range. */
     get selectedValue(): string;
     set selectedValue(value: string);
-    /**
-     * The selected ITEM (`Adw.ComboRow:selected-item`) — the model's own object at
-     * {@link selected}, read through `get_item`, so the identity comparison a `selected-item`
-     * consumer writes holds. `null` for the sentinel and for no model. Read-only, as in
-     * libadwaita.
-     */
-    get selectedItem(): unknown;
     /** `adw_combo_row_get_selected_item`. */
     get_selected_item(): unknown;
 }

package/lib/types/widgets/adw-split-button.d.ts

@@ -1,5 +1,5 @@
 import { GridLayout, Label, StackLayout, type EventData } from '@nativescript/core';
-import type { AdwMenuActions, AdwMenuInput, AdwMenuModel, SplitButtonDirection } from '@gjsify/adwaita-core';
+import type { AdwMenuActions, AdwMenuModel, SplitButtonDirection } from '@gjsify/adwaita-core';
 import { GtkImage } from './gtk-image.js';
 import { type ConstructProps } from './construct-props.js';
 import { type GObjectNotify } from './signals.js';
@@ -121,6 +121,12 @@ export declare class AdwSplitButton extends AdwSplitButton_base {
     /** The direction arrow. */
     protected readonly _chevron: GtkImage;
     private readonly _state;
+    /**
+     * The menu this button holds, with its `items-changed` watcher. The STATE holds it too
+     * — `setMenuModel` is what drives `dropdownEnabled` and the notify order — and this
+     * holds the snapshot the popup is built from, which the state has no business knowing.
+     */
+    private readonly _slot;
     private _actions;
     /** Which of the two action views is currently parented. */
     private _showingIcon;
@@ -168,13 +174,17 @@ export declare class AdwSplitButton extends AdwSplitButton_base {
      * (`gallery-page.ts`), which no structured value can satisfy. An input form nothing
      * can run is a claim, not a feature.
      *
-     * AND IT SAYS SO. Left to `normalizeMenuModel`, a string is "not an array" and
-     * becomes an EMPTY menu — so an XML author writing `menuModel="[…]"` would get a
-     * button whose dropdown is dead, with nothing anywhere saying why. A shut door that
-     * is silent is worse than one that is open.
+     * AND IT SAYS SO. Left to the core's door a string would be PARSED, because that door
+     * is also the browser's `menu-model` attribute (ADR 0128 § 4) — so an XML author writing
+     * `menuModel="[…]"` would get a menu this port never promised to build from markup. A
+     * shut door that is silent is worse than one that is open, so the refusal names itself.
+     *
+     * `null` IS THE ONE SPELLING OF "NO MENU" since ADR 0128: an empty `Gio.Menu` is a menu
+     * that happens to have no rows, and it keeps the dropdown live exactly as it does on
+     * GTK (measured, `MENU_MODEL_DOOR_VECTORS`).
      */
-    get menuModel(): AdwMenuModel;
-    set menuModel(value: AdwMenuInput);
+    get menuModel(): AdwMenuModel | null;
+    set menuModel(value: AdwMenuModel | null);
     /**
      * What the action group publishes about the actions this menu names — the portable
      * stand-in for a `GActionGroup`, and the only source of a menu's enabled/checked

package/lib/types/widgets/box-layout.d.ts

@@ -25,6 +25,43 @@ export interface BoxTrack {
 export declare function boxTrackPlan(expands: readonly boolean[], spacing: unknown, homogeneous: boolean): BoxTrack[];
 /** The track child `index` lives in — the even ones; the odd ones are the gaps. */
 export declare function boxChildTrack(index: number): number;
+/** What a track list has to change to become the next one — a kept head and an added tail. */
+export interface BoxTrackDiff {
+    /** How many leading tracks are already right and stay exactly as they are. */
+    keep: number;
+    /** The tracks to add after those, in order. Everything past `keep` is dropped first. */
+    add: readonly BoxTrack[];
+}
+/**
+ * How to turn `current` into `next`: keep the common leading run, drop the rest from the END
+ * backwards, then add {@link BoxTrackDiff.add}.
+ *
+ * WHY A DIFF AND NOT A REBUILD. {@link boxTrackPlan} is a pure SUFFIX EXTENSION — one more
+ * child appends a gap track and a track, and leaves every earlier track untouched, because
+ * {@link boxChildTrack} answers `2 * i` whatever follows. So the widget re-planned the whole
+ * list on every single `addChild` / `removeChild`, and that is quadratic in the child count.
+ * Measured on a Galaxy S9, a 167-child vertical box building the Learn6502 tutorial: 362
+ * `_applyChildren` calls, 175 ms of them spent removing and re-adding `ItemSpec`s that had
+ * not changed and writing cells to children that had not moved. With this diff an append and
+ * a remove-at-the-end are both one track pair.
+ *
+ * REMOVING FROM THE END IS NOT AN OPTIMISATION, it is the only order that works: the platform
+ * removes a track BY SPEC, so dropping a leading one renumbers the specs still to drop.
+ */
+export declare function boxTrackDiff(current: readonly BoxTrack[], next: readonly BoxTrack[]): BoxTrackDiff;
+/**
+ * The first index at which the children already placed differ from the children now — where
+ * writing cells has to start.
+ *
+ * A child's cell is `2 * index` and nothing else, so a child whose index did not move keeps
+ * the cell it has: an append has to place only the newcomer, and a remove-at-the-end nothing
+ * at all. A prepend or a remove from the middle shifts every index after it and is answered
+ * with a 0 — correct, and no cheaper than it is in the child list itself.
+ *
+ * Generic over the child type for the same reason the rest of this module is free of
+ * `@nativescript/core`: so the spec suite can drive it off-device.
+ */
+export declare function boxPlacementStart<T>(placed: readonly T[], next: readonly T[]): number;
 /**
  * Where the child list ends up after an `insert_child_after` / `reorder_child_after`, or
  * `null` where C would have hit a `g_return_if_fail`.

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

@@ -8,7 +8,10 @@ export declare class GtkBox extends AdwStyledLayoutBase {
     private _spacing;
     private _orientation;
     private _homogeneous;
-    private _trackKey;
+    private _tracks;
+    private _tracksVertical;
+    private readonly _specs;
+    private _placed;
     private readonly _followers;
     constructor(props?: ConstructProps<GtkBox>);
     /** Append a child — `gtk_box_append`. */
@@ -54,10 +57,13 @@ export declare class GtkBox extends AdwStyledLayoutBase {
     /**
      * Give every child its track and the box the track list that matches.
      *
-     * The WHOLE set, not just the newcomer: adding a second child changes the FIRST one's
-     * answer too when the box is re-ordered, and a removal shifts every index after it. The
-     * track list is rebuilt only when it differs, because re-adding every `ItemSpec` makes
-     * the platform re-measure.
+     * RE-PLANNED FROM THE WHOLE SET, APPLIED AS A DIFF. Adding a second child changes the
+     * FIRST one's answer too when the box is re-ordered, and a removal shifts every index
+     * after it, so the plan is always read off every child. But this runs on EVERY
+     * `addChild` / `insertChild` / `removeChild`, and re-adding every `ItemSpec` and
+     * re-writing every cell made that quadratic in the child count — `boxTrackDiff` and
+     * `boxPlacementStart` hold the measurement and the reasoning. An append and a
+     * remove-from-the-end are one track pair and one cell each.
      */
     private _applyChildren;
 }

package/lib/types/widgets/gtk-drop-down.d.ts

@@ -1,24 +1,16 @@
-import { Label, StackLayout, type EventData, type View } from '@nativescript/core';
+import { Label, StackLayout, type View } from '@nativescript/core';
 import type { AdwComboOption, ComboWatchableModel } from '@gjsify/adwaita-core';
 import { GtkImage } from './gtk-image.js';
 import { type ConstructProps } from './construct-props.js';
-/** Event name emitted when {@link GtkDropDown.selected} changes through a pick. Mirrors GObject `notify::selected`. */
+import { type GObjectNotify } from './signals.js';
+/** Event name emitted when {@link GtkDropDown.selected} changes. Mirrors GObject `notify::selected`. */
 export declare const NOTIFY_SELECTED = "notify::selected";
 /** Mirrors GObject `notify::selected-item`; fired right after the one above, on the same change. */
 export declare const NOTIFY_SELECTED_ITEM = "notify::selected-item";
-/** Payload of the `notify::selected` event. */
-export interface NotifyDropDownSelectedEventData extends EventData {
-    /** The newly-selected index. */
-    selected: number;
-    /** The newly-selected option's `value`. */
-    value: string;
-    /** The newly-selected option's `label` — what the button now shows. */
-    label: string;
-}
 declare const GtkDropDown_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;
@@ -73,7 +65,7 @@ declare const GtkDropDown_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;
@@ -82,8 +74,6 @@ declare const GtkDropDown_base: ((abstract new (...args: any[]) => {
 }) & typeof StackLayout;
 export declare class GtkDropDown extends GtkDropDown_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[];
     /**
      * `model` only: `model: Gtk.StringList { strings [ … ] }` in a `.blp` places the list at
      * the property it sets (ADR 0072). `GtkDropDown` takes no child widget in GTK.
@@ -104,16 +94,43 @@ export declare class GtkDropDown extends GtkDropDown_base {
     private readonly _authored;
     /** Title shown atop the substituted `action()` sheet. */
     private _chooserTitle;
+    /**
+     * A `selected` written while the widget has no model yet — the twin of
+     * {@link AdwComboRow}'s. NativeScript's XML builder assigns every attribute before it adds
+     * the children, so `<gtk:DropDown selected="1">` reached this widget before its
+     * `<gtk:DropDown.model>` list did and the index was DROPPED; the row has held it since it
+     * was written and the drop-down does now too.
+     */
+    private _pendingSelected;
+    /** `Gtk.DropDown:model` — the list, by identity. Declared above; the seam installs it. */
+    model: ComboWatchableModel | null;
+    /**
+     * `Gtk.DropDown:selected` — the selected position, or {@link ADW_COMBO_NO_SELECTION}.
+     * Declared above; not `readonly` in TypeScript because the seam installs one accessor pair
+     * per declared property and this widget is what writes the derived value.
+     */
+    selected: number;
+    /**
+     * `Gtk.DropDown:selected-item` — the model's OWN object at {@link selected}, so the identity
+     * comparison a `selected-item` consumer writes holds. `null` for the sentinel and for no
+     * model. Read-only by derivation (see the declaration).
+     */
+    selectedItem: unknown;
+    /** GJS's `notify('<prop>')` beside NativeScript's `notify({ eventName })`; see the seam. */
+    notify: GObjectNotify;
+    /**
+     * What a `model` write does, once the seam has stored the normalized value — the twin of
+     * `AdwComboRow._applyModel`, which says why the body sits on the class and not in the
+     * declaration.
+     */
+    private _applyModel;
+    /** What a `selected` write does: emits `selected` then `selected-item` through the relay. */
+    private _applySelected;
     constructor(props?: ConstructProps<GtkDropDown>);
+    /** What the relay pushes for each of the three — the state's reading, never the store's. */
+    private _valueOf;
     /** Open the native chooser and apply the picked option. */
     private _openChooser;
-    /**
-     * The list model (`Gtk.DropDown:model`) — the OBJECT that was assigned, by identity, as
-     * `dropdown.model === model` is measured to hold in GTK (ADR 0122 § 4). The normalised
-     * descriptors are {@link options}.
-     */
-    get model(): ComboWatchableModel | null;
-    set model(value: ComboWatchableModel | string | null);
     /** The held model's items as `{ value, label }` descriptors. */
     get options(): AdwComboOption[];
     /** `gtk_drop_down_set_model`. */
@@ -125,9 +142,6 @@ export declare class GtkDropDown extends GtkDropDown_base {
      * Anything else is refused, as GTK refuses a child widget on a `GtkDropDown`.
      */
     _addChildFromBuilder(name: string, child: View): void;
-    /** The selected option index (`Gtk.DropDown:selected`). */
-    get selected(): number;
-    set selected(raw: number | string);
     /** `gtk_drop_down_get_selected`. */
     get_selected(): number;
     /** `gtk_drop_down_set_selected`. */
@@ -135,12 +149,6 @@ export declare class GtkDropDown extends GtkDropDown_base {
     /** The selected option's `value`, or `''` when out of range. */
     get selectedValue(): string;
     set selectedValue(value: string);
-    /**
-     * The selected ITEM (`Gtk.DropDown:selected-item`) — the model's own object at
-     * {@link selected}, read through `get_item`, so the identity comparison a `selected-item`
-     * consumer writes holds. `null` for the sentinel and for no model. Read-only, as in GTK.
-     */
-    get selectedItem(): unknown;
     /** `gtk_drop_down_get_selected_item`. */
     get_selected_item(): unknown;
     /**

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

@@ -1,22 +1,24 @@
-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;
@@ -71,7 +73,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 +82,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-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,12 +4,10 @@ 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, NotifySelectedEventData } 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';
-export type { NotifyDropDownSelectedEventData } from './gtk-drop-down.js';
 export { AdwSpinRow, NOTIFY_VALUE, SpinState } from './adw-spin-row.js';
 export type { NotifyValueEventData, SpinStateChange, SpinStateListener } from './adw-spin-row.js';
 export { AdwSliderRow, NOTIFY_SLIDER_VALUE } from './adw-slider-row.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;