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

package/src/child-slot.spec.ts

@@ -0,0 +1,71 @@
+// A `.blp`'s `child:` (and every other widget-valued property) becomes `slot: '<property>'` in the
+// shared tree (`packages/infra/blueprint/src/project.mjs`). An element that routed only its
+// DEFAULT slot refused that name on mount, and before the refusal existed it left the child
+// beside the structure it had built — Learn6502's `Overlay { child: Adw.ToastOverlay { … } }`
+// was the measured case. Every element whose GTK class has such a property is mounted here
+// with it, and the child has to land where the element's own binding says that slot goes.
+import { describe, expect, it } from '@gjsify/unit';
+import type { SharedTreeNode } from '@gjsify/adwaita-core/conformance';
+
+import { mountSharedTree } from './shared-tree-builder.js';
+import { slottedChildrenOf } from './slotted-children.js';
+
+/** The GIR class, and the widget-valued property the tree writes as its child's slot. */
+const CASES: ReadonlyArray<readonly [string, string]> = [
+    ['GtkOverlay', 'child'],
+    ['AdwToastOverlay', 'child'],
+    ['AdwDialog', 'child'],
+    ['AdwAlertDialog', 'extra-child'],
+    ['GtkListBoxRow', 'child'],
+    ['GtkFlowBoxChild', 'child'],
+    ['GtkGraphicsOffload', 'child'],
+    ['GtkPaned', 'start-child'],
+    ['GtkPaned', 'end-child'],
+    ['GtkWindow', 'child'],
+    ['GtkWindowHandle', 'child'],
+    ['GtkPopover', 'child'],
+    ['AdwBreakpointBin', 'child'],
+    ['GtkPopoverBin', 'child'],
+    ['GtkViewport', 'child'],
+    ['GtkTreeExpander', 'child'],
+    ['GtkDragIcon', 'child'],
+    ['GtkSearchBar', 'child'],
+    ['AdwBin', 'child'],
+    ['AdwClamp', 'child'],
+    ['GtkScrolledWindow', 'child'],
+    ['GtkRevealer', 'child'],
+    ['GtkFrame', 'child'],
+    ['GtkExpander', 'child'],
+    ['AdwStatusPage', 'child'],
+];
+
+/** Where `child` ended up, read against the slot the parent itself declares. */
+function report(root: HTMLElement, child: Element, slot: string): string {
+    const declared = slottedChildrenOf(root)?.slots.find((candidate) => candidate.name === slot);
+    if (declared === undefined) return 'undeclared';
+    if (!root.contains(child)) return 'outside';
+    if (!('into' in declared)) return 'consumed';
+    return child.parentElement === declared.into ? 'routed' : `beside, under <${child.parentElement?.localName}>`;
+}
+
+export const AdwChildSlotTest = async () => {
+    await describe('adwaita-web: a widget-valued property in a tree is the slot it names', async () => {
+        for (const [tag, slot] of CASES) {
+            await it(`${tag} { ${slot}: … }`, () => {
+                const tree: SharedTreeNode = {
+                    tag,
+                    children: [{ tag: 'GtkBox', id: 'probe', slot }],
+                };
+                let outcome: string;
+                try {
+                    const { root, unmount } = mountSharedTree(tree);
+                    outcome = report(root, root.querySelector('#probe')!, slot);
+                    unmount();
+                } catch (error) {
+                    outcome = `refused: ${(error as Error).message}`;
+                }
+                expect(`${tag} ${slot}: ${outcome}`).toBe(`${tag} ${slot}: routed`);
+            });
+        }
+    });
+};

package/src/construct-vectors.spec.ts

@@ -13,7 +13,7 @@ import { describe, expect, it } from '@gjsify/unit';
 
 import type { AdwAlertDialog } from './elements/adw-alert-dialog.js';
 import { capabilities } from './capabilities.mjs';
-import { buildSharedTree, mountSharedTree } from './shared-tree-builder.js';
+import { buildSharedTree, buildWithSiblings, mountSharedTree } from './shared-tree-builder.js';
 import { registerTemplateClass } from './template-classes.js';
 
 const vector = (kind: string) => CONSTRUCT_VECTORS.find((each) => each.kind === kind)!.tree;
@@ -24,8 +24,21 @@ registerTemplateClass(EXTERN_VECTOR_CLASS, 'corpus-extern');
 
 function observe(vector: ConstructVector): unknown {
     if (vector.kind === 'sibling-object') {
-        buildSharedTree(vector.tree);
-        return undefined;
+        let feed: ((size: { width: number; height: number }) => void) | undefined;
+        const { root, siblings } = buildWithSiblings(vector.tree, {
+            observeSize: (_element, onSize) => {
+                feed = onSize;
+                return () => {};
+            },
+        });
+        const beside = siblings.get('beside')!;
+        return {
+            insideRoot: root.contains(beside) || beside.parentElement !== null,
+            label: BREAKPOINT_VECTOR_SIZES.map((size) => {
+                feed!(size);
+                return beside.getAttribute('label');
+            }),
+        };
     }
     if (vector.kind === 'layout') {
         // CSS Grid lines count from 1, GTK cells from 0: `2 / span 2` is column 1, columnSpan 2.
@@ -99,9 +112,9 @@ function observe(vector: ConstructVector): unknown {
         const dialog = root as unknown as AdwAlertDialog;
         return (vector.tree.extensions?.responses ?? []).map(({ id }) => ({
             id,
-            label: dialog.getResponseLabel(id),
-            appearance: dialog.getResponseAppearance(id),
-            enabled: dialog.getResponseEnabled(id),
+            label: dialog.get_response_label(id),
+            appearance: dialog.get_response_appearance(id),
+            enabled: dialog.get_response_enabled(id),
         }));
     } finally {
         unmount();
@@ -331,6 +344,38 @@ export const AdwConstructVectorsTest = async () => {
             expect(() => mountSharedTree(withBreakpoint('template'))).toThrow("id 'template'");
             expect(() => mountSharedTree(withBreakpoint('caption', 'wide please'))).toThrow('breakpoint condition');
         });
+        await it('hands a sibling back by id, a dialog included, and builds none of them into the root', () => {
+            const tree: SharedTreeNode = {
+                tag: 'GtkBox',
+                children: [{ tag: 'GtkLabel', id: 'inside' }],
+                siblings: [
+                    { tag: 'AdwAlertDialog', id: 'confirm', props: { heading: 'Save?' } },
+                    { tag: EXTERN_VECTOR_CLASS, extern: true, id: 'screen' },
+                ],
+            };
+            const { root, siblings, objects } = buildWithSiblings(tree);
+            expect([...siblings.keys()].join()).toBe('confirm,screen');
+            expect(siblings.get('screen') instanceof CorpusExtern).toBe(true);
+            expect(siblings.get('confirm')!.localName).toBe('adw-alert-dialog');
+            expect(siblings.get('confirm')!.getAttribute('heading')).toBe('Save?');
+            expect(root.querySelector('#screen')).toBe(null);
+            expect([...objects.keys()].sort().join()).toBe('confirm,inside,screen');
+        });
+        await it('refuses siblings through every one-root door, a sibling without an id, and a duplicate id', () => {
+            const withSiblings = (siblings: SharedTreeNode[]): SharedTreeNode => ({
+                tag: 'GtkBox',
+                children: [{ tag: 'GtkLabel', id: 'taken' }],
+                siblings,
+            });
+            const labelled = withSiblings([{ tag: 'GtkLabel', id: 'beside' }]);
+            expect(() => buildSharedTree(labelled)).toThrow('buildWithSiblings');
+            expect(() => mountSharedTree(labelled)).toThrow('buildWithSiblings');
+            expect(() => buildWithSiblings(withSiblings([{ tag: 'GtkLabel' }]))).toThrow('has no id');
+            expect(() => buildWithSiblings(withSiblings([{ tag: 'GtkLabel', id: 'taken' }]))).toThrow("id 'taken'");
+        });
+        await it('refuses a breakpoint setter that names a sibling the tree does not carry', () => {
+            expect(() => buildWithSiblings({ ...vector('sibling-object'), siblings: [] })).toThrow("id 'beside'");
+        });
         await it('does not read a registered name for a node that is not extern', () => {
             const el = buildSharedTree({ tag: 'GtkBox', children: [{ tag: 'GtkLabel' }] });
             expect(el.children[0]!.localName).toBe('gtk-label');

package/src/container-fill.spec.ts

@@ -0,0 +1,70 @@
+// Single-child containers hand their child the WHOLE allocation, on both axes: GtkOverlay's main
+// child (gtkoverlay.c size_allocate), AdwToastOverlay's child, GtkStack's visible page
+// (gtkstack.c:2778-2831) and AdwBin's child (gtkbinlayout.c:81). A block box gives a child only
+// its content height, and a percentage resolves against an indefinite one — these specs pin the
+// chain a real window builds: overlay > toast-overlay > stack > bin > view-stack.
+import { describe, expect, it } from '@gjsify/unit';
+
+function mount(html: string, width = 400, height = 300): { host: HTMLElement; box: (sel: string) => DOMRect } {
+    const host = document.createElement('div');
+    host.style.cssText = `width:${width}px;height:${height}px;display:flex;flex-direction:column`;
+    host.innerHTML = html;
+    document.body.appendChild(host);
+    const box = (sel: string) => (host.querySelector(sel) as HTMLElement).getBoundingClientRect();
+    return { host, box };
+}
+
+export const ContainerFillTest = async () => {
+    await describe('single-child containers fill', async () => {
+        await it('<gtk-overlay> gives its main child the whole sized overlay', () => {
+            const { host, box } = mount('<gtk-overlay style="flex:1"><div id="main"></div></gtk-overlay>');
+            expect(box('#main').width).toBe(400);
+            expect(box('#main').height).toBe(300);
+            host.remove();
+        });
+
+        await it('<gtk-overlay> still measures as its main child when unsized', () => {
+            const { host, box } = mount('<gtk-overlay id="o"><div style="height:70px"></div></gtk-overlay>');
+            expect(box('#o').height).toBe(70);
+            host.remove();
+        });
+
+        await it('<adw-toast-overlay> gives its child the whole overlay', () => {
+            const { host, box } = mount('<adw-toast-overlay style="flex:1"><div id="c"></div></adw-toast-overlay>');
+            expect(box('#c').width).toBe(400);
+            expect(box('#c').height).toBe(300);
+            host.remove();
+        });
+
+        await it('a default <gtk-stack> page fills both axes, even with a zero-intrinsic child', () => {
+            const { host, box } = mount(
+                '<gtk-stack style="flex:1"><div id="p" name="a"><div id="z"></div></div></gtk-stack>',
+            );
+            expect(box('#p').width).toBe(400);
+            expect(box('#p').height).toBe(300);
+            host.remove();
+        });
+
+        await it('hhomogeneous="false" sizes a page to max-content', () => {
+            const { host, box } = mount(
+                '<gtk-stack hhomogeneous="false" style="flex:1"><div id="p" name="a" style="width:max-content"><span>hi</span></div></gtk-stack>',
+            );
+            expect(box('#p').width < 400).toBe(true);
+            host.remove();
+        });
+
+        await it('overlay > toast-overlay > stack > bin > view-stack fills the box', async () => {
+            const { host, box } = mount(
+                `<gtk-overlay style="flex:1"><adw-toast-overlay><gtk-stack>
+                   <adw-bin id="b" name="a"><adw-view-stack id="v" style="flex:1"></adw-view-stack></adw-bin>
+                 </gtk-stack></adw-toast-overlay></gtk-overlay>`,
+            );
+            await new Promise((resolve) => requestAnimationFrame(resolve));
+            for (const sel of ['adw-toast-overlay', 'gtk-stack', '#b', '#v']) {
+                expect(box(sel).width).toBe(400);
+                expect(box(sel).height).toBe(300);
+            }
+            host.remove();
+        });
+    });
+};

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

@@ -5,11 +5,20 @@
 // with a unique string ID and a label; one may carry the suggested or
 // destructive appearance.
 //
-// Responses are declared imperatively via add_response() / addResponse() (the
-// Adw.AlertDialog API), or via <adw-alert-response> children consumed at connect
-// time. The dialog is hidden until `present()` (or setting the `open` attribute)
-// reveals it; Escape / scrim-click dismiss it — respecting the `close-response`
-// — unless can-close is suppressed by the close response.
+// Responses are declared imperatively via add_response() (the Adw.AlertDialog API),
+// or via <adw-alert-response> children consumed at connect time. The dialog is
+// hidden until `present()` (or setting the `open` attribute) reveals it; Escape /
+// scrim-click dismiss it — respecting the `close-response` — unless can-close is
+// suppressed by the close response.
+//
+// THE GJS FORM RUNS AS WRITTEN: `new Adw.AlertDialog({ heading, close_response })`,
+// `add_response(id, label)`, `connect('response', (dialog, id) => …)`, `present(parent)`.
+// The response verbs carry libadwaita's snake_case names only — the camelCase
+// `addResponse` / `setDefaultResponse` … this element used to publish had no GIR
+// counterpart. `present()` attaches a detached dialog to the document: libadwaita adds it
+// to the dialog host of `parent`'s ROOT window, and the page is that root here. A dialog
+// `present()` attached leaves the document again when it closes, as `adw_dialog_close`
+// unparents it from the host; one placed in markup stays where its author put it.
 //
 // Attributes:
 //   heading    (the bold heading text)
@@ -35,12 +44,12 @@
 // sizes) and laid out horizontally when prefer-wide-layout is set and there are no more
 // than two of them — the libadwaita measure/allocate heuristic in spirit, not to the px.
 //
-// Events:
-//   `response` (CustomEvent, bubbles, `detail = { response }`) when a response
-//     button is activated OR the dialog is dismissed (then `response` is the
-//     close-response ID) — mirrors the Adw.AlertDialog::response signal.
-//   `notify::heading` / `notify::body` / `notify::open` (CustomEvent, bubbles)
-//     mirroring the matching GObject properties.
+// Signals (declared in `static signals`, reached with `connect`):
+//   `response (dialog, id)` when a response button is activated OR the dialog is
+//     dismissed (then `id` is the close-response) — Adw.AlertDialog::response. It
+//     arrives as a non-bubbling `response` DOM event whose `detail` is `[id]`.
+//   `notify::heading` / `notify::body` (CustomEvent, bubbles) mirroring the matching
+//     GObject properties; `notify::open` is the web-only `open` attribute's.
 //
 // The RESPONSE MODEL — the registry (id/label/appearance/enabled), the
 // default/close-response semantics and the resolve-to-chosen-id contract — is HEADLESS
@@ -57,8 +66,11 @@
 
 import { AdwAlertResponses } from '@gjsify/adwaita-core';
 import type { AdwResponseAppearance } from '@gjsify/adwaita-core';
+import { propertyOf } from '@gjsify/adwaita-core/tags';
 
+import { dispatchElement, installElementApi } from '../gobject-elements.js';
 import { renderPangoMarkup } from '../pango-markup.js';
+import type { DispatchedSignals } from '../signals.js';
 import { bindEmptySections } from '../empty-sections.js';
 import { bindSlottedChildren } from '../slotted-children.js';
 import { AdwModalSurface } from './modal-surface.js';
@@ -79,8 +91,55 @@ export class AdwAlertResponse extends HTMLElement {
     }
 }
 
+/** The `Adw.AlertDialog` construct properties, in GJS's snake_case or the camelCase GJS also takes. */
+export interface AdwAlertDialogProps {
+    heading?: string;
+    body?: string;
+    heading_use_markup?: boolean;
+    headingUseMarkup?: boolean;
+    body_use_markup?: boolean;
+    bodyUseMarkup?: boolean;
+    close_response?: string;
+    closeResponse?: string;
+    default_response?: string | null;
+    defaultResponse?: string | null;
+    prefer_wide_layout?: boolean;
+    preferWideLayout?: boolean;
+}
+
 export class AdwAlertDialog extends HTMLElement {
+    /** The GTK signals this element dispatches, each with the DOM event it arrives as (ADR 0093). */
+    static readonly signals: DispatchedSignals = {
+        response: 'response',
+        ...Object.fromEntries(
+            [
+                'heading',
+                'body',
+                'heading-use-markup',
+                'body-use-markup',
+                'close-response',
+                'default-response',
+                'prefer-wide-layout',
+            ].map((name) => [`notify::${name}`, `notify::${name}`]),
+        ),
+    };
+
+    /** `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`. */
+    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`. */
+    declare set_property: (name: string, value: unknown) => void;
+
     private _initialized = false;
+    /** Set when `present()` attached the dialog, so closing detaches it again. */
+    private _attachedByPresent = false;
     private _scrimEl!: HTMLDivElement;
     private _dialogEl!: HTMLDivElement;
     private _headingEl!: HTMLHeadingElement;
@@ -97,6 +156,22 @@ export class AdwAlertDialog extends HTMLElement {
     // also fire the close-response (AdwAlertDialog's `block_close_response`).
     private _blockCloseResponse = false;
 
+    /**
+     * `new Adw.AlertDialog({ heading, body, close_response, default_response })`, the GJS
+     * construct bag. Only the `new` form passes one: `document.createElement` and the
+     * parser call this with nothing, which is why writing attributes here is allowed.
+     */
+    constructor(props?: AdwAlertDialogProps) {
+        super();
+        installElementApi(this);
+        for (const [key, value] of Object.entries(props ?? {})) {
+            if (value === undefined) continue;
+            const member = propertyOf(key);
+            if (!(member in this)) throw new Error(`No property ${key} on <adw-alert-dialog>`);
+            (this as unknown as Record<string, unknown>)[member] = value;
+        }
+    }
+
     static get observedAttributes() {
         return [
             'heading',
@@ -171,7 +246,7 @@ export class AdwAlertDialog extends HTMLElement {
     }
 
     set defaultResponse(value: string | null) {
-        this.setDefaultResponse(value);
+        this.set_default_response(value);
     }
 
     /** The ID passed to `response` when the dialog is dismissed. */
@@ -180,7 +255,7 @@ export class AdwAlertDialog extends HTMLElement {
     }
 
     set closeResponse(value: string) {
-        this.setCloseResponse(value);
+        this.set_close_response(value);
     }
 
     connectedCallback() {
@@ -239,6 +314,7 @@ export class AdwAlertDialog extends HTMLElement {
                 claims: (node) => node instanceof Element && node.localName === 'adw-alert-response',
                 consume: (node) => this._adoptResponse(node as AdwAlertResponse),
             },
+            { name: 'extra-child', into: this._childEl },
             { into: this._childEl },
         ]).install(this._scrimEl, this._dialogEl);
 
@@ -261,7 +337,9 @@ export class AdwAlertDialog extends HTMLElement {
         // two live in the model and would simply be dropped.
         const closeResponse = this.getAttribute('close-response');
         if (closeResponse !== null) this._model.closeResponse = closeResponse;
-        this._model.defaultResponse = this.getAttribute('default-response');
+        // An absent attribute leaves a `default_response` the construct bag already set.
+        const defaultResponse = this.getAttribute('default-response');
+        if (defaultResponse !== null) this._model.defaultResponse = defaultResponse;
 
         this._render();
     }
@@ -275,11 +353,11 @@ export class AdwAlertDialog extends HTMLElement {
         const id = el.getAttribute('id');
         if (!id) return;
         const appearance = (el.getAttribute('appearance') ?? 'default') as AdwResponseAppearance;
-        this.addResponse(id, (el.textContent ?? '').trim());
-        if (appearance !== 'default') this.setResponseAppearance(id, appearance);
+        this.add_response(id, (el.textContent ?? '').trim());
+        if (appearance !== 'default') this.set_response_appearance(id, appearance);
         // `enabled` is a value-based boolean attribute (GTK property defaulting to TRUE).
         // Use the shared reader instead of a hand-rolled `=== 'false'` comparison.
-        if (!booleanAttribute(el.getAttribute('enabled'), true)) this.setResponseEnabled(id, false);
+        if (!booleanAttribute(el.getAttribute('enabled'), true)) this.set_response_enabled(id, false);
     }
 
     attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null) {
@@ -301,22 +379,38 @@ export class AdwAlertDialog extends HTMLElement {
             // header) — the attribute is a markup entry point that feeds it, so the
             // setter is not mirrored back and there is no reflection loop. An absent
             // attribute means "leave the model's default", not "reset to `close`".
-            if (newValue !== null) this.setCloseResponse(newValue);
+            if (newValue !== null) this.set_close_response(newValue);
         } else if (name === 'default-response') {
-            this.setDefaultResponse(newValue);
+            this.set_default_response(newValue);
         } else if (name === 'open') {
             this.dispatchEvent(new CustomEvent('notify::open', { bubbles: true, detail: { open: this.open } }));
-            if (this.open) this._modal.present();
-            else this._modal.dismiss();
+            if (this.open) {
+                this._modal.present();
+            } else {
+                this._modal.dismiss();
+                if (this._attachedByPresent) {
+                    this._attachedByPresent = false;
+                    this.remove();
+                }
+            }
         }
     }
 
-    /** Present the dialog. `parent` is accepted for API parity; unused. */
+    /**
+     * Present the dialog (`adw_dialog_present`). A detached dialog is attached to the document
+     * first and detached again when it closes; `parent` names the window it belongs to, and the
+     * page is that window's root here, so it does not change where the dialog goes.
+     */
     present(_parent?: unknown): void {
+        if (!this.isConnected) {
+            document.body.appendChild(this);
+            this._attachedByPresent = true;
+        }
         this.open = true;
     }
 
-    addResponse(id: string, label: string): void {
+    /** `adw_alert_dialog_add_response`: a duplicate id is refused, as libadwaita's g_critical does. */
+    add_response(id: string, label: string): void {
         // The core registry UPDATES a duplicate id in place; AdwAlertDialog refuses it,
         // so the guard stays here.
         if (this._model.hasResponse(id)) {
@@ -339,15 +433,14 @@ export class AdwAlertDialog extends HTMLElement {
         this._render();
     }
 
-    /** Adds multiple responses at once — id/label pairs (Adw.add_responses parity). */
-    addResponses(...idLabelPairs: string[]): void {
-        for (let i = 0; i + 1 < idLabelPairs.length; i += 2) {
-            this.addResponse(idLabelPairs[i], idLabelPairs[i + 1]);
+    /** `adw_alert_dialog_remove_response`. */
+    remove_response(id: string): void {
+        if (!this._model.hasResponse(id)) {
+            console.warn(
+                `[adw-alert-dialog] Trying to remove a response with id '${id}', but such a response does not exist`,
+            );
+            return;
         }
-    }
-
-    removeResponse(id: string): void {
-        if (!this._model.hasResponse(id)) return;
         this._buttons.get(id)?.remove();
         this._buttons.delete(id);
         // `AdwAlertResponses` exposes no removal (a gap against
@@ -367,15 +460,18 @@ export class AdwAlertDialog extends HTMLElement {
         this._render();
     }
 
-    hasResponse(id: string): boolean {
+    /** `adw_alert_dialog_has_response`. */
+    has_response(id: string): boolean {
         return this._model.hasResponse(id);
     }
 
-    getResponseLabel(id: string): string | null {
+    /** `adw_alert_dialog_get_response_label`; `null` for an unknown id, as the C returns NULL. */
+    get_response_label(id: string): string | null {
         return this._model.responses.find((response) => response.id === id)?.label ?? null;
     }
 
-    setResponseLabel(id: string, label: string): void {
+    /** `adw_alert_dialog_set_response_label`. */
+    set_response_label(id: string, label: string): void {
         const button = this._buttons.get(id);
         if (!button) return;
         // Re-adding a known id updates it in place (the core registry contract).
@@ -383,11 +479,13 @@ export class AdwAlertDialog extends HTMLElement {
         button.textContent = label;
     }
 
-    getResponseAppearance(id: string): AdwResponseAppearance | null {
+    /** `adw_alert_dialog_get_response_appearance`; `null` for an unknown id. */
+    get_response_appearance(id: string): AdwResponseAppearance | null {
         return this._model.hasResponse(id) ? this._model.getResponseAppearance(id) : null;
     }
 
-    setResponseAppearance(id: string, appearance: AdwResponseAppearance): void {
+    /** `adw_alert_dialog_set_response_appearance`. */
+    set_response_appearance(id: string, appearance: AdwResponseAppearance): void {
         const button = this._buttons.get(id);
         if (!button) return;
         this._model.setResponseAppearance(id, appearance);
@@ -395,31 +493,63 @@ export class AdwAlertDialog extends HTMLElement {
         button.classList.toggle('destructive-action', appearance === 'destructive');
     }
 
-    getResponseEnabled(id: string): boolean {
+    /** `adw_alert_dialog_get_response_enabled`; `false` for an unknown id, as the C returns FALSE. */
+    get_response_enabled(id: string): boolean {
         return this._model.hasResponse(id) ? this._model.getResponseEnabled(id) : false;
     }
 
-    /** Sets whether a response is enabled (disabled buttons can't be activated). */
-    setResponseEnabled(id: string, enabled: boolean): void {
+    /** `adw_alert_dialog_set_response_enabled`: a disabled button cannot be activated. */
+    set_response_enabled(id: string, enabled: boolean): void {
         const button = this._buttons.get(id);
         if (!button) return;
         this._model.setResponseEnabled(id, enabled);
         button.disabled = !enabled;
     }
 
-    /** Sets the default response — its button is highlighted as the suggested one. */
-    setDefaultResponse(id: string | null): void {
+    /** `adw_alert_dialog_get_default_response`. */
+    get_default_response(): string | null {
+        return this._model.defaultResponse;
+    }
+
+    /** `adw_alert_dialog_set_default_response`: its button is highlighted and takes the focus. */
+    set_default_response(id: string | null): void {
         this._model.defaultResponse = id;
         this._render();
     }
 
-    /** Sets the close response — emitted on dismissal (Escape / scrim click). */
-    setCloseResponse(id: string): void {
+    /** `adw_alert_dialog_get_close_response`. */
+    get_close_response(): string {
+        return this._model.closeResponse;
+    }
+
+    /** `adw_alert_dialog_set_close_response`: emitted on dismissal (Escape / scrim click). */
+    set_close_response(id: string): void {
         this._model.closeResponse = id;
     }
 
+    /** `adw_alert_dialog_get_heading`. */
+    get_heading(): string {
+        return this.heading;
+    }
+
+    /** `adw_alert_dialog_set_heading`. */
+    set_heading(heading: string): void {
+        this.heading = heading;
+    }
+
+    /** `adw_alert_dialog_get_body`. */
+    get_body(): string {
+        return this.body;
+    }
+
+    /** `adw_alert_dialog_set_body`. */
+    set_body(body: string): void {
+        this.body = body;
+    }
+
     private _activateResponse(id: string): void {
         if (!this._model.getResponseEnabled(id)) return;
+        // `emit_response`: block the close-response, close, then emit the chosen one.
         this._blockCloseResponse = true;
         this.open = false;
         this._blockCloseResponse = false;
@@ -438,7 +568,7 @@ export class AdwAlertDialog extends HTMLElement {
     }
 
     private _emitResponse(response: string): void {
-        this.dispatchEvent(new CustomEvent('response', { bubbles: true, detail: { response } }));
+        dispatchElement(this, 'response', [response]);
     }
 
     /**

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

@@ -45,7 +45,6 @@ import type { AdwBreakpoint } from '@gjsify/adwaita-core';
 import type { AdwSlot } from '../slotted-children.js';
 import { AdwWindowFeatures } from './adw-window-features.js';
 import { GtkApplicationWindow } from './gtk-application-window.js';
-import { defineWindowApplication } from '../application.js';
 
 export class AdwApplicationWindow extends GtkApplicationWindow {
     private readonly _features = new AdwWindowFeatures(this);
@@ -232,5 +231,3 @@ export class AdwApplicationWindow extends GtkApplicationWindow {
 }
 
 customElements.define('adw-application-window', AdwApplicationWindow);
-
-defineWindowApplication(AdwApplicationWindow.prototype);

package/src/elements/adw-breakpoint-bin.ts

@@ -67,6 +67,7 @@ import { BreakpointBinState } from '@gjsify/adwaita-core';
 import type { BreakpointSetter } from '@gjsify/adwaita-core';
 
 import { observeAdaptiveSize } from '../breakpoints.js';
+import { bindSlottedChildren } from '../slotted-children.js';
 
 /** One authored setter, as it reads in the `breakpoints` attribute. */
 interface AuthoredSetter {
@@ -157,6 +158,8 @@ export class AdwBreakpointBin extends HTMLElement {
     }
 
     connectedCallback() {
+        // The NAME only, for the reason `adw-bin.ts` gives: the child already IS the content.
+        bindSlottedChildren(this, [{ name: 'child', into: this }]);
         this.setAttribute('role', 'group');
         // A GTK widget is a box and an unknown custom element is `inline`, which measures
         // zero — and a bin measuring zero matches every condition forever. libadwaita

package/src/elements/adw-dialog.ts

@@ -196,7 +196,9 @@ export class AdwDialog extends HTMLElement {
         // Everything the author places inside is the dialog content — LIVE, because
         // `Adw.Dialog:child` is a property and a dialog whose body is filled in after it
         // was created is the ordinary case. `src/slotted-children.ts` has the incident.
-        bindSlottedChildren(this, [{ into: this._contentEl }]).install(this._scrimEl);
+        bindSlottedChildren(this, [{ name: 'child', into: this._contentEl }, { into: this._contentEl }]).install(
+            this._scrimEl,
+        );
 
         this._render();
     }

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

@@ -119,6 +119,10 @@ export class AdwHeaderBar extends HTMLElement {
                 // gallery's own fences are written in.
                 { name: 'title-widget', into: this._centerEl },
                 { name: 'end', into: this._endEl },
+                // An untyped `<child>` packs from the start (adw-header-bar.c:1040-1041). A
+                // Blueprint `[start]` tags only the NEXT child, so every button after it
+                // arrives untyped and had no destination at all.
+                { into: this._startEl },
             ],
             (_node, slot) => {
                 if ('into' in slot && slot.into === this._centerEl) this._dropDerivedTitle();