@gjsify/adwaita-web 0.64.12-next.279 → 0.64.12-next.281

package/src/elements/gtk-scrolled-window.ts

@@ -210,7 +210,9 @@ export class GtkScrolledWindow extends WidgetElement {
     private _fadeTimer: ReturnType<typeof setTimeout> | null = null;
     private _built = false;
     /** What an unbuilt window answers before it has a viewport to read. */
-    private readonly _standIn: { hadjustment?: AdwAdjustment; vadjustment?: AdwAdjustment } = {};
+    private readonly _standIn: { hadjustment?: GtkAdjustment; vadjustment?: GtkAdjustment } = {};
+    private readonly _heard = new WeakSet<object>();
+    private _pushing = false;
     private readonly _adopted: { hadjustment?: AdwAdjustment; vadjustment?: AdwAdjustment } = {};
 
     static get observedAttributes() {
@@ -265,21 +267,18 @@ export class GtkScrolledWindow extends WidgetElement {
         this.vscrollbarPolicy = v;
     }
 
-    /** `GtkScrollable:hadjustment` as the window reports it: the one it was given, else the viewport's. */
+    /**
+     * `GtkScrollable:hadjustment` as the window reports it: the one it was given, else its own.
+     *
+     * Either is ONE object for the window's life, observable like GTK's: the viewport's
+     * numbers are configured into it, and a write to its value scrolls the content.
+     */
     get hadjustment(): AdwAdjustment {
-        return (
-            this._adopted.hadjustment ??
-            (this._viewport as GtkViewport | undefined)?.hadjustment ??
-            (this._standIn.hadjustment ??= new GtkAdjustment())
-        );
+        return this._adjustmentOf('hadjustment');
     }
 
     get vadjustment(): AdwAdjustment {
-        return (
-            this._adopted.vadjustment ??
-            (this._viewport as GtkViewport | undefined)?.vadjustment ??
-            (this._standIn.vadjustment ??= new GtkAdjustment())
-        );
+        return this._adjustmentOf('vadjustment');
     }
 
     get_hadjustment(): AdwAdjustment {
@@ -290,13 +289,55 @@ export class GtkScrolledWindow extends WidgetElement {
         return this.vadjustment;
     }
 
-    /** Adopts `adjustment` as what `get_hadjustment` answers; the scroll position keeps following the viewport. */
+    /** Adopts `adjustment` as what `get_hadjustment` answers; it is kept in step with the viewport both ways. */
     set_hadjustment(adjustment: AdwAdjustment): void {
-        this._adopted.hadjustment = adjustment;
+        this._adopt('hadjustment', adjustment);
     }
 
     set_vadjustment(adjustment: AdwAdjustment): void {
-        this._adopted.vadjustment = adjustment;
+        this._adopt('vadjustment', adjustment);
+    }
+
+    private _adjustmentOf(key: 'hadjustment' | 'vadjustment'): AdwAdjustment {
+        const adopted = this._adopted[key];
+        if (adopted !== undefined) return adopted;
+        let own = this._standIn[key];
+        if (own === undefined) {
+            own = this._standIn[key] = new GtkAdjustment();
+            this._listen(key, own);
+            this._push(key);
+        }
+        return own;
+    }
+
+    private _adopt(key: 'hadjustment' | 'vadjustment', adjustment: AdwAdjustment): void {
+        this._adopted[key] = adjustment;
+        this._listen(key, adjustment);
+        this._push(key);
+    }
+
+    /** A write to the adjustment's value moves the scrollport; a plain object has no signal to hear. */
+    private _listen(key: 'hadjustment' | 'vadjustment', adjustment: AdwAdjustment): void {
+        if (!(adjustment instanceof GtkAdjustment) || this._heard.has(adjustment)) return;
+        this._heard.add(adjustment);
+        adjustment.connect('value-changed', () => {
+            if (this._pushing || this._adjustmentOf(key) !== adjustment || !this._viewport) return;
+            this._viewport.scrollAxis(key === 'hadjustment' ? 'horizontal' : 'vertical', adjustment.value);
+        });
+    }
+
+    /** Configures the window's adjustment of one axis from the viewport's numbers. */
+    private _push(key: 'hadjustment' | 'vadjustment'): void {
+        const viewport = this._viewport as GtkViewport | undefined;
+        const adjustment = this._adopted[key] ?? this._standIn[key];
+        if (!viewport?.isConnected || !(adjustment instanceof GtkAdjustment)) return;
+        const v = viewport[key];
+        this._pushing = true;
+        try {
+            adjustment.configure(v.value, v.lower, v.upper, v.stepIncrement, v.pageIncrement, v.pageSize);
+        } finally {
+            this._pushing = false;
+        }
     }
 
     /** `GtkScrolledWindow:window-placement` — where the contents sit against the bars. */
@@ -533,6 +574,8 @@ export class GtkScrolledWindow extends WidgetElement {
         // bars are not connected, so this pass has no adjustment to read and no geometry to
         // decide — `connectedCallback` ends with a `_sync()` of its own, once they are.
         if (bars === null || !this._viewport.isConnected || !bars.vertical.isConnected) return;
+        this._push('hadjustment');
+        this._push('vadjustment');
         const placement = this.windowPlacement;
         const indicators = this._useIndicators;
         this.classList.toggle('frame', this.hasFrame);
@@ -621,6 +664,8 @@ export class GtkScrolledWindow extends WidgetElement {
         const bars = this._bars;
         if (bars === null) return;
         const detail = (event as CustomEvent<{ hadjustment: AdwAdjustment; vadjustment: AdwAdjustment }>).detail;
+        this._push('hadjustment');
+        this._push('vadjustment');
         for (const axis of AXES) {
             const adjustment = detail[axis.key];
             (bars[axis.bar] as HTMLElement & { adjustment: AdwAdjustment }).adjustment = adjustment;

package/src/elements/gtk-stack.ts

@@ -387,6 +387,48 @@ export class GtkStack extends WidgetElement {
         child.remove();
     }
 
+    /**
+     * `gtk_stack_remove` under its GIR name. With no argument it stays `ChildNode.remove()`:
+     * the stack leaves its own parent.
+     */
+    override remove(child?: HTMLElement): void {
+        if (child === undefined) {
+            super.remove();
+            return;
+        }
+        this.removePage(child);
+    }
+
+    /** `gtk_stack_add_titled` under its GIR name. */
+    add_titled(child: HTMLElement, name: string | null, title: string | null): HTMLElement {
+        return this.addTitled(child, name, title);
+    }
+
+    /** `gtk_stack_add_named` under its GIR name. */
+    add_named(child: HTMLElement, name: string | null): HTMLElement {
+        return this.addNamed(child, name);
+    }
+
+    /** `gtk_stack_get_visible_child_name`. */
+    get_visible_child_name(): string | null {
+        return this.visibleChildName;
+    }
+
+    /** `gtk_stack_set_visible_child_name`. */
+    set_visible_child_name(name: string): void {
+        this.setVisibleChildName(name);
+    }
+
+    /** `gtk_stack_get_visible_child`. */
+    get_visible_child(): HTMLElement | null {
+        return this.visibleChild;
+    }
+
+    /** `gtk_stack_set_visible_child`. */
+    set_visible_child(child: HTMLElement): void {
+        this.setVisibleChild(child);
+    }
+
     /**
      * `gtk_stack_set_visible_child` (gtkstack.c:2244-2281), with `gtk_stack_set_visible_
      * child_full`'s per-call transition (gtkstack.c:2306-2334). A child that is not in

package/src/elements/gtk-window.ts

@@ -96,7 +96,7 @@
 // Copyright (c) The GTK Team. LGPLv2.1+.
 // Modifications: Implemented as a Web Component for @gjsify/adwaita-web.
 
-import { CloseRequestState, WindowMemberState, type WindowMemberProperty } from '@gjsify/adwaita-core';
+import { CloseRequestState, WindowMemberState, stepDefaultSize, type WindowMemberProperty } from '@gjsify/adwaita-core';
 
 import { defineWindowApplication, type GtkApplication } from '../application.js';
 import { installElementApi } from '../gobject-elements.js';
@@ -171,14 +171,6 @@ export class GtkWindow extends WidgetElement {
     declare get_application: () => GtkApplication | null;
     declare set_application: (application: GtkApplication | null) => void;
 
-    /** `GObject.Object.connect`: installed per instance by `installElementApi`; refuses an undeclared signal. */
-    declare connect: (signal: string, handler: (emitter: this, ...args: any[]) => unknown) => number;
-    /** `GObject.Object.disconnect`: throws for an id that is not connected. */
-    declare disconnect: (id: number) => void;
-    /** `GObject.Object.emit`; `close-request` is refused, call `close()`. */
-    declare emit: (signal: string, ...args: unknown[]) => void;
-    /** `GObject.Object.notify`. */
-    declare notify: (name: string) => void;
     /** `GObject.Object.get_property`, by GTK's dashed name. */
     declare get_property: (name: string) => unknown;
     /** `GObject.Object.set_property`; a read-only property throws. */
@@ -281,6 +273,26 @@ export class GtkWindow extends WidgetElement {
         this._write('deletable', String(value));
     }
 
+    /** `Gtk.Window:hide-on-close` — `close()` hides the window instead of destroying it. */
+    get hide_on_close(): boolean {
+        return this._offByDefault('hide-on-close');
+    }
+
+    set hide_on_close(value: boolean) {
+        if (this._offByDefault('hide-on-close') === value) return;
+        this._write('hide-on-close', String(value));
+    }
+
+    /** `gtk_window_get_hide_on_close`. */
+    get_hide_on_close(): boolean {
+        return this.hide_on_close;
+    }
+
+    /** `gtk_window_set_hide_on_close`. */
+    set_hide_on_close(setting: boolean): void {
+        this.hide_on_close = setting;
+    }
+
     /**
      * `setAttribute` for a write that changes nothing. Every GObject setter here returns
      * early when the value is already right (gtkwindow.c:1015-1017, :1045-1046, :894-895),
@@ -540,7 +552,7 @@ export class GtkWindow extends WidgetElement {
     close(): boolean {
         const outcome = this._closing.close({
             realized: this.isConnected,
-            hideOnClose: this._offByDefault('hide-on-close'),
+            hideOnClose: this.hide_on_close,
             emit: () => {
                 const request = new CustomEvent('close-request', { bubbles: true, cancelable: true });
                 this.dispatchEvent(request);
@@ -613,6 +625,27 @@ export class GtkWindow extends WidgetElement {
         this._members.reportFocus(this.get_focus());
     }
 
+    /** `gtk_window_get_default_size`: `[width, height]`, `[0, 0]` while neither attribute is set. */
+    get_default_size(): [number, number] {
+        const read = (name: string): number => {
+            const value = Number.parseInt(this.getAttribute(name) ?? '', 10);
+            return Number.isFinite(value) ? value : 0;
+        };
+        return [read('default-width'), read('default-height')];
+    }
+
+    /**
+     * `gtk_window_set_default_size`: a value below -1 is refused (GTK's `g_return_if_fail`), an
+     * equal one does not notify, and `default-height` notifies before `default-width`.
+     */
+    set_default_size(width: number, height: number): void {
+        const step = stepDefaultSize(this.get_default_size(), width, height);
+        if (step === null) return;
+        for (const property of step.changed) {
+            this._write(property, String(property === 'default-width' ? step.width : step.height));
+        }
+    }
+
     /** `gtk_window_is_maximized`: the FRAME's state, not the browser window's. */
     is_maximized(): boolean {
         return this.maximized;

package/src/gdk.spec.ts

@@ -6,6 +6,9 @@
 
 import {
     driveGdkClipboardVectors,
+    driveRGBAVectors,
+    RGBA_VECTORS,
+    type GdkRGBALike,
     GDK_CLIPBOARD_VECTORS,
     type GdkClipboardNamespaces,
 } from '@gjsify/adwaita-core/conformance';
@@ -51,6 +54,12 @@ export const GdkTest = async () => {
         ),
     );
 
+    await driveRGBAVectors(
+        { name: 'adwaita-web', isOracle: false, Gdk: Gdk as unknown as GdkRGBALike },
+        { describe, it, expect },
+        RGBA_VECTORS,
+    );
+
     await describe('adwaita-web: Gdk clipboard door', async () => {
         const mounted = () => {
             const view = document.createElement('gtk-source-view') as GtkSourceView;

package/src/gobject-door.spec.ts

@@ -5,6 +5,7 @@ import { describe, expect, it } from '@gjsify/unit';
 
 import { Adw, GObject } from './index.js';
 import { tagForTypeName } from './gobject-door.js';
+import { listenElement } from './gobject-elements.js';
 import type { SharedTreeNode } from '@gjsify/adwaita-core/conformance';
 import { bindProperties } from '@gjsify/adwaita-core';
 
@@ -90,6 +91,45 @@ GObject.registerClass(
     GoWebSensitive as never,
 );
 
+const SiblingsTemplate = tree(`template $GoWebSiblings : Adw.Bin {
+    child: Gtk.Box {
+        Gtk.Label caption { label: bind peer.title; }
+    };
+}
+
+Adw.AlertDialog unsavedChangesDialog { heading: "Save changes?"; }
+
+$GoWebPeer peer { }`);
+
+class GoWebPeer extends Adw.Bin {
+    declare title: string;
+}
+GObject.registerClass(
+    {
+        GTypeName: 'GoWebPeer',
+        Properties: { title: GObject.ParamSpec.string('title', '', '', GObject.ParamFlags.READWRITE, 'first') },
+    },
+    GoWebPeer as never,
+);
+
+class GoWebSiblings extends Adw.Bin {
+    declare _unsavedChangesDialog: HTMLElement & { heading: string };
+    declare _peer: GoWebPeer;
+    declare _caption: HTMLElement & { label: string };
+    constructor(params?: Record<string, unknown>) {
+        // @ts-expect-error the element's own constructor takes none; the registered class's takes the params
+        super(params);
+    }
+}
+GObject.registerClass(
+    {
+        GTypeName: 'GoWebSiblings',
+        Template: SiblingsTemplate,
+        InternalChildren: ['unsavedChangesDialog', 'peer', 'caption'],
+    },
+    GoWebSiblings as never,
+);
+
 export const GObjectDoorTest = async () => {
     await driveGObjectVectors(subject, { describe, it, expect }, GOBJECT_VECTORS);
     await describe('adwaita-web: GObject.registerClass end to end (ADR 0096)', async () => {
@@ -97,6 +137,24 @@ export const GObjectDoorTest = async () => {
             expect(tagForTypeName('Hexdump')).toBe('gjsify-hexdump');
             expect(customElements.get('gjsify-go-web-hexdump')).toBe(GoWebHexdump);
         });
+        await it('reaches the objects written beside the template through InternalChildren, outside its children', () => {
+            const el = new GoWebSiblings();
+            expect(el._unsavedChangesDialog.localName).toBe('adw-alert-dialog');
+            expect(el._peer instanceof GoWebPeer).toBe(true);
+            document.body.append(el);
+            try {
+                // Independent objects, as in GTK: neither is a child of the template widget.
+                expect(el.contains(el._unsavedChangesDialog)).toBe(false);
+                expect(el.contains(el._peer)).toBe(false);
+                expect(el.contains(el._caption)).toBe(true);
+                // A template child names a sibling by id, and follows it.
+                expect(el._caption.label).toBe('first');
+                el._peer.title = 'second';
+                expect(el._caption.label).toBe('second');
+            } finally {
+                el.remove();
+            }
+        });
         await it('refuses a second class under the same tag', () => {
             expect(() =>
                 GObject.registerClass({ GTypeName: 'GoWebHexdump' }, class extends Adw.Bin {} as never),
@@ -160,4 +218,80 @@ export const GObjectDoorTest = async () => {
             expect(el._sw.hasAttribute('disabled')).toBe(true);
         });
     });
+    await describe('adwaita-web: a signal is per instance, as in GObject', async () => {
+        const nested = (tag: string) => {
+            const parent = document.createElement(tag) as HTMLElement;
+            const child = document.createElement(tag) as HTMLElement;
+            parent.append(child);
+            document.body.append(parent);
+            return { parent, child };
+        };
+        await it('notify::visible-child-name of a child stack is not heard on the parent', () => {
+            const { parent, child } = nested('adw-view-stack');
+            let heard = 0;
+            listenElement(parent, 'notify::visible-child-name', () => heard++);
+            child.dispatchEvent(new CustomEvent('notify::visible-child-name', { bubbles: true }));
+            expect(heard).toBe(0);
+            parent.dispatchEvent(new CustomEvent('notify::visible-child-name', { bubbles: true }));
+            expect(heard).toBe(1);
+            parent.remove();
+        });
+        await it('activated of a child row is not heard on the parent, but still bubbles in the DOM', () => {
+            const { parent, child } = nested('adw-action-row');
+            let heard = 0;
+            let bubbled = 0;
+            listenElement(parent, 'activated', () => heard++);
+            parent.addEventListener('activated', () => bubbled++);
+            child.dispatchEvent(new CustomEvent('activated', { bubbles: true }));
+            expect(heard).toBe(0);
+            expect(bubbled).toBe(1);
+            parent.dispatchEvent(new CustomEvent('activated', { bubbles: true }));
+            expect(heard).toBe(1);
+            parent.remove();
+        });
+        await it('clicked of a nested button is not heard on the outer one; a click on plain content is', () => {
+            const { parent, child } = nested('gtk-button');
+            const inner = document.createElement('span');
+            parent.append(inner);
+            let heard = 0;
+            listenElement(parent, 'clicked', () => heard++);
+            child.dispatchEvent(new Event('click', { bubbles: true }));
+            expect(heard).toBe(0);
+            inner.dispatchEvent(new Event('click', { bubbles: true }));
+            expect(heard).toBe(1);
+            parent.remove();
+        });
+    });
+    await describe('adwaita-web: a bare element has the GObject signal API', async () => {
+        await it('connects to a signal on createElement, and disconnects by id', () => {
+            const stack = document.createElement('adw-view-stack') as HTMLElement & {
+                connect(signal: string, handler: () => void): number;
+                disconnect(id: number): void;
+            };
+            document.body.append(stack);
+            let heard = 0;
+            const id = stack.connect('notify::visible-child-name', () => heard++);
+            stack.dispatchEvent(new CustomEvent('notify::visible-child-name'));
+            expect(heard).toBe(1);
+            stack.disconnect(id);
+            stack.dispatchEvent(new CustomEvent('notify::visible-child-name'));
+            expect(heard).toBe(1);
+            stack.remove();
+        });
+        await it('connects to clicked on a bare button', () => {
+            const button = document.createElement('gtk-button') as HTMLElement & {
+                connect(signal: string, handler: () => void): number;
+            };
+            let heard = 0;
+            button.connect('clicked', () => heard++);
+            button.click();
+            expect(heard).toBe(1);
+        });
+        await it('refuses a signal the element does not declare', () => {
+            const button = document.createElement('gtk-button') as HTMLElement & {
+                connect(signal: string, handler: () => void): number;
+            };
+            expect(() => button.connect('no-such-signal', () => {})).toThrow();
+        });
+    });
 };

package/src/gobject-elements.ts

@@ -106,6 +106,18 @@ export function ensureNotifying(el: HTMLElement, property: string): void {
     });
 }
 
+/**
+ * The element a bubbled DOM event is the GTK signal of: the nearest one from `target` up that
+ * declares `signal` as `event`. A click on plain content inside a button is the button's `clicked`;
+ * a click on a nested button is that button's, and a signal is per instance in GObject.
+ */
+function signalOwner(target: EventTarget | null, signal: string, event: string): Element | null {
+    for (let at = target instanceof Element ? target : null; at !== null; at = at.parentElement) {
+        if (dispatchedSignalsOf(at)[signal] === event) return at;
+    }
+    return null;
+}
+
 /** Calls `handler(el, ...args)` for `signal`; returns the disconnect. */
 export function listenElement(el: HTMLElement, signal: string, handler: Handler): () => void {
     const event = eventOf(el, signal);
@@ -114,6 +126,7 @@ export function listenElement(el: HTMLElement, signal: string, handler: Handler)
     const listener = (domEvent: Event) => {
         // A notification bubbles, and a parent must not hear its child's property as its own.
         if (notification && domEvent.target !== el) return;
+        if (!notification && !EMITTED.has(domEvent) && signalOwner(domEvent.target, signal, event) !== el) return;
         const handled = handler(el, ...(EMITTED.has(domEvent) ? ((domEvent as CustomEvent).detail as unknown[]) : []));
         // A GTK handler of a boolean-handled signal (`close-request`) returns true to take it over,
         // which on a cancelable DOM event is `preventDefault()`; the handlers after it do not run.
@@ -198,8 +211,10 @@ export function installVisible(el: HTMLElement): void {
 
 /** Gives `el` the instance API of a registered class, over the events it declares. */
 export function installElementApi(el: HTMLElement): void {
-    // A registered class already has the core's four methods on its prototype.
-    if (typeof (el as unknown as Record<string, unknown>).connect === 'function') return;
+    // A registered class already has the core's four methods on its prototype; the stubs of
+    // `defineLazyElementApi` are not those, they exist to run this.
+    const inherited = (el as unknown as Record<string, unknown>).connect;
+    if (typeof inherited === 'function' && !LAZY_API.has(inherited)) return;
     WITH_API.add(el);
     const connections = new Map<number, () => void>();
     const define = (name: string, value: unknown) =>
@@ -237,6 +252,15 @@ export function installElementApi(el: HTMLElement): void {
     define('has_css_class', (name: string): boolean => el.classList.contains(name));
 }
 
+const LAZY_API = new WeakSet<object>();
+
+/** Marks the self-installing `connect` / `disconnect` / `emit` / `notify` of `proto` ({@link WidgetElement}). */
+export function markLazyElementApi(proto: object): void {
+    for (const name of ['connect', 'disconnect', 'emit', 'notify']) {
+        LAZY_API.add((proto as Record<string, object>)[name]);
+    }
+}
+
 const API_MEMBERS = new Set(['connect', 'disconnect', 'emit', 'notify', 'get_property', 'set_property']);
 
 /**

package/src/gtk-box.spec.ts

@@ -33,6 +33,10 @@ function mount(count = 3): { box: GtkBox; kids: HTMLElement[]; host: HTMLElement
     return { box, kids, host };
 }
 
+/** The children by position in `kids`, `x` for the one extra. */
+const order = (box: Element, kids: Element[], extra?: Element): string =>
+    [...box.children].map((el) => (el === extra ? 'x' : kids.indexOf(el))).join(',');
+
 const rect = (el: Element) => el.getBoundingClientRect();
 
 /** Author `value` the way markup does: absent is no attribute at all. */
@@ -138,6 +142,40 @@ export const GtkBoxTest = async () => {
             ],
         };
 
+        await it('remove(child) detaches a direct child and leaves a stranger alone', () => {
+            const { box, kids, host } = mount(3);
+            const warn = console.warn;
+            const warnings: unknown[] = [];
+            console.warn = (...args: unknown[]) => void warnings.push(args);
+            try {
+                box.remove(kids[1]);
+                expect(order(box, kids)).toBe('0,2');
+                box.remove(document.createElement('div'));
+                expect(box.children.length).toBe(2);
+                expect(warnings.length).toBe(1);
+                box.remove();
+                expect(box.isConnected).toBe(false);
+            } finally {
+                console.warn = warn;
+                host.remove();
+            }
+        });
+
+        await it('insert_child_after and reorder_child_after follow the NULL = FIRST rule', () => {
+            const { box, kids, host } = mount(3);
+            try {
+                const extra = document.createElement('div');
+                expect(box.insert_child_after(extra, null)).toBe(true);
+                expect(order(box, kids, extra)).toBe('x,0,1,2');
+                expect(box.insert_child_after(extra, kids[0])).toBe(false);
+                expect(box.reorder_child_after(extra, kids[2])).toBe(true);
+                expect(order(box, kids, extra)).toBe('0,1,2,x');
+                expect(box.reorder_child_after(document.createElement('div'), null)).toBe(false);
+            } finally {
+                host.remove();
+            }
+        });
+
         await it('mounts upgraded elements, stacked by the authored orientation and spacing', () => {
             const { root, unmount } = mountSharedTree(tree);
             try {

package/src/gtk-menu-button.spec.ts

@@ -177,6 +177,21 @@ export const GtkMenuButtonTest = async () => {
             unmountAll();
         });
 
+        await it('menu_model / get_menu_model / set_menu_model mirror menuModel', () => {
+            const el = document.createElement('gtk-menu-button') as MenuButtonElement & {
+                menu_model: AdwMenuInput;
+                get_menu_model(): unknown;
+                set_menu_model(v: AdwMenuInput): void;
+            };
+            document.body.appendChild(el);
+            el.set_menu_model(['Save', 'Quit']);
+            expect(el.get_menu_model()).toBe(el.menuModel);
+            expect(el.querySelectorAll('.adw-popover-item').length).toBe(2);
+            el.menu_model = ['Save'];
+            expect(el.querySelectorAll('.adw-popover-item').length).toBe(1);
+            unmountAll();
+        });
+
         await it('a malformed attribute is NOT a refusal — a typo may not stop the upgrade', () => {
             // The other half of the same rule: `parseMenuModel` stays total, so this
             // element upgrades with no menu instead of throwing.

package/src/gtk-stack.spec.ts

@@ -599,4 +599,30 @@ export const GtkStackTest = async () => {
             }
         });
     });
+
+    await describe('<gtk-stack> GIR method names', async () => {
+        await it('add_named / add_titled / the visible-child accessors follow the C functions', () => {
+            const { el, host } = mount();
+            const [a, b] = [1, 2].map(() => document.createElement('div'));
+            el.add_named(a!, 'a');
+            el.add_titled(b!, 'b', 'Beta');
+            expect(el.get_visible_child_name()).toBe('a');
+            el.set_visible_child_name('b');
+            expect(el.get_visible_child()).toBe(b!);
+            el.set_visible_child(a!);
+            expect(el.get_visible_child_name()).toBe('a');
+            host.remove();
+        });
+
+        await it('remove(child) removes the page; remove() still detaches the stack', () => {
+            const { el, host } = mount();
+            const a = document.createElement('div');
+            el.add_named(a, 'a');
+            el.remove(a);
+            expect(a.parentElement).toBe(null);
+            el.remove();
+            expect(el.parentElement).toBe(null);
+            host.remove();
+        });
+    });
 };

package/src/gtk-window.spec.ts

@@ -36,7 +36,7 @@ export function webWindowSubject(tag: string): { subject: WindowSubject; dispose
         create({ hideOnClose }) {
             // Never in a page: not realized, which is GTK's state for a window before `present()`.
             const el = document.createElement(tag) as GtkWindow;
-            if (hideOnClose) el.setAttribute('hide-on-close', 'true');
+            if (hideOnClose) el.hide_on_close = true;
             el.append(document.createElement('button'), document.createElement('button'));
             return el;
         },
@@ -65,6 +65,8 @@ export function webWindowSubject(tag: string): { subject: WindowSubject; dispose
         maximize: (w) => (w as GtkWindow).maximize(),
         unmaximize: (w) => (w as GtkWindow).unmaximize(),
         isMaximized: (w) => (w as GtkWindow).is_maximized(),
+        getDefaultSize: (w) => (w as GtkWindow).get_default_size(),
+        setDefaultSize: (w, width, height) => (w as GtkWindow).set_default_size(width, height),
         isVisible: (w) => (w as GtkWindow).isConnected && !(w as GtkWindow).hidden,
         focusables: (w) => [...(w as GtkWindow).querySelectorAll('button')] as unknown as [Element, Element],
         setFocus: (w, widget) => (w as GtkWindow).set_focus(widget as Element | null),
@@ -244,6 +246,38 @@ export const GtkWindowTest = async () => {
             host.remove();
         });
 
+        await it('`hide_on_close` is the real property, default false, and close() follows it', async () => {
+            const { el, host } = mount();
+            expect(el.hide_on_close).toBe(false);
+            expect(el.get_hide_on_close()).toBe(false);
+            el.set_hide_on_close(true);
+            expect(el.hide_on_close).toBe(true);
+            expect(el.getAttribute('hide-on-close')).toBe('true');
+            el.close();
+            expect(el.isConnected).toBe(true);
+            expect(el.hidden).toBe(true);
+            el.hidden = false;
+            el.hide_on_close = false;
+            expect(el.close()).toBe(true);
+            expect(el.isConnected).toBe(false);
+            host.remove();
+        });
+
+        await it('notify::hide-on-close fires on change only', async () => {
+            const { el, host } = mount();
+            let seen = 0;
+            el.connect('notify::hide-on-close', () => void seen++);
+            el.hide_on_close = false;
+            expect(seen).toBe(0);
+            el.set_hide_on_close(true);
+            expect(seen).toBe(1);
+            el.hide_on_close = true;
+            expect(seen).toBe(1);
+            el.hide_on_close = false;
+            expect(seen).toBe(2);
+            host.remove();
+        });
+
         await it('a handler that cancels `close-request` takes the whole thing over', async () => {
             // gtkwindow.c:1300-1320 — `g_signal_stop_emission_by_name` on the default handler.
             const { el, host } = mount();