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

package/lib/types/application.d.ts

@@ -1,11 +1,11 @@
-import { GioApplicationBase, type AdwMenuItem, type AdwMenuActions, type AdwMenuModel, type ApplicationHost } from '@gjsify/adwaita-core';
+import { GioApplicationBase, type AdwMenuItem, type AdwMenuActions, type AdwMenuTree, type ApplicationHost } from '@gjsify/adwaita-core';
 export declare const webHost: ApplicationHost;
 /** An element's parent for action resolution; a popover is rooted at the widget that owns it. */
 export declare function parentOfElement(node: object): object | null;
 /** What a `Gtk.Actionable` does on activation: the action `prefix.name` found from `widget`. */
 export declare function activateWidgetAction(widget: Element, fullName: string, parameter?: unknown): boolean;
-/** What the items of `model` read from the actions registered above `el` (ADR 0097 § 3). */
-export declare function menuActionsOfElement(el: Element, model: AdwMenuModel): AdwMenuActions;
+/** What the items of `tree` read from the actions registered above `el` (ADR 0097 § 3). */
+export declare function menuActionsOfElement(el: Element, tree: AdwMenuTree): AdwMenuActions;
 /** What choosing `item` in a menu owned by `el` does: the action it names fires. */
 export declare function activateElementMenuItem(el: Element, item: AdwMenuItem): boolean;
 export declare class GioApplication extends GioApplicationBase {

package/lib/types/elements/adw-application-window.d.ts

@@ -1,10 +1,10 @@
-import { type AdwMenuInput, type AdwMenuModel } from '@gjsify/adwaita-core';
+import { type AdwMenuModel } from '@gjsify/adwaita-core';
 import type { AdwBreakpoint } from '@gjsify/adwaita-core';
 import type { AdwSlot } from '../slotted-children.js';
 import { GtkApplicationWindow } from './gtk-application-window.js';
 export declare class AdwApplicationWindow extends GtkApplicationWindow {
     private readonly _features;
-    private _model;
+    private readonly _slot;
     private _menubarEl;
     static get observedAttributes(): string[];
     /** The content area — the Adw.Window:content property. */
@@ -20,8 +20,8 @@ export declare class AdwApplicationWindow extends GtkApplicationWindow {
     get showMenubar(): boolean;
     set showMenubar(value: boolean);
     /** The menubar's model — what a GtkApplication would own here. */
-    get menuModel(): AdwMenuModel;
-    set menuModel(value: AdwMenuInput);
+    get menuModel(): AdwMenuModel | null;
+    set menuModel(value: AdwMenuModel | string | null);
     /** The menubar strip, or null before the window is connected. */
     get menubar(): HTMLDivElement | null;
     connectedCallback(): void;

package/lib/types/elements/adw-bin.d.ts

@@ -5,6 +5,19 @@ export declare class AdwBin extends WidgetElement {
     get child(): Element | null;
     /** `adw_bin_set_child`: replace the current child, unparenting it. */
     set child(value: Element | null);
+    /**
+     * `adw_bin_get_child` / `adw_bin_set_child` — the METHOD spelling of {@link child}.
+     *
+     * The property alone is not the whole door. `Adw.Bin:child` is reached two ways and only
+     * one of them is a property: markup writes `child:`, but code built against GI calls
+     * `bin.get_child()` / `bin.set_child(w)`, which is the spelling a `.blp`-driven widget
+     * shared across renderers uses — GJS and the NativeScript bridge both answer it
+     * (`AdwSingleChildBase`), and here it was missing, so the shared code died with
+     * `get_child is not a function` on the web and nowhere else.
+     */
+    get_child(): Element | null;
+    /** `adw_bin_set_child`. Refuses a child that already has a parent, as {@link setChild} does. */
+    set_child(child: Element | null): void;
     connectedCallback(): void;
     disconnectedCallback(): void;
     /**

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

@@ -1,8 +1,15 @@
-import type { AdwMenuActions, AdwMenuInput, AdwMenuModel, SplitButtonDirection } from '@gjsify/adwaita-core';
+import type { AdwMenuActions, AdwMenuModel, SplitButtonDirection } from '@gjsify/adwaita-core';
 import './gtk-popover.js';
 import { WidgetElement } from '../widget-element.js';
 export declare class AdwSplitButton extends WidgetElement {
     private readonly _state;
+    /**
+     * The model's door, tree snapshot and `items-changed` subscription (ADR 0128). The
+     * STATE still owns the menu as a property — `dropdownEnabled` is derived from it and
+     * the notify order is libadwaita's — so every write here goes through the slot FIRST
+     * (which is what refuses it and snapshots it) and is then handed to the state.
+     */
+    private readonly _slot;
     private _actionEl;
     private _dropdownEl;
     private _arrowEl;
@@ -24,39 +31,23 @@ export declare class AdwSplitButton extends WidgetElement {
     /** The symbolic icon name, or `null` when the action half shows a label or nothing. */
     get iconName(): string | null;
     set iconName(value: string);
-    /** The menu, normalised (ADR 0042). Empty when the dropdown has none. */
-    get menuModel(): AdwMenuModel;
     /**
-     * Set the menu from anything the portable model accepts — a bare `string[]`, item
-     * descriptors, sections, submenus.
+     * The menu the dropdown pops up, by identity, or `null` when it has none (ADR 0128).
      *
-     * The REFUSAL is here rather than at render time: a `custom` item names an
-     * application widget this surface cannot host, and discovering that as a blank row
-     * three interactions later is what {@link assertMenuRenderable} exists to prevent.
+     * `null` is the ONLY spelling of "no menu" now: an empty model is a menu, so an empty
+     * one leaves the dropdown enabled exactly as it does in GTK, where a non-null model
+     * still builds a popover (measured, `MENU_MODEL_DOOR_VECTORS`).
      */
-    set menuModel(value: AdwMenuInput);
+    get menuModel(): AdwMenuModel | null;
     /**
-     * Normalise, REFUSE, store — the one door every menu comes through.
-     *
-     * The property setter is not the only way a menu arrives: an attribute is, and the
-     * first cut refused only the setter, so a `custom` item written in markup drew
-     * exactly the row `assertMenuRenderable` exists to prevent — one that reads like a
-     * command and does nothing.
-     *
-     * THE TWO DOORS REFUSE DIFFERENTLY, and the difference is which side can hear it.
-     * A property assignment is a CALL, so it throws and the caller can catch. An
-     * attribute is MARKUP, parsed by the browser: a throw from `connectedCallback` is
-     * not delivered to whoever appended the element, it is reported as an uncaught
-     * page error — measured, it broke `adwaita-upgrade-order.spec.ts`, which counts
-     * exactly those. Nobody can handle it and everybody else pays for it. So the
-     * attribute path REFUSES THE MENU (no menu, and a menu-less dropdown is
-     * insensitive, which is visible) and says why on `console.error`.
+     * Take a real model, a JSON string in the portable spelling, or `null`.
      *
-     * A REFUSAL AND A TYPO ARE STILL DIFFERENT THINGS. `parseMenuModel` is total
-     * because malformed JSON is an author slip and must not stop the element
-     * upgrading; `custom` is well-formed, deliberate, and unhonourable here.
+     * The REFUSAL is at the assignment rather than at render time: a `custom` item names
+     * an application widget this surface cannot host, and discovering that as a blank row
+     * three interactions later is what the refusal exists to prevent. {@link MenuSlot}
+     * owns the door; the state is handed only a menu this surface agreed to draw.
      */
-    private _acceptMenu;
+    set menuModel(value: AdwMenuModel | string | null);
     /**
      * What the action group publishes about the actions this menu names — the portable
      * stand-in for a `GActionGroup`, and the ONLY place a menu's enabled/checked state

package/lib/types/elements/adw-tab-overview.d.ts

@@ -1,4 +1,4 @@
-import { type AdwMenuInput, type AdwMenuModel } from '@gjsify/adwaita-core';
+import { type AdwMenuModel } from '@gjsify/adwaita-core';
 import type { AdwTabView } from './adw-tab-view.js';
 import { WidgetElement } from '../widget-element.js';
 export declare class AdwTabOverview extends WidgetElement {
@@ -20,7 +20,7 @@ export declare class AdwTabOverview extends WidgetElement {
     private _newTabBtn;
     private readonly _thumbs;
     private _view;
-    private _model;
+    private readonly _slot;
     private _searchActive;
     private _initialized;
     /** The last visibility actually painted, so `notify::open` fires on a real change. */
@@ -66,8 +66,8 @@ export declare class AdwTabOverview extends WidgetElement {
     get enableNewTab(): boolean;
     set enableNewTab(value: boolean);
     /** `Adw.TabOverview:secondary-menu` — the portal menu of extra actions. */
-    get secondaryMenu(): AdwMenuModel;
-    set secondaryMenu(value: AdwMenuInput);
+    get secondaryMenu(): AdwMenuModel | null;
+    set secondaryMenu(value: AdwMenuModel | string | null);
     /** `Adw.TabOverview:show-start-title-buttons`, TRUE upstream, so `="false"` turns it off. */
     get showStartTitleButtons(): boolean;
     set showStartTitleButtons(value: boolean);

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

@@ -1,10 +1,11 @@
-import type { AdwMenuActions, AdwMenuInput, AdwMenuModel, SplitButtonDirection } from '@gjsify/adwaita-core';
+import type { AdwMenuActions, AdwMenuModel, SplitButtonDirection } from '@gjsify/adwaita-core';
 import './gtk-popover.js';
 import { WidgetElement } from '../widget-element.js';
 export declare class GtkMenuButton extends WidgetElement {
     private _buttonEl;
     private _popoverEl;
-    private _model;
+    /** The model, its tree snapshot and its `items-changed` subscription (ADR 0128). */
+    private readonly _slot;
     private _actions;
     private _menuTitle;
     private _initialized;
@@ -12,41 +13,26 @@ export declare class GtkMenuButton extends WidgetElement {
     static get observedAttributes(): string[];
     /** Whether the popover menu is currently open. */
     get active(): boolean;
-    /** The menu, normalised (ADR 0042). Setting rebuilds the popover. */
-    get menuModel(): AdwMenuModel;
     /**
-     * Set the menu from anything the portable model accepts. Refused HERE, at the
-     * assignment, for a `custom` item this surface cannot host — see the split button's
-     * note on the same setter.
+     * The menu this button pops up, BY IDENTITY — the model itself, `null` when there is
+     * none, exactly as `gtk_menu_button_get_menu_model` answers (ADR 0128).
+     *
+     * It no longer answers an array, and `[]` is no longer how "no menu" is spelled: an
+     * EMPTY model is a menu that GTK still builds a popover for, and `null` is the one
+     * spelling of its absence (measured, `MENU_MODEL_DOOR_VECTORS`).
      */
-    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 menuModel(): AdwMenuModel | null;
     /**
-     * Normalise, REFUSE, store — the one door every menu comes through.
-     *
-     * The property setter is not the only way a menu arrives: an attribute is, and the
-     * first cut refused only the setter, so a `custom` item written in markup drew
-     * exactly the row `assertMenuRenderable` exists to prevent — one that reads like a
-     * command and does nothing.
-     *
-     * THE TWO DOORS REFUSE DIFFERENTLY, and the difference is which side can hear it.
-     * A property assignment is a CALL, so it throws and the caller can catch. An
-     * attribute is MARKUP, parsed by the browser: a throw from `connectedCallback` is
-     * not delivered to whoever appended the element, it is reported as an uncaught
-     * page error — measured, it broke `adwaita-upgrade-order.spec.ts`, which counts
-     * exactly those. Nobody can handle it and everybody else pays for it. So the
-     * attribute path REFUSES THE MENU (no menu, and a menu-less dropdown is
-     * insensitive, which is visible) and says why on `console.error`.
-     *
-     * A REFUSAL AND A TYPO ARE STILL DIFFERENT THINGS. `parseMenuModel` is total
-     * because malformed JSON is an author slip and must not stop the element
-     * upgrading; `custom` is well-formed, deliberate, and unhonourable here.
+     * Take a real model, a JSON string in the portable spelling, or `null`. Refused HERE,
+     * at the assignment, for a `custom` item this surface cannot host — {@link MenuSlot}
+     * owns both doors and the note on why they refuse differently.
      */
-    private _acceptMenu;
+    set menuModel(value: AdwMenuModel | string | null);
+    /** `Gtk.MenuButton:menu-model` — the GIR spelling of {@link menuModel}. */
+    get menu_model(): AdwMenuModel | null;
+    set menu_model(value: AdwMenuModel | string | null);
+    get_menu_model(): AdwMenuModel | null;
+    set_menu_model(value: AdwMenuModel | string | null): void;
     /**
      * 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
@@ -62,18 +48,20 @@ export declare class GtkMenuButton extends WidgetElement {
     set direction(value: SplitButtonDirection);
     connectedCallback(): void;
     attributeChangedCallback(name: string): void;
-    /**
-     * The `menu-model` attribute, through the core parser both elements share.
-     *
-     * The copy this replaces was weaker in a way markup can reach: it kept `id` and
-     * `icon` WHATEVER their runtime type, so `{"label":"Open","id":7}` produced an
-     * entry whose `id` is a number in a field typed `string` — and `id` is what the
-     * activation event reports. The core parser keeps only string-typed attributes.
-     */
-    private _parseMenuAttr;
     private _onPopoverToggled;
     private _render;
     /** The registry's answer, unless the application wrote `actions` itself (ADR 0097 § 2). */
     private _refreshActions;
+    /**
+     * `gtk_menu_button_set_menu_model` notifies UNCONDITIONALLY — no identity guard, so the
+     * same model written twice notifies twice and `null` over `null` notifies as well
+     * (measured, `MENU_MODEL_NOTIFY_VECTORS`). Its `Adw.SplitButton` sibling guards on
+     * pointer equality, and the two disagree on purpose: a port with one rule for both is
+     * wrong about one of them.
+     *
+     * A MUTATION of the held model is not a write and notifies nothing — it arrives over
+     * `items-changed`, where it redraws the rows and stops.
+     */
+    private _notifyModel;
     private _renderMenu;
 }

package/lib/types/elements/gtk-popover-bin.d.ts

@@ -1,22 +1,29 @@
-import type { AdwMenuActions, AdwMenuInput, AdwMenuModel } from '@gjsify/adwaita-core';
+import type { AdwMenuActions, AdwMenuModel } from '@gjsify/adwaita-core';
 import './gtk-popover-menu.js';
 import type { GtkPopoverMenu } from './gtk-popover-menu.js';
 import { WidgetElement } from '../widget-element.js';
 export declare class GtkPopoverBin extends WidgetElement {
-    private _model;
+    /**
+     * The model's door and `items-changed` subscription (ADR 0128), with NOTHING to do
+     * when the menu it holds mutates: this bin draws no rows. The `<gtk-popover-menu>` it
+     * built holds the SAME model and watches it through a slot of its own, so the rows
+     * follow one level down — and GTK sends no `notify::menu-model` for a mutation either
+     * (measured, `MENU_MODEL_NOTIFY_VECTORS`).
+     */
+    private readonly _slot;
     private _popover;
     private _actions;
     private _initialized;
     private _longPressTimer;
     static get observedAttributes(): string[];
-    /** The menu model, normalised (ADR 0042). */
-    get menuModel(): AdwMenuModel;
+    /** The menu this bin pops up, by identity, or `null` (ADR 0128). */
+    get menuModel(): AdwMenuModel | null;
     /**
      * The model the popover is built from — ONE slot with `popover`, because GTK's two
      * setters clear each other (gtkpopoverbin.c:474-500, :543-551). A model REPLACES the
      * popover; a popover DROPS the model, and both notify for both properties.
      */
-    set menuModel(value: AdwMenuInput | AdwMenuModel);
+    set menuModel(value: AdwMenuModel | string | null);
     /**
      * The popover this bin presents, or `null`.
      *
@@ -61,6 +68,12 @@ export declare class GtkPopoverBin extends WidgetElement {
      * un-modified key beside Shift is the whole binding here.
      */
     private _onKeyDown;
+    /**
+     * The popover follows the PRESENCE of a model, not its length: an empty non-null
+     * `Gio.Menu` at `menu-model` still builds a `GtkPopoverMenu` in GTK and still
+     * dissociates an application-set popover (measured, `MENU_MODEL_DOOR_VECTORS`), and
+     * `null` is the one spelling of "no menu".
+     */
     private _buildPopover;
     /**
      * `set_popover` (gtkpopoverbin.c:543-587): hide and unparent the old one, parent the
@@ -74,10 +87,4 @@ export declare class GtkPopoverBin extends WidgetElement {
      * of its own to report.
      */
     private _notifyModel;
-    /**
-     * The `menu-model` ATTRIBUTE through the core parser, refusing a `custom` item the way
-     * every menu-bearing surface here does: markup is parsed by the browser, so a throw from
-     * `connectedCallback` would reach nobody and the menu would be silently empty.
-     */
-    private _parseMenuAttr;
 }

package/lib/types/elements/gtk-popover-menu-bar.d.ts

@@ -1,16 +1,24 @@
-import type { AdwMenuActions, AdwMenuInput, AdwMenuModel } from '@gjsify/adwaita-core';
+import type { AdwMenuActions, AdwMenuModel } from '@gjsify/adwaita-core';
 import './gtk-popover-menu.js';
 import { WidgetElement } from '../widget-element.js';
 export declare class GtkPopoverMenuBar extends WidgetElement {
-    private _model;
+    /** The model, its tree snapshot and its `items-changed` subscription (ADR 0128). */
+    private readonly _slot;
     private _actions;
     private _items;
     private _active;
     private _initialized;
     static get observedAttributes(): string[];
-    /** The menu model, normalised (ADR 0042). */
-    get menuModel(): AdwMenuModel;
-    set menuModel(value: AdwMenuInput);
+    /** The menu this bar draws, by identity, or `null` (ADR 0128). */
+    get menuModel(): AdwMenuModel | null;
+    set menuModel(value: AdwMenuModel | string | null);
+    /**
+     * The one place a changed menu is answered — from either door AND from a mutation of
+     * the menu the bar is holding, which is why the `console.warn` below is here rather
+     * than beside the attribute parse it used to live in: a toplevel entry that is not a
+     * submenu can arrive by `append_item` just as easily as by markup.
+     */
+    private _menuChanged;
     /** What the action group publishes about the actions these menus name (ADR 0042). */
     get actions(): AdwMenuActions | null;
     set actions(value: AdwMenuActions | null);
@@ -51,8 +59,8 @@ export declare class GtkPopoverMenuBar extends WidgetElement {
     /**
      * One `menubar > item > popover` (the node tree in gtkpopovermenubar.c:38-46).
      *
-     * A toplevel node that is not a submenu is refused by `_parseMenuAttr` with GTK's own
-     * wording rather than drawn: `tracker_insert` builds nothing for it
+     * A toplevel node that is not a submenu is WARNED about by {@link _menuChanged} with
+     * GTK's own wording rather than drawn: `tracker_insert` builds nothing for it
      * (gtkpopovermenubar.c:466), and a row that opens nothing is the same lie in another
      * shape.
      */
@@ -63,5 +71,4 @@ export declare class GtkPopoverMenuBar extends WidgetElement {
      * row is not the row that opened a submenu (gtkpopovermenu.c:257-259).
      */
     private _activate;
-    private _parseMenuAttr;
 }

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

@@ -1,27 +1,26 @@
-import type { AdwMenuActions, AdwMenuInput, AdwMenuModel } from '@gjsify/adwaita-core';
+import type { AdwMenuActions, AdwMenuModel } from '@gjsify/adwaita-core';
 import { GtkPopover } from './gtk-popover.js';
 export declare class GtkPopoverMenu extends GtkPopover {
-    private _model;
+    /** The model, its tree snapshot and its `items-changed` subscription (ADR 0128). */
+    private readonly _slot;
     private _actions;
     private _menuView;
     /** Named apart from `GtkPopover`'s own: two `private` fields of one name are two fields. */
     private _menuInitialized;
     static get observedAttributes(): string[];
-    /** The menu, normalised (ADR 0042). */
-    get menuModel(): AdwMenuModel;
+    /** The menu this popover draws, by identity, or `null` (ADR 0128). */
+    get menuModel(): AdwMenuModel | null;
     /**
-     * Set the menu from anything the portable model accepts, refusing a `custom` item
-     * HERE — at the assignment, where it is a call the caller can catch. An ATTRIBUTE is
-     * markup the browser parses, so the attribute path refuses the whole menu instead and
-     * says why on `console.error`, exactly as `<gtk-menu-button>` does.
+     * Take a real model, a JSON string in the portable spelling, or `null`, refusing a
+     * `custom` item HERE — at the assignment, where it is a call the caller can catch.
+     * An ATTRIBUTE is markup the browser parses, so that path refuses the whole menu and
+     * says why on `console.error`; {@link MenuSlot} owns both doors.
      *
-     * `AdwMenuModel` is in the union because a menu bar hands over a submenu's own `items`
-     * untouched, and `normalizeMenuModel` is documented to be IDEMPOTENT over an
-     * already-normalised node — that is what lets a renderer hand a model it is holding
-     * straight back. The one cast is where the core's parameter type (`AdwMenuInput`, whose
-     * entries are the AUTHORED shapes) is narrower than the behaviour it documents.
+     * A REAL MODEL IS WHAT A MENU BAR HANDS OVER for one of its submenus, and the model
+     * it hands over is `buildMenu(node.items)` — a menu of its own rather than this
+     * element's authored one, so the two cannot overwrite each other.
      */
-    set menuModel(value: AdwMenuInput | AdwMenuModel);
+    set menuModel(value: AdwMenuModel | string | null);
     /** What the action group publishes about the actions this menu names (ADR 0042). */
     get actions(): AdwMenuActions | null;
     set actions(value: AdwMenuActions | null);
@@ -81,5 +80,4 @@ export declare class GtkPopoverMenu extends GtkPopover {
      */
     private _activate;
     private _renderMenu;
-    private _parseMenuAttr;
 }

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

@@ -0,0 +1,49 @@
+import type { AdwMenuTree, GioMenuModel } from '@gjsify/adwaita-core';
+export declare class MenuSlot {
+    private readonly onItemsChanged;
+    /**
+     * The menu this element OWNS, so an edit to the same `menu-model="[…]"` attribute is a
+     * content change rather than a new menu — the popover already open follows it instead of
+     * being rebuilt (ADR 0128 § 5, the same rule `GjsifyOptionList` has for a list).
+     */
+    private readonly _authored;
+    private _model;
+    private _tree;
+    private _unwatch;
+    /** @param onItemsChanged what to do when the HELD menu mutates under the element. */
+    constructor(onItemsChanged: () => void);
+    /** The model itself, by identity — what `menuModel` answers and what a child is handed. */
+    get model(): GioMenuModel | null;
+    /** The snapshot every walker 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 GTK treats them differently: an
+     * empty non-null model still builds a `GtkPopoverMenu` and still dissociates an
+     * application-set popover (measured, `MENU_MODEL_DOOR_VECTORS`). This answers the
+     * question the ROWS ask — "is there a row to draw" — and the elements ask
+     * `model === null` where GTK asks about the model.
+     */
+    get isEmpty(): boolean;
+    /**
+     * A PROPERTY write: a real model by identity, a JSON string into the authored menu,
+     * `null` for no menu — and a `TypeError` for an array, which this door no longer takes
+     * (`buildMenu` is how an array becomes a model now).
+     *
+     * A REFUSAL PUTS THE AUTHORED MENU BACK, because the door has already reconciled it by
+     * the time the tree can be refused: without the restore a refused string would leave the
+     * element holding a menu it threw over, and the next render would draw it.
+     */
+    write(value: unknown): void;
+    /**
+     * The `menu-model` ATTRIBUTE, through the same door. A `null` attribute is no menu.
+     *
+     * A REFUSAL AND A TYPO ARE STILL DIFFERENT THINGS: `parseMenuModel` is total because
+     * malformed JSON is an author slip that must not stop the element upgrading, while a
+     * `custom` item is well-formed, deliberate, and unhonourable on this surface.
+     */
+    writeMarkup(value: string | null): void;
+    /** Hold `next`, snapshot it, and listen to it — the three that always happen together. */
+    private _adopt;
+}

package/lib/types/elements/popover-menu.d.ts

@@ -1,4 +1,4 @@
-import type { AdwMenuActions, AdwMenuModel, AdwMenuPath } from '@gjsify/adwaita-core';
+import type { AdwMenuActions, AdwMenuPath, AdwMenuTree } from '@gjsify/adwaita-core';
 import type { GtkPopover } from './gtk-popover.js';
 /**
  * Called when the reader chooses an item, with the path that addresses it in the WHOLE
@@ -19,7 +19,7 @@ export declare class PopoverMenuView {
     /** Class prefix for the element's own hooks — `adw-menu-button`, `adw-split-button-menu`. */
     private readonly prefix;
     private readonly onActivate;
-    private _model;
+    private _tree;
     private _actions;
     private _title;
     /** The submenu whose items are showing; `[]` is the root page. */
@@ -28,7 +28,7 @@ export declare class PopoverMenuView {
     private _openers;
     /** The row that LEAVES a page — what ArrowLeft acts on. */
     private _backRow;
-    /** The canonical text of the model showing, so an unchanged re-render keeps the page. */
+    /** The canonical text of the tree showing, so an unchanged re-render keeps the page. */
     private _key;
     private _rows;
     constructor(surface: GtkPopover, 
@@ -90,13 +90,17 @@ export declare class PopoverMenuView {
      */
     private focusPage;
     /**
-     * Named for the value it takes, and NOT `setModel` — the portable LIST model gave
+     * Named for the value it takes, which since ADR 0128 is a TREE and not a model: this
+     * view never holds a `Gio.MenuModel`, it walks the snapshot its element took, and a
+     * `setMenuModel` here would name a type it has no way to read. The element is the one
+     * place that owns the model.
+     *
+     * It was `setMenuModel` for the reason the rename keeps: the portable LIST model gave
      * `ComboState` a `setModel` (ADR 0046), and two methods called `setModel` over two
      * unrelated values on one surface is the collision the vocabulary work exists to
-     * remove. It also un-blinds `check-adwaita-collection-reactivity`, which resolves a
-     * collection call by the setter's name.
+     * remove.
      */
-    setMenuModel(model: AdwMenuModel): void;
+    setMenuTree(tree: AdwMenuTree): void;
     setActions(actions: AdwMenuActions | null): void;
     setTitle(title: string): void;
     /** Return to the root page — called when the popover closes. */

package/lib/types/index.d.ts

@@ -32,6 +32,7 @@ export { AdwBottomSheetBottomBar, AdwBottomSheetContent, AdwBottomSheetSheet } f
 export { AdwAlertResponse } from './elements/adw-alert-dialog.js';
 export type { GtkPopoverAlign, GtkPopoverPosition, GtkPopoverRole } from './elements/gtk-popover.js';
 export type { AdwViewStackPageInfo } from './elements/adw-view-stack.js';
-export type { AdwMenuActions, AdwMenuEntryInput, AdwMenuInput, AdwMenuItem, AdwMenuModel, AdwMenuNode, AdwMenuPath, AdwMenuSection, AdwMenuSubmenu, } from '@gjsify/adwaita-core';
+export { buildMenu, menuTree, watchMenuModel } from '@gjsify/adwaita-core';
+export type { AdwMenuActions, AdwMenuEntryInput, AdwMenuInput, AdwMenuItem, AdwMenuModel, AdwMenuNode, AdwMenuPath, AdwMenuSection, AdwMenuSubmenu, AdwMenuTree, } from '@gjsify/adwaita-core';
 export type { GtkDropDownOption } from './elements/gtk-drop-down.js';
 export type { AdwDialogPresentationMode } from './elements/adw-dialog.js';

package/lib/types/namespace/gio.d.ts

@@ -1,5 +1,5 @@
 import '../file-chooser-host.js';
-export { GioMenu as Menu, GioMenuItem as MenuItem } from '@gjsify/adwaita-core';
+export { GioMenu as Menu, GioMenuItem as MenuItem, GioMenuModel as MenuModel, GioMenuAttributeIter as MenuAttributeIter, GioMenuLinkIter as MenuLinkIter, MENU_ATTRIBUTE_ACTION, MENU_ATTRIBUTE_ACTION_NAMESPACE, MENU_ATTRIBUTE_ICON, MENU_ATTRIBUTE_LABEL, MENU_ATTRIBUTE_TARGET, MENU_EXPORTER_MAX_SECTION_SIZE, MENU_LINK_SECTION, MENU_LINK_SUBMENU, } from '@gjsify/adwaita-core';
 export { ListModel } from '@gjsify/adwaita-core';
 export { GioFile as File, GioListStore as ListStore, GioOutputStream as OutputStream, GioFileOutputStream as FileOutputStream, FileCreateFlags, IOErrorEnum, promisify as _promisify, } from '@gjsify/adwaita-core';
 export { SimpleAction, SimpleActionGroup, ApplicationFlags } from '@gjsify/adwaita-core';

package/lib/types/widget-element.d.ts

@@ -9,7 +9,13 @@ export declare class WidgetElement extends HTMLElement {
     get_visible(): boolean;
     /** `gtk_widget_set_visible`. */
     set_visible(visible: boolean): void;
-    /** `gtk_widget_get_first_child`: the first child element, `null` for a leaf. */
+    /**
+     * `gtk_widget_get_first_child`: the first child WIDGET, `null` for a leaf.
+     *
+     * The five walkers skip the elements a port builds for its own insides — `isWidgetNode`
+     * in `@gjsify/adwaita-core` carries the rule and the incident behind it, and the
+     * registered-class copy in `widgetTreeMembers()` answers from the same function.
+     */
     get_first_child(): Element | null;
     /** `gtk_widget_get_last_child`. */
     get_last_child(): Element | null;
@@ -17,7 +23,7 @@ export declare class WidgetElement extends HTMLElement {
     get_next_sibling(): Element | null;
     /** `gtk_widget_get_prev_sibling`. */
     get_prev_sibling(): Element | null;
-    /** `gtk_widget_get_parent`. */
+    /** `gtk_widget_get_parent`: the nearest ancestor that is a widget, not a port's own wrapper. */
     get_parent(): Element | null;
     /** `gtk_widget_get_width`: the layout box in CSS px; 0 until the widget is rendered. */
     get_width(): number;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gjsify/adwaita-web",
-    "version": "0.64.13-next.283",
+    "version": "0.64.14",
     "description": "Adwaita/Libadwaita web components for browser targets",
     "type": "module",
     "main": "./src/index.ts",
@@ -58,14 +58,14 @@
         "@codemirror/language": "^6.12.4",
         "@codemirror/state": "^6.7.0",
         "@codemirror/view": "^6.43.4",
-        "@gjsify/adwaita-core": "0.64.13-next.283",
-        "@gjsify/adwaita-fonts": "0.64.13-next.283",
-        "@gjsify/adwaita-icons": "0.64.13-next.283",
-        "@gjsify/gtksource-core": "0.64.13-next.283",
+        "@gjsify/adwaita-core": "^0.64.14",
+        "@gjsify/adwaita-fonts": "^0.64.14",
+        "@gjsify/adwaita-icons": "^0.64.14",
+        "@gjsify/gtksource-core": "^0.64.14",
         "@lezer/highlight": "^1.2.3"
     },
     "peerDependencies": {
-        "@gjsify/app-settings": "0.64.13-next.283"
+        "@gjsify/app-settings": "^0.64.14"
     },
     "peerDependenciesMeta": {
         "@gjsify/app-settings": {
@@ -73,11 +73,11 @@
         }
     },
     "devDependencies": {
-        "@gjsify/app-settings": "0.64.13-next.283",
-        "@gjsify/blueprint": "0.64.13-next.283",
-        "@gjsify/cli": "0.64.13-next.283",
-        "@gjsify/unit": "0.64.13-next.283",
-        "@gjsify/vite-plugin-blueprint": "0.64.13-next.283",
+        "@gjsify/app-settings": "^0.64.14",
+        "@gjsify/blueprint": "^0.64.14",
+        "@gjsify/cli": "^0.64.14",
+        "@gjsify/unit": "^0.64.14",
+        "@gjsify/vite-plugin-blueprint": "^0.64.14",
         "sass": "^1.101.0",
         "typescript": "^6.0.3"
     },
@@ -114,6 +114,5 @@
     "bugs": {
         "url": "https://github.com/gjsify/gjsify/issues"
     },
-    "homepage": "https://github.com/gjsify/gjsify/tree/main/packages/web/adwaita-web#readme",
-    "gitHead": "05fae97125a374e84bf57c2d2d086fb53523f205"
+    "homepage": "https://github.com/gjsify/gjsify/tree/main/packages/web/adwaita-web#readme"
 }

package/src/adw-application-window.spec.ts

@@ -8,6 +8,7 @@
 // <adw-window>'s spec and only the delta is asserted here.
 import { describe, it, expect } from '@gjsify/unit';
 import { driveWindowVectors, WINDOW_VECTORS } from '@gjsify/adwaita-core/conformance';
+import { menuTree } from '@gjsify/adwaita-core';
 
 import { webWindowSubject } from './gtk-window.spec.js';
 
@@ -114,12 +115,14 @@ export const AdwApplicationWindowTest = async () => {
 
         await it('a broken model is dropped rather than thrown', async () => {
             // `parseMenuModel` is total by construction: a typo in markup must not take
-            // the window down with it.
+            // the window down with it. Since ADR 0128 the window still HOLDS its authored
+            // menu — the typo empties it rather than removing it, and `null` is the only
+            // spelling of "no menu".
             const win = document.createElement('adw-application-window') as AdwApplicationWindow;
             win.setAttribute('menu-model', '{not json');
             win.setAttribute('show-menubar', '');
             document.body.appendChild(win);
-            expect(win.menuModel).toStrictEqual([]);
+            expect(menuTree(win.menuModel!)).toStrictEqual([]);
             expect(win.menubar?.hidden).toBe(true);
             win.remove();
         });