@gjsify/adwaita-web 0.64.1 → 0.64.2-next.252

package/lib/types/widget-visible.spec.d.ts

@@ -0,0 +1 @@
+export declare const AdwWidgetVisibleTest: () => Promise<void>;

package/lib/types/window-maximize.spec.d.ts

@@ -0,0 +1 @@
+export declare const WindowMaximizeTest: () => Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gjsify/adwaita-web",
-    "version": "0.64.1",
+    "version": "0.64.2-next.252",
     "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.1",
-        "@gjsify/adwaita-fonts": "^0.64.1",
-        "@gjsify/adwaita-icons": "^0.64.1",
-        "@gjsify/gtksource-core": "^0.64.1",
+        "@gjsify/adwaita-core": "0.64.2-next.252",
+        "@gjsify/adwaita-fonts": "0.64.2-next.252",
+        "@gjsify/adwaita-icons": "0.64.2-next.252",
+        "@gjsify/gtksource-core": "0.64.2-next.252",
         "@lezer/highlight": "^1.2.3"
     },
     "peerDependencies": {
-        "@gjsify/app-settings": "^0.64.1"
+        "@gjsify/app-settings": "0.64.2-next.252"
     },
     "peerDependenciesMeta": {
         "@gjsify/app-settings": {
@@ -73,11 +73,11 @@
         }
     },
     "devDependencies": {
-        "@gjsify/app-settings": "^0.64.1",
-        "@gjsify/blueprint": "^0.64.1",
-        "@gjsify/cli": "^0.64.1",
-        "@gjsify/unit": "^0.64.1",
-        "@gjsify/vite-plugin-blueprint": "^0.64.1",
+        "@gjsify/app-settings": "0.64.2-next.252",
+        "@gjsify/blueprint": "0.64.2-next.252",
+        "@gjsify/cli": "0.64.2-next.252",
+        "@gjsify/unit": "0.64.2-next.252",
+        "@gjsify/vite-plugin-blueprint": "0.64.2-next.252",
         "sass": "^1.101.0",
         "typescript": "^6.0.3"
     },
@@ -114,5 +114,6 @@
     "bugs": {
         "url": "https://github.com/gjsify/gjsify/issues"
     },
-    "homepage": "https://github.com/gjsify/gjsify/tree/main/packages/web/adwaita-web#readme"
+    "homepage": "https://github.com/gjsify/gjsify/tree/main/packages/web/adwaita-web#readme",
+    "gitHead": "3853c65f772d30460e3894ff08a6079a70d7b206"
 }

package/scss/_bin.scss

@@ -14,13 +14,16 @@
 // Modifications: Adapted for @gjsify/adwaita-web Web Components.
 
 adw-bin {
-  display: block;
+  display: flex;
+  flex-direction: column;
 
   // One child, and it fills — `gtk_bin_layout_allocate` allocates the whole widget to
   // its single child. `:only-child` rather than `> *` because a bin keeps ONE
   // (`adw_bin_set_child` unparents the one it replaces), so the case where the selector
-  // could match two is one the element has already refused.
+  // could match two is one the element has already refused. Flex stretch rather than
+  // `block-size: 100%`: a percentage needs a definite parent height, which a bin that is
+  // itself a flex item (a stack page) only has by the stretch algorithm.
   > :only-child {
-    block-size: 100%;
+    flex: 1 1 auto;
   }
 }

package/scss/_overlay.scss

@@ -38,13 +38,23 @@
 // Modifications: Adapted for @gjsify/adwaita-web Web Components.
 
 gtk-overlay {
-  display: block;
+  // A column flex box rather than a block: `gtk_overlay_size_allocate` hands the main child
+  // the overlay's WHOLE allocation (gtkoverlay.c), and a block would give it only its content
+  // height. With an auto height the overlay still measures as its child (the child's
+  // `flex-basis: auto` is the content), with a definite one the child grows to fill it.
+  display: flex;
+  flex-direction: column;
   position: relative;
 }
 
 .adw-overlay-child {
   // The main child, in the host's own flow — see the header.
   display: contents;
+
+  // Fill the allocation on the main axis; the cross axis stretches by default.
+  > * {
+    flex: 1 1 auto;
+  }
 }
 
 .adw-overlay-layer {

package/scss/_reset.scss

@@ -48,7 +48,7 @@ $adw-components:
   gtk-link-button, gtk-list-box, gtk-list-box-row, gtk-list-view, gtk-media-controls, gtk-menu-button, gtk-overlay, gtk-page-setup-unix-dialog, gtk-paned,
   gtk-password-entry, gtk-picture, gtk-popover, gtk-popover-bin, gtk-popover-menu, gtk-popover-menu-bar, gtk-print-unix-dialog,
   gtk-progress-bar, gtk-revealer, gtk-scale, gtk-scale-button, gtk-scrollbar, gtk-scrolled-window, gtk-search-bar, gtk-search-entry, gtk-separator, gtk-source-view,
-  gtk-spin-button, gtk-spinner, gtk-stack, gtk-stack-sidebar, gtk-stack-switcher, gtk-switch, gtk-text, gtk-text-view, gtk-toggle-button, gtk-tree-expander, gtk-video, gtk-viewport,
+  gtk-spin-button, gtk-spinner, gtk-stack, gtk-stack-page, gtk-stack-sidebar, gtk-stack-switcher, gtk-switch, gtk-text, gtk-text-view, gtk-toggle-button, gtk-tree-expander, gtk-video, gtk-viewport,
   gtk-window, gtk-window-controls, gtk-window-handle;
 
 // Roots: re-root the inherited typographic properties (and the box model) so a

package/scss/_stack.scss

@@ -60,13 +60,19 @@ gtk-stack {
     // looks at the VISIBLE child alone on that axis (gtkstack.c:2899-2905) — the stack is
     // as big as the current page. Turned off, the stack is as big as the LARGEST page,
     // which is `max-content` on the cross axis and `flex: 1 1 auto` along the main one.
-    &:not([hhomogeneous]) > .adw-stack-page {
+    //
+    // The element reflects the flag as an ABSENT attribute or `=""` for TRUE and
+    // `="false"` for FALSE (`_flag`: `raw !== 'false'`, absent → the default TRUE), so
+    // only the literal `'false'` is the non-homogeneous state. `:not([hhomogeneous])`
+    // read a missing attribute as false and gave every default stack's page
+    // `width: max-content`, a zero-width page for a child with no intrinsic width.
+    &[hhomogeneous='false'] > .adw-stack-page {
         flex: 0 1 auto;
         width: max-content;
         max-width: 100%;
     }
 
-    &:not([vhomogeneous]) > .adw-stack-page {
+    &[vhomogeneous='false'] > .adw-stack-page {
         height: max-content;
         max-height: 100%;
     }

package/scss/_toast.scss

@@ -12,12 +12,22 @@
 
 adw-toast-overlay {
   position: relative;
-  display: block;
+  display: flex;
+  flex-direction: column;
 
-  // The wrapped content (Adw.ToastOverlay :child) occupies the overlay's box.
+  // The wrapped content (Adw.ToastOverlay :child) occupies the overlay's box: AdwToastOverlay
+  // allocates its child the full size (adw-toast-overlay.c size_allocate). A percentage height
+  // resolves against an indefinite one inside a block parent, so the fill is flex stretch.
   .adw-toast-overlay-content {
+    display: flex;
+    flex: 1 1 auto;
+    flex-direction: column;
+    min-height: 0;
     width: 100%;
-    height: 100%;
+
+    > * {
+      flex: 1 1 auto;
+    }
   }
 
   // The toast slot: layered over the bottom edge of the overlay and centered,

package/scss/_window.scss

@@ -43,6 +43,15 @@ adw-application-window {
     box-shadow: none;
   }
 
+  // A maximized or fullscreen window ignores its default size and fills the work area
+  // (gtkwindow.c); on a page that is the containing block. The element drops its inline
+  // `default-width`/`default-height` in these states so this can apply, and keeps the minimum.
+  &[maximized]:not([maximized="false"]),
+  &[fullscreened]:not([fullscreened="false"]) {
+    width: 100%;
+    height: 100%;
+  }
+
   // `present()` and `hide-on-close` toggle `hidden`, which `display: flex` would override.
   &[hidden] {
     display: none;
@@ -110,6 +119,13 @@ gtk-application-window {
     box-shadow: none;
   }
 
+  // The same fill as `adw-window` above: the default size is only the restored size.
+  &[maximized]:not([maximized="false"]),
+  &[fullscreened]:not([fullscreened="false"]) {
+    width: 100%;
+    height: 100%;
+  }
+
   // The strip: an application's `titlebar` slot, or the two window-control groups and the
   // window's own title. `min-width: 0` on the title is what lets a long one ellipsize
   // instead of pushing the end controls out of the frame.

package/src/adw-alert-dialog.spec.ts

@@ -124,8 +124,8 @@ export const AdwAlertDialogTest = async () => {
             // directly would assert a contract this element does not have.
             const { el, host } = mount({ 'close-response': 'cancel', open: '' });
             let seen: string | null = null;
-            el.addEventListener('response', (event) => {
-                seen = (event as CustomEvent<{ response: string }>).detail.response;
+            el.connect('response', (_dialog, response: string) => {
+                seen = response;
             });
             (el.querySelector('.adw-alert-dialog-scrim') as HTMLElement).click();
             expect(seen).toBe('cancel');
@@ -147,9 +147,9 @@ export const AdwAlertDialogTest = async () => {
     await describe('adw-alert-dialog responses before the first connect', async () => {
         await it('buttons added while detached appear once connected', () => {
             const el = document.createElement('adw-alert-dialog') as AdwAlertDialog;
-            el.addResponse('cancel', 'Cancel');
-            el.addResponse('ok', 'OK');
-            expect(el.getResponseLabel('ok')).toBe('OK');
+            el.add_response('cancel', 'Cancel');
+            el.add_response('ok', 'OK');
+            expect(el.get_response_label('ok')).toBe('OK');
             const host = document.createElement('div');
             document.body.appendChild(host);
             host.appendChild(el);
@@ -158,4 +158,70 @@ export const AdwAlertDialogTest = async () => {
             host.remove();
         });
     });
+
+    // The calls a GJS app makes (Learn6502's `notification.service.ts`), run as written.
+    await describe('adw-alert-dialog in the GJS construct-props form', async () => {
+        const Dialog = customElements.get('adw-alert-dialog') as unknown as new (
+            props?: Record<string, unknown>,
+        ) => AdwAlertDialog;
+
+        const confirmDialog = () => {
+            const dialog = new Dialog({
+                heading: 'Reset?',
+                body: 'This clears the memory.',
+                close_response: 'cancel',
+                default_response: 'confirm',
+            });
+            dialog.add_response('cancel', 'Cancel');
+            dialog.add_response('confirm', 'Confirm');
+            return dialog;
+        };
+
+        await it('takes the snake_case bag', () => {
+            const dialog = confirmDialog();
+            expect(dialog.heading).toBe('Reset?');
+            expect(dialog.body).toBe('This clears the memory.');
+            expect(dialog.get_close_response()).toBe('cancel');
+            expect(dialog.get_default_response()).toBe('confirm');
+        });
+
+        await it('refuses a key that is no Adw.AlertDialog property', () => {
+            expect(() => new Dialog({ no_such_prop: 1 })).toThrow();
+        });
+
+        await it('present() attaches it, a click emits response with the id, and closing detaches it', () => {
+            const dialog = confirmDialog();
+            const seen: unknown[][] = [];
+            dialog.connect('response', (emitter, response: string) => seen.push([emitter, response]));
+            dialog.present(null);
+            expect(dialog.isConnected).toBe(true);
+            expect(dialog.open).toBe(true);
+            const buttons = [...dialog.querySelectorAll('.adw-alert-dialog-response')] as HTMLButtonElement[];
+            buttons.find((b) => b.textContent === 'Confirm')!.click();
+            expect(seen.length).toBe(1);
+            expect(seen[0]![0]).toBe(dialog);
+            expect(seen[0]![1]).toBe('confirm');
+            expect(dialog.open).toBe(false);
+            expect(dialog.isConnected).toBe(false);
+        });
+
+        await it('a dismissal emits the close_response once, not the clicked one too', () => {
+            const dialog = confirmDialog();
+            const seen: string[] = [];
+            dialog.connect('response', (_dialog, response: string) => seen.push(response));
+            dialog.present(null);
+            (dialog.querySelector('.adw-alert-dialog-scrim') as HTMLElement).click();
+            expect(seen.join(',')).toBe('cancel');
+            expect(dialog.isConnected).toBe(false);
+        });
+
+        await it('remove_response drops the response and its button', () => {
+            const dialog = confirmDialog();
+            dialog.present(null);
+            dialog.remove_response('confirm');
+            expect(dialog.has_response('confirm')).toBe(false);
+            expect(dialog.querySelectorAll('.adw-alert-dialog-response').length).toBe(1);
+            dialog.remove();
+        });
+    });
 };

package/src/adw-bin.spec.ts

@@ -61,12 +61,13 @@ export const AdwBinTest = async () => {
             other.remove();
         });
 
-        await it('an empty bin is a block box, and its only child fills it', () => {
+        await it('a bin is a column flex box, and its only child fills it', () => {
             const { el, host } = mount([document.createElement('div')]);
             // A bin takes the size it is GIVEN and hands all of it to the child, which
-            // `GtkBinLayout` does on both axes (gtkbinlayout.c:81).
+            // `GtkBinLayout` does on both axes (gtkbinlayout.c:81). Flex stretch, not a
+            // percentage, so it also holds when the bin is itself a flex item.
             el.style.height = '120px';
-            expect(getComputedStyle(el).display).toBe('block');
+            expect(getComputedStyle(el).display).toBe('flex');
             const child = el.firstElementChild as HTMLElement;
             expect(child.getBoundingClientRect().height).toBe(120);
             host.remove();

package/src/adw-header-bar.spec.ts

@@ -233,6 +233,24 @@ export const AdwHeaderBarTest = async () => {
 
     // `windowtitle .title, .subtitle { padding: 0 12px }` (_header-bar.scss:214-227).
     // Measured beside a GTK render of the gallery's window-title `.blp`: 27px narrower here.
+    await describe('<adw-header-bar> packing', async () => {
+        await it('packs an untyped child from the start, declared or appended', async () => {
+            // adw-header-bar.c:1040-1041 — `type == NULL` is pack_start. A Blueprint `[start]`
+            // tags only the next child, so the buttons after it arrive untyped.
+            const tagged = document.createElement('button');
+            tagged.setAttribute('slot', 'start');
+            const declared = document.createElement('button');
+            const bar = mountHeaderBar({ title: 'T' }, [tagged, declared]);
+            const late = document.createElement('button');
+            bar.appendChild(late);
+            await Promise.resolve();
+            const start = bar.querySelector('.adw-header-bar-start');
+            const report = [tagged, declared, late].map((el) => el.parentElement === start);
+            unmountAll();
+            expect(report).toStrictEqual([true, true, true]);
+        });
+    });
+
     await describe('adw-window-title label sides', async () => {
         await it('pads its title and subtitle 12px on each side', () => {
             const title = document.createElement('adw-window-title');

package/src/adw-toast-overlay.spec.ts

@@ -1,12 +1,14 @@
 // DOM-level behaviour tests for <adw-toast-overlay>, in a real browser via the
 // @gjsify/adwaita-web browser test axis.
 //
-// `Adw.ToastOverlay` shows exactly ONE toast at a time and queues the rest FIFO,
+// `Adw.ToastOverlay` shows exactly ONE toast at a time and queues the rest,
 // advancing only when the visible one is dismissed (manually or by its timeout) — the
-// policy `AdwToastQueue` owns in `@gjsify/adwaita-core` and this element composes.
+// policy `ToastOverlayQueue` owns in `@gjsify/adwaita-core` and this element composes.
+// A toast is an `Adw.Toast`, added with `add_toast(toast)` as on GTK.
 //
 // Timing runs through core's injected `ToastScheduler` seam (a virtual clock), so the
 // auto-dismiss lifecycle is deterministic with no real timers.
+import { Toast } from '@gjsify/adwaita-core';
 import { describe, expect, it } from '@gjsify/unit';
 
 import type { AdwToastOverlay, ToastScheduler, ToastTimerHandle } from './elements/adw-toast-overlay.js';
@@ -65,12 +67,10 @@ export const AdwToastOverlayTest = async () => {
         await it('shows exactly one toast at a time, in FIFO order', async () => {
             const { overlay, clock, host } = mountOverlay();
 
-            overlay.addToast('First', { timeout: 3 });
-            overlay.addToast('Second', { timeout: 3 });
-            overlay.addToast('Third', { timeout: 3 });
+            overlay.add_toast(new Toast({ title: 'First', timeout: 3 }));
+            overlay.add_toast(new Toast({ title: 'Second', timeout: 3 }));
+            overlay.add_toast(new Toast({ title: 'Third', timeout: 3 }));
 
-            // BEFORE the fix this was ['First', 'Second', 'Third'] — all three
-            // strips mounted at once.
             expect(toastTitles(overlay)).toStrictEqual(['First']);
             expect(overlay.pendingToasts).toBe(2);
             expect(overlay.currentToast?.title).toBe('First');
@@ -96,8 +96,9 @@ export const AdwToastOverlayTest = async () => {
         await it('holds the queue while a sticky toast (timeout 0) is shown', async () => {
             const { overlay, clock, host } = mountOverlay();
 
-            overlay.addToast('Sticky', { timeout: 0 });
-            overlay.addToast('Next', { timeout: 3 });
+            const sticky = new Toast({ title: 'Sticky', timeout: 0 });
+            overlay.add_toast(sticky);
+            overlay.add_toast(new Toast({ title: 'Next', timeout: 3 }));
 
             // No timer was scheduled for the sticky toast, so time does not advance it.
             clock.advance(60_000);
@@ -105,7 +106,7 @@ export const AdwToastOverlayTest = async () => {
             expect(overlay.pendingToasts).toBe(1);
 
             // Dismissing it hands the slot to the queued toast.
-            overlay.dismiss();
+            sticky.dismiss();
             expect(toastTitles(overlay)).toStrictEqual(['Next']);
             expect(overlay.pendingToasts).toBe(0);
 
@@ -115,30 +116,34 @@ export const AdwToastOverlayTest = async () => {
         await it('advances the queue when the close button is pressed', async () => {
             const { overlay, host } = mountOverlay();
 
-            overlay.addToast('First', { timeout: 3 });
-            overlay.addToast('Second', { timeout: 3 });
+            const first = new Toast({ title: 'First', timeout: 3 });
+            let dismissed = 0;
+            first.connect('dismissed', () => {
+                dismissed += 1;
+            });
+            overlay.add_toast(first);
+            overlay.add_toast(new Toast({ title: 'Second', timeout: 3 }));
 
             const close = overlay.querySelector('.adw-toast-close-button') as HTMLButtonElement;
             close.click();
 
+            expect(dismissed).toBe(1);
             expect(toastTitles(overlay)).toStrictEqual(['Second']);
             expect(overlay.pendingToasts).toBe(0);
 
             host.remove();
         });
 
-        await it('runs the action callback and advances the queue', async () => {
+        await it('emits button-clicked and advances the queue', async () => {
             const { overlay, host } = mountOverlay();
 
+            const toast = new Toast({ title: 'File moved to Trash', timeout: 3, button_label: 'Undo' });
             let undone = 0;
-            overlay.addToast('File moved to Trash', {
-                timeout: 3,
-                buttonLabel: 'Undo',
-                onAction: () => {
-                    undone += 1;
-                },
+            toast.connect('button-clicked', () => {
+                undone += 1;
             });
-            overlay.addToast('Second', { timeout: 3 });
+            overlay.add_toast(toast);
+            overlay.add_toast(new Toast({ title: 'Second', timeout: 3 }));
 
             const action = overlay.querySelector('.adw-toast-action-button') as HTMLButtonElement;
             expect(action.textContent).toBe('Undo');
@@ -150,12 +155,51 @@ export const AdwToastOverlayTest = async () => {
             host.remove();
         });
 
-        await it('drops the queued toasts on clearToasts()', async () => {
+        await it('draws no action button without a button_label', async () => {
+            const { overlay, host } = mountOverlay();
+
+            overlay.add_toast(new Toast({ title: 'Saved' }));
+            expect(overlay.querySelector('.adw-toast-action-button')).toBeNull();
+
+            host.remove();
+        });
+
+        await it('renders the title as markup unless use_markup is off', async () => {
+            const { overlay, host } = mountOverlay();
+
+            overlay.add_toast(new Toast({ title: '<b>Bold</b>', timeout: 0 }));
+            expect(overlay.querySelector('.adw-toast-title b')?.textContent).toBe('Bold');
+            overlay.dismiss_all();
+
+            const { overlay: plain, host: plainHost } = mountOverlay();
+            plain.add_toast(new Toast({ title: '<b>Bold</b>', timeout: 0, use_markup: false }));
+            expect(plain.querySelector('.adw-toast-title b')).toBeNull();
+            expect(toastTitles(plain)).toStrictEqual(['<b>Bold</b>']);
+
+            host.remove();
+            plainHost.remove();
+        });
+
+        await it('shows a HIGH priority toast ahead of the current one', async () => {
+            const { overlay, host } = mountOverlay();
+
+            overlay.add_toast(new Toast({ title: 'Normal', timeout: 0 }));
+            const urgent = new Toast({ title: 'Urgent', timeout: 0, priority: 1 });
+            overlay.add_toast(urgent);
+
+            expect(toastTitles(overlay)).toStrictEqual(['Urgent']);
+            urgent.dismiss();
+            expect(toastTitles(overlay)).toStrictEqual(['Normal']);
+
+            host.remove();
+        });
+
+        await it('dismisses the visible toast and the queue on dismiss_all()', async () => {
             const { overlay, clock, host } = mountOverlay();
 
-            overlay.addToast('First', { timeout: 3 });
-            overlay.addToast('Second', { timeout: 3 });
-            overlay.clearToasts();
+            overlay.add_toast(new Toast({ title: 'First', timeout: 3 }));
+            overlay.add_toast(new Toast({ title: 'Second', timeout: 3 }));
+            overlay.dismiss_all();
 
             expect(overlay.currentToast).toBeNull();
             expect(overlay.pendingToasts).toBe(0);

package/src/application.spec.ts

@@ -95,6 +95,50 @@ export const ApplicationTest = async () => {
             (window as unknown as { application: object | null }).application = null;
             expect(press({ key: 's', ctrlKey: true })).toBe(false);
         });
+        await it('inhibit(LOGOUT) cancels beforeunload until uninhibit', () => {
+            const app = new Adw.Application({ application_id: 'org.gjsify.vec.WebInhibit' });
+            const unload = (): boolean => {
+                const event = new Event('beforeunload', { cancelable: true });
+                window.dispatchEvent(event);
+                return event.defaultPrevented;
+            };
+            expect(unload()).toBe(false);
+            const cookie = app.inhibit(null, Gtk.ApplicationInhibitFlags.LOGOUT, 'unsaved changes');
+            expect(cookie > 0).toBe(true);
+            expect(unload()).toBe(true);
+            app.uninhibit(cookie);
+            expect(unload()).toBe(false);
+        });
+        await it('every window class has application, get_application and set_application', () => {
+            const app = new Adw.Application({ application_id: 'org.gjsify.vec.WebWindowApp' });
+            const other = new Adw.Application({ application_id: 'org.gjsify.vec.WebWindowOther' });
+            for (const tag of ['gtk-window', 'gtk-application-window', 'adw-window', 'adw-application-window']) {
+                const window = document.createElement(tag) as unknown as Gtk.WindowCommon<Element>;
+                const notified: unknown[] = [];
+                window.connect('notify::application', () => notified.push(window.application));
+                expect(window.get_application()).toBe(null);
+                window.set_application(app as never);
+                expect(window.get_application()).toBe(app);
+                expect(window.application).toBe(app);
+                expect(app.get_windows().includes(window)).toBe(true);
+                window.set_application(other as never);
+                expect(app.get_windows().includes(window)).toBe(false);
+                expect(other.get_windows().includes(window)).toBe(true);
+                window.application = null;
+                expect(window.get_application()).toBe(null);
+                expect(other.get_windows().includes(window)).toBe(false);
+                expect(notified).toStrictEqual([app, other, null]);
+            }
+        });
+        await it('a window reaches inhibit through get_application()', () => {
+            const app = new Adw.Application({ application_id: 'org.gjsify.vec.WebWindowInhibit' });
+            const window = document.createElement('gtk-window') as unknown as Gtk.WindowCommon<Element>;
+            window.set_application(app as never);
+            const cookie = window.get_application()?.inhibit(window, Gtk.ApplicationInhibitFlags.LOGOUT, 'unsaved');
+            expect((cookie ?? 0) > 0).toBe(true);
+            window.get_application()?.uninhibit(cookie ?? 0);
+            window.set_application(null);
+        });
         await it('quit() takes the windows it added off the page', async () => {
             const app = new Adw.Application({ application_id: 'org.gjsify.vec.WebQuit' });
             const window = scene.window(app as never) as Element;

package/src/application.ts

@@ -10,10 +10,9 @@ import {
     withGtkApplication,
     activateWidgetAction as activateIn,
     activateMenuItem,
-    applicationOfWindow,
+    defineWindowApplicationMembers,
     dispatchAccelerator,
     menuActionsFor,
-    installActionMap,
     type AdwMenuItem,
     type AdwMenuActions,
     type AdwMenuModel,
@@ -40,8 +39,18 @@ export const webHost: ApplicationHost = {
     },
     exit() {},
     iconTheme: () => IconTheme.get_for_display(null),
+    guardUnload(active) {
+        if (active) window.addEventListener('beforeunload', confirmUnload);
+        else window.removeEventListener('beforeunload', confirmUnload);
+    },
 };
 
+/** The only hook a page has on Ctrl+Q, closing the tab and reload; the browser words the prompt. */
+function confirmUnload(event: BeforeUnloadEvent): void {
+    event.preventDefault();
+    event.returnValue = '';
+}
+
 /** An element's parent for action resolution; a popover is rooted at the widget that owns it. */
 export function parentOfElement(node: object): object | null {
     if (!(node instanceof Element)) return null;
@@ -88,23 +97,9 @@ function followAccelerators(window: object, application: WindowApplication | nul
 }
 
 /**
- * `Gtk.Window:application` and the window's `Gio.ActionMap` (`win.` actions) on an element class.
+ * `Gtk.Window:application`, `get_application()` and `set_application()` on a window element class.
  * Setting the property is `add_window`, as on GTK; setting it to `null` is `remove_window`.
  */
 export function defineWindowApplication(proto: object): void {
-    installActionMap(proto);
-    Object.defineProperty(proto, 'application', {
-        configurable: true,
-        enumerable: true,
-        get(this: object) {
-            return applicationOfWindow(this);
-        },
-        set(this: object, value: WindowApplication | null) {
-            const current = applicationOfWindow(this) as unknown as WindowApplication | null;
-            if (current === value) return;
-            current?.remove_window(this);
-            value?.add_window(this);
-            followAccelerators(this, value);
-        },
-    });
+    defineWindowApplicationMembers(proto, followAccelerators);
 }

package/src/capabilities.mjs

@@ -12,7 +12,5 @@ export const capabilities = {
     signal: 'implemented',
     bind: 'implemented',
     breakpoint: 'implemented',
-    'sibling-object': {
-        refused: 'the web builder mounts one root element and has no consumer for a second root yet (ADR 0093)',
-    },
+    'sibling-object': 'implemented',
 };