@gjsify/adwaita-web 0.53.0 → 0.55.0

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

@@ -0,0 +1,199 @@
+import { type AdwMenuInput, type AdwMenuModel } from '@gjsify/adwaita-core';
+import type { AdwTabView } from './adw-tab-view.js';
+export declare class AdwTabOverview extends HTMLElement {
+    private _childEl;
+    private _overviewEl;
+    private _headerEl;
+    private _startButtonsEl;
+    private _endButtonsEl;
+    private _titleEl;
+    private _searchBtn;
+    private _searchEntry;
+    private _searchClamp;
+    private _searchBar;
+    private _menuBtn;
+    private _gridEl;
+    private _pinnedGridEl;
+    private _emptyState;
+    private _searchEmptyState;
+    private _newTabBtn;
+    private readonly _thumbs;
+    private _view;
+    private _model;
+    private _searchActive;
+    private _initialized;
+    /** The last visibility actually painted, so `notify::open` fires on a real change. */
+    private _appliedOpen;
+    /** Guards the `open` attribute we write ourselves from re-entering `setOpen`. */
+    private _reflecting;
+    static get observedAttributes(): string[];
+    /** `Adw.TabOverview:view` — the tab view the overview controls. */
+    get view(): AdwTabView | null;
+    set view(value: AdwTabView | string | null);
+    /**
+     * `adw_tab_overview_set_view`: rebind the view's five signals, then repopulate.
+     * The view must be INSIDE the overview (adw-tab-overview.c:1090-1093 refuses
+     * otherwise), which the element enforces by looking the view up among its own
+     * children when the reference is not a live element.
+     */
+    setView(view: AdwTabView | null): void;
+    /**
+     * `Adw.TabOverview:child` — the widget the overview covers. Declared children are
+     * it: there is one slot in the template and it holds whatever the author wrote.
+     */
+    get child(): HTMLElement | null;
+    /** `Adw.TabOverview:open` — whether the overview is showing. */
+    get open(): boolean;
+    set open(value: boolean);
+    /**
+     * Whether the thumbnails use the INVERTED layout: the close/unpin button at the
+     * START and the indicator at the END, rather than the other way round
+     * (adw-tab-overview.c:1626-1634).
+     */
+    get inverted(): boolean;
+    set inverted(value: boolean);
+    /**
+     * `Adw.TabOverview:enable-search`, TRUE upstream — and so `="false"` is the off
+     * switch, absent meaning on. The same MODIFICATION `<adw-carousel>` makes for
+     * `allow-scroll-wheel`: an HTML boolean attribute can only mean TRUE.
+     */
+    get enableSearch(): boolean;
+    set enableSearch(value: boolean);
+    /** `Adw.TabOverview:search-active` — read-only upstream, and read-only here. */
+    get searchActive(): boolean;
+    /** `Adw.TabOverview:enable-new-tab`. */
+    get enableNewTab(): boolean;
+    set enableNewTab(value: boolean);
+    /** `Adw.TabOverview:secondary-menu` — the portal menu of extra actions. */
+    get secondaryMenu(): AdwMenuModel;
+    set secondaryMenu(value: AdwMenuInput);
+    /** `Adw.TabOverview:show-start-title-buttons`, TRUE upstream, so `="false"` turns it off. */
+    get showStartTitleButtons(): boolean;
+    set showStartTitleButtons(value: boolean);
+    /** `Adw.TabOverview:show-end-title-buttons`, TRUE upstream, so `="false"` turns it off. */
+    get showEndTitleButtons(): boolean;
+    set showEndTitleButtons(value: boolean);
+    /**
+     * `Adw.TabOverview:extra-drag-preload`. Stored and reported; it gates the GDK drag
+     * protocol this port does not have (see the header).
+     */
+    get extraDragPreload(): boolean;
+    set extraDragPreload(value: boolean);
+    /** `Adw.TabOverview:extra-drag-preferred-action` — always 0 here, for the same reason. */
+    get extraDragPreferredAction(): number;
+    /**
+     * The `overview.open` action (`overview_open_cb`, adw-tab-overview.c:1517-1521),
+     * with `update_actions`' enabled rule: closed AND holding a view (:816-826).
+     */
+    activateOverviewOpen(): boolean;
+    /**
+     * The `overview.close` action (`overview_close_cb`, :1523-1527): open, holding a
+     * view, and holding at least one page — an empty overview has nothing to close to.
+     */
+    activateOverviewClose(): boolean;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    private _resolveView;
+    /** The `AdwTabView` among our own children — the only place the C allows one. */
+    private _findView;
+    /**
+     * `set_view`'s five connections (adw-tab-overview.c:1140-1209), read off the view's
+     * own events: the page list's attach/detach/reorder, each page's `pinned` change,
+     * the selection, and the page COUNT (which the title and the actions are derived
+     * from). The pinned page change arrives as `page-updated` / `page-pinned`.
+     */
+    private _bindView;
+    private _unbindView;
+    private _onViewChange;
+    private _syncAll;
+    /**
+     * `notify_n_pages_cb`: `dngettext ("%u Tab", "%u Tabs", n_pages)` — the count is
+     * the number of pages, and the singular is only for exactly one. No view means an
+     * EMPTY title, which is the C's own branch before the format string (:955-958).
+     */
+    private _applyTitle;
+    /**
+     * The two grids, split the way `populate_sidebar`-shaped code splits them: pinned
+     * pages in `pinned_grid` in view order, the rest in `grid`, each filtered by the
+     * current search terms. Thumbnails are edited in place; a page that left either
+     * grid loses its node.
+     */
+    private _syncGrids;
+    /**
+     * `empty_changed_cb`: EMPTY is BOTH grids empty, and which of the two status pages
+     * shows is the search — `empty_state` when it is off, `search_empty_state` when on.
+     */
+    private _applyEmptyStates;
+    /** `update_new_tab_button`: the button hides while the search is running. */
+    private _applyNewTabButton;
+    /**
+     * `update_header_bar`: the bar shows when search is on, or a secondary menu is set,
+     * or either side wants its title buttons. The two sides are drawn as the slots C
+     * puts the window buttons in — this renderer has no window chrome to move, so the
+     * slot is where an application puts its own controls.
+     */
+    private _applyHeaderBar;
+    private _applyMenu;
+    /** `set_open` + `set_overview_visible` (:916-939): one visibility, two surfaces. */
+    private _applyOpen;
+    /** `adw_tab_overview_set_open`, the setter the actions and the grid both call. */
+    setOpen(open: boolean): void;
+    private _searchMode;
+    /** The template's `search-mode-enabled` binding: the search BUTTON's own state. */
+    private _toggleSearchMode;
+    /**
+     * `search_changed_cb`: the terms go to BOTH grids and `search-active` is just
+     * "the entry is non-empty" — there is no separate mode to keep in step, which is why
+     * `stop_search_cb` has to clear the entry itself before reporting FALSE.
+     */
+    private _onSearchChanged;
+    private _stopSearch;
+    /** `set_search_active` (:838-852): assign, re-derive, and notify only on a change. */
+    private _setSearchActive;
+    /**
+     * `search_activated_cb` (:884-893): Enter in the entry moves into the grid, and it
+     * is the PINNED grid first, because it sits above `grid` in the scrolled window.
+     */
+    private _onSearchKeyDown;
+    /**
+     * `adw_tab_overview_focus` (:1343-1405), the parts the DOM can honour: the search
+     * button and the entry go DOWN into the first row, the secondary-menu button goes
+     * down to the LAST row, and the new-tab button goes UP to the last row of `grid`
+     * first. GTK's focus is a widget returning TRUE for a direction; a browser moves the
+     * focus itself, so this only names the destination.
+     */
+    private _onKeyDown;
+    /**
+     * The thumbnail grids are `GtkGridView`s: arrows move a cursor in two dimensions over
+     * a column count the layout decides (the grid reflows), Home/End jump, and nothing
+     * wraps. Selection follows focus; Enter and Space activate like a click, because a
+     * thumbnail is a `div` with no activation of its own. A move that would leave the
+     * grid is not claimed for Up/Down, so `_onKeyDown` can still hand focus to the
+     * new-tab button.
+     */
+    private _onGridKey;
+    private _focusFirstRow;
+    private _focusLastRow;
+    /**
+     * `create_tab` (:895-909) and `new_tab_clicked_cb` (:911-926).
+     *
+     * `create-tab`'s handler RETURNS a page, which a DOM event cannot do: `detail.page`
+     * is the return slot, and a listener fills it (usually by appending to the view).
+     * Nothing filled is C's `g_critical ("AdwTabOverview::create-tab handler must not
+     * return NULL")`, reported on `console.error` because the click cannot be abandoned.
+     */
+    private _requestCreateTab;
+    private _createGrid;
+    /**
+     * adw-tab-thumbnail.ui, node for node: the `.thumbnail` overlay over a `.card`
+     * overlay holding the PICTURE, the close button, the unpin icon and the indicator
+     * button, with the attention dot over that and the icon/title box underneath.
+     */
+    private _thumbFor;
+    /**
+     * `update_tooltip`, `update_icon`, `update_indicator`, `update_loading` and the
+     * needs-attention revealer, in that order (adw-tab-thumbnail.c:82-152).
+     */
+    private _refreshThumb;
+}

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

@@ -19,6 +19,8 @@ export declare class AdwTabView extends HTMLElement {
     private readonly _pagesEl;
     /** Tab chips keyed by page id — the bar is edited in place, never rebuilt. */
     private readonly _tabs;
+    /** The same chips as {@link _tabs}, held as the shared builder's parts for a refresh. */
+    private readonly _chips;
     /** Page panels keyed by page id; kept so a DETACHED page's node is still reachable. */
     private readonly _panels;
     private readonly _hovered;
@@ -103,7 +105,16 @@ export declare class AdwTabView extends HTMLElement {
     reorderLast(id: string): boolean;
     setPageTitle(id: string, title: string | null): boolean;
     setPageTooltip(id: string, tooltip: string | null): boolean;
+    /**
+     * Set a page's search keyword (`AdwTabPage:keyword`) — the string the tab overview's
+     * search matches on beside the title and the tooltip ("Use keywords to search in
+     * e.g. page URLs in a web browser", adw-tab-overview.c:1646-1648).
+     */
+    setPageKeyword(id: string, keyword: string | null): boolean;
+    /** Set a page's icon name (`adw_tab_page_set_icon`). */
     setPageIcon(id: string, icon: string | null): boolean;
+    /** Set a page's indicator icon (`adw_tab_page_set_indicator_icon`). */
+    setPageIndicatorIcon(id: string, indicatorIcon: string | null): boolean;
     setPageLoading(id: string, loading: boolean): boolean;
     setPageNeedsAttention(id: string, needsAttention: boolean): boolean;
     /** Every precondition the model refused, as C would have warned about it. */
@@ -117,35 +128,20 @@ export declare class AdwTabView extends HTMLElement {
     private _moveTab;
     private _refreshTab;
     /**
-     * `get_tab_position` in the BAR's scroll space: how far the chip sits from the
-     * strip's scroll origin, the one coordinate both `scroll_to_tab_full` and
-     * `update_visible` compare against the adjustment.
-     *
-     * Never `offsetLeft`. Nothing in this widget is positioned, so a chip's offsetParent
-     * is whichever positioned ancestor the HOST page happens to have; a tab view that
-     * merely sits indented then measured every chip against the wrong origin and
-     * reported all of them clipped.
-     */
-    private _tabPosition;
-    /**
-     * `tabCloseVisible`, with its pinned gate. `dragging` is constantly false — tab
-     * drag-and-drop is compositor work and is not modelled — and `fullyVisible` is
-     * measured against the bar's scroll window, which is what the C term means for a
-     * horizontally scrolled bar.
+     * The close affordance's visibility, and both halves of it now live in `../tab-chip.js`
+     * — `tabCloseVisible` and the geometry it is measured with, in the BAR's own scroll
+     * space. The incident that moved them there is recorded beside `chipPosition`: the
+     * measurement once used `offsetLeft`, which is relative to whichever positioned ancestor
+     * the HOST page happens to have, so a tab view that merely sat indented reported every
+     * chip clipped and swallowed the close button on hover.
      */
     private _refreshCloseVisibility;
     private _onSelectionChange;
     private _applyActiveState;
     /**
      * `scroll_to_tab_full` (adw-tab-box.c:928-961), called on every selection the way
-     * `select_page` calls it (:1728): bring the selected chip inside the BAR's own
-     * scroll window, padded by half of whichever is smaller, the chip or the leftover.
-     *
-     * The bar is the only thing C ever scrolls for a tab: `scroll_to_tab_full` writes
-     * `self->adjustment`, the strip's own adjustment, and nothing else. The DOM has no
-     * such narrow API: `focus()` and `scrollIntoView()` both walk EVERY scrollable
-     * ancestor up to the window. So this moves `scrollLeft` by hand, and the focus call
-     * below passes `preventScroll`.
+     * `select_page` calls it (:1728) — `scrollChipIntoBar` in `../tab-chip.js`, with the
+     * reasoning and the SPACING slack that is deliberately not transplanted.
      */
     private _scrollSelectedTabIntoBar;
     private _applyBarVisibility;

package/lib/types/elements/adw-view-switcher-sidebar.d.ts

@@ -0,0 +1,84 @@
+import type { SidebarItemFilter } from '@gjsify/adwaita-core';
+import type { AdwViewStack } from './adw-view-stack.js';
+export declare class AdwViewSwitcherSidebar extends HTMLElement {
+    private _sidebar;
+    private _placeholderEl;
+    private _prefixEl;
+    private _suffixEl;
+    private _stack;
+    private _filter;
+    private _initialized;
+    static get observedAttributes(): string[];
+    /** `AdwViewSwitcherSidebar:stack` — the stack the sidebar controls. */
+    get stack(): AdwViewStack | null;
+    set stack(value: AdwViewStack | string | null);
+    /**
+     * `adw_view_switcher_sidebar_set_stack`: unbind the old stack's four connections, bind
+     * the new one's, and populate. A NULL stack is refused, exactly as C is
+     * (`g_return_if_fail (!stack)`, :284) — an overview-less sidebar is not a state the C
+     * has, and inventing one here would give a reader a widget libadwaita cannot build.
+     */
+    setStack(stack: AdwViewStack | null): void;
+    /** `AdwViewSwitcherSidebar:mode` — `sidebar` (default) or `page`. */
+    get mode(): 'sidebar' | 'page';
+    set mode(value: 'sidebar' | 'page');
+    /**
+     * `AdwViewSwitcherSidebar:filter` — a `GtkFilter`, which on this renderer is the
+     * sidebar's own predicate. A property and not an attribute: it is a FUNCTION, and
+     * markup cannot carry one.
+     */
+    get filter(): SidebarItemFilter | null;
+    set filter(value: SidebarItemFilter | null);
+    /** `AdwViewSwitcherSidebar:placeholder` — shown when no item survives. */
+    get placeholder(): HTMLElement | null;
+    set placeholder(value: HTMLElement | null);
+    /**
+     * `AdwViewSwitcherSidebar:prefix` (1.10) — shown above the items.
+     *
+     * NOT `prefix`. `HTMLElement.prefix` is the RDFa attribute and a STRING, and a
+     * property of a different type cannot shadow it (TS2416). The GIR name is kept in the
+     * SLOT (`slot="prefix"`, what a `.blp`'s `prefix: …` authors) and here in the header.
+     */
+    get prefixWidget(): HTMLElement | null;
+    set prefixWidget(value: HTMLElement | null);
+    /** `AdwViewSwitcherSidebar:suffix` (1.10) — shown below the items. `suffixWidget`, as `prefixWidget`. */
+    get suffixWidget(): HTMLElement | null;
+    set suffixWidget(value: HTMLElement | null);
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    private _resolveStack;
+    /** The stack this sidebar is next to, when the author named no id. */
+    private _findStack;
+    /** `set_stack`'s four connections (:270-282), read off the stack's own events. */
+    private _bindStack;
+    private _unbindStack;
+    private _onStackChange;
+    /**
+     * `activated_cb` (:104-112) — the row's index is the stack's index, so the two lists
+     * are kept one for one. The selection moves FIRST: `activated` is the signal a split
+     * view reveals its content pane on, and a handler that read the stack in that callback
+     * would otherwise see the page the user was leaving.
+     */
+    private _onSidebarActivated;
+    /**
+     * `populate_sidebar` (:225-249) — one `AdwSidebarSection` per group of pages, each
+     * holding one `AdwSidebarItem` per page. The grouping is core's, so the browser and
+     * any second renderer derive the sections from the same table.
+     */
+    private _populate;
+    private _toSectionSpec;
+    /**
+     * `selection_changed_cb` (:258-271) — the row follows the stack's visible page. Read as
+     * the INDEX, because the sidebar's flat index space is the unfiltered one (ADR 0004),
+     * so page position and row position are the same number.
+     */
+    private _syncSelection;
+    private _applyMode;
+    /**
+     * `placeholder` (:449-460) — shown when the sidebar has no items, or when the filter
+     * took them all. The `<adw-sidebar>` knows the filtered list (`visibleItems` is empty),
+     * which is the C condition in `AdwSidebar`'s own words.
+     */
+    private _applyEmptyState;
+}

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

@@ -1,3 +1,43 @@
+import { AdwBreakpoint } from '@gjsify/adwaita-core';
 export declare class AdwWindow extends HTMLElement {
+    private _initialized;
+    private _contentEl;
+    private _breakpoints;
+    private _disposeBreakpoints;
+    private _openDialogs;
+    static get observedAttributes(): string[];
+    /** The content area — the Adw.Window:content property. */
+    get contentArea(): HTMLDivElement;
+    /** The content widget — the first child of the content area. */
+    get content(): HTMLElement | null;
+    set content(value: HTMLElement | null);
+    /** The breakpoints added to this window. */
+    get breakpoints(): readonly AdwBreakpoint[];
+    /** The currently applied breakpoint, or null when none is. */
+    get currentBreakpoint(): AdwBreakpoint | null;
+    /** The open dialogs presented inside this window (Adw.Window:dialogs). */
+    get dialogs(): readonly HTMLElement[];
+    /** The currently visible dialog, or null when none is (Adw.Window:visible-dialog). */
+    get visibleDialog(): HTMLElement | null;
+    /**
+     * Add a breakpoint to this window (adw_window_add_breakpoint).
+     * The breakpoint evaluates against the window's own box and sets a
+     * `data-breakpoint` attribute when applied.
+     */
+    addBreakpoint(condition: string): AdwBreakpoint;
     connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string): void;
+    private _buildOnce;
+    /**
+     * Bind the breakpoints to THIS box.
+     *
+     * NOT once per lifetime: `disconnectedCallback` releases the disposer, so a
+     * window moved between parents would come back deaf — and a window is exactly
+     * the thing a client-side route change re-parents. Re-binding is cheap and
+     * idempotent, and it re-measures the new box on the way.
+     */
+    private _bindBreakpoints;
+    /** The window's size request — GTK's, not CSS's, so an absent attribute means the default. */
+    private _applySizeRequest;
 }

package/lib/types/elements/gtk-about-dialog.d.ts

@@ -0,0 +1,146 @@
+import { AdwDialog } from './adw-dialog.js';
+/**
+ * GTK's licence preamble (`gtk_about_dialog_set_license_type`, :2301) — NOT
+ * libadwaita's `ADW_LICENSE_WARRANTY_TEMPLATE`, which says "This application" and has no
+ * newline. Both strings are translatable and they are not translations of each other.
+ * The C template is `'This program comes with absolutely no warranty.\nSee the
+ * <a href="%s">%s</a> for details.'`; `_licenseMarkup` composes the same three runs —
+ * text, link, text — as DOM, because the scan it uses for plain licence text would read
+ * the `<a href>` as an email address.
+ */
+export declare class GtkAboutDialog extends AdwDialog {
+    private _built;
+    private _logo;
+    private _switcherEl;
+    private _stackEl;
+    private _pages;
+    private _populated;
+    private _authors;
+    private _documenters;
+    private _artists;
+    private _creditSections;
+    static get observedAttributes(): string[];
+    /** The program name; unset falls back to the document's own title (`g_get_application_name`). */
+    get programName(): string;
+    set programName(value: string);
+    get version(): string;
+    set version(value: string);
+    get copyright(): string;
+    set copyright(value: string);
+    get comments(): string;
+    set comments(value: string);
+    get license(): string;
+    set license(value: string);
+    /** The `GtkLicense` nick — `unknown`, `custom`, `mit-x11`, … */
+    get licenseType(): string;
+    set licenseType(value: string);
+    get systemInformation(): string;
+    set systemInformation(value: string);
+    get website(): string;
+    set website(value: string);
+    get websiteLabel(): string;
+    set websiteLabel(value: string);
+    get translatorCredits(): string;
+    set translatorCredits(value: string);
+    /** The named-icon logo; overrides {@link logo}, as in the C. */
+    get logoIconName(): string;
+    set logoIconName(value: string);
+    /** Whether the License page's text view WRAPS (`populate_license_page`, :2157). */
+    get wrapLicense(): boolean;
+    set wrapLicense(value: boolean);
+    /**
+     * A logo URL, drawn as an `<img>`.
+     *
+     * `GtkAboutDialog:logo` is a `GdkPaintable`, which is the one GObject property here
+     * an attribute could have carried and cannot: there is no paintable in a document.
+     * A URL is the honest browser stand-in and the override order is the C's.
+     */
+    get logo(): string;
+    set logo(value: string);
+    /** The people whose names the Credits page shows — `GtkAboutDialog:authors`. */
+    get authors(): string[];
+    set authors(value: readonly string[]);
+    get documenters(): string[];
+    set documenters(value: readonly string[]);
+    get artists(): string[];
+    set artists(value: readonly string[]);
+    /** `gtk_about_dialog_add_credit_section` — an extra titled group on the Credits page. */
+    addCreditSection(name: string, people: readonly string[]): void;
+    private _creditsChanged;
+    connectedCallback(): void;
+    attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
+    /**
+     * The headerbar carries the stack switcher and nothing else, exactly as
+     * `gtkaboutdialog.ui` declares it (`title-widget` → the switcher, no title).
+     */
+    protected decorateHeader(header: HTMLElement): void;
+    /** Which stack page is showing — `gtk_stack_get_visible_child_name`. */
+    get visiblePage(): string;
+    /**
+     * Show a page of the stack — `gtk_stack_set_visible_child_name`. The switcher buttons
+     * call it, and it is the one way the stack's lazy population (`stack_visible_child_notify`)
+     * runs: a page is built the first time it is shown, not before.
+     */
+    showPage(name: string): void;
+    private _build;
+    private _renderAbout;
+    /** The three visibility rules, one predicate each, as in the C. */
+    private _pageVisible;
+    /** `add_credits_section`'s input, in `populate_credits_page`'s order. */
+    private _creditsPeople;
+    /** Whether the stack switcher has anything to show (`update_stack_switcher_visibility`). */
+    private _visiblePages;
+    private _renderSwitcher;
+    private _renderLogo;
+    /** The main page: version, comments, website, copyright, licence — in `.ui` order. */
+    private _renderMain;
+    /**
+     * The licence label: the text `license` holds, with its `<…>` and bare-URL links
+     * turned into spans — or, for a known type, the warranty preamble `set_license_type`
+     * composes. The preamble keeps its `<a href>` markup and is read with
+     * `gtk_label_set_markup` (:2354), a REAL link: it never goes through the
+     * `text_buffer_new` scan below, which would read `<a href="…">` as an email
+     * address. Same split here.
+     */
+    private _licenseMarkup;
+    /** The License page — a text view whose wrap mode is `wrap-license`. */
+    private _populateLicense;
+    /** The System page — a text view with no wrap mode of its own. */
+    private _populateSystem;
+    /** The Credits page — the scrolled, framed grid `populate_credits_page` fills. */
+    private _populateCredits;
+    /**
+     * `stack_visible_child_notify` (:297-333): each of the three pages is built the first
+     * time the stack SHOWS it, and never rebuilt after. A credits grid for three hundred
+     * authors is not work a dialog nobody opened it for.
+     */
+    private _populatePage;
+    /** The framed scrolled window the three extra pages sit in (`has-frame`). */
+    private _frame;
+    private _link;
+    /**
+     * `text_buffer_new` (:1903-2028 of `gtkaboutdialog.c`) for the plain-DOM case: split
+     * the string into literal runs and links. A `<…>` run is an email when it carries no
+     * scheme and a URL when it does; a bare `http://` or `https://` run ends at the first
+     * of space, newline, tab or `>`, which is `strpbrk (r1, " \n\t>")`.
+     */
+    private _fillWithLinks;
+    /**
+     * `emit_activate_link` (:646-655): the `BOOLEAN__STRING` accumulator. A handler that
+     * returns TRUE says it took over, which is `preventDefault()` here — and only then
+     * does the default `Gtk.UriLauncher` navigation not happen.
+     */
+    private _activateLink;
+}
+/** One run of `text_buffer_new`'s output: literal text, or a link with its URI. */
+interface LinkPart {
+    readonly text: string;
+    readonly uri: string | null;
+}
+/**
+ * `text_buffer_new`'s scan, in order: the first `<` and the first `>` after it, the
+ * earliest bare `http://` or `https://` and where it ends, and the C's own precedence —
+ * a URL that starts AT or just after the `<` wins, which leaves the bracket in the text.
+ */
+export declare function splitLinks(text: string): LinkPart[];
+export {};

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

@@ -0,0 +1,34 @@
+import type { AdwSlot } from '../slotted-children.js';
+import { GtkWindow } from './gtk-window.js';
+export declare class GtkApplicationWindow extends GtkWindow {
+    private _menubar;
+    private _menubarObserver;
+    static get observedAttributes(): string[];
+    /** `Gtk.ApplicationWindow:show-menubar` — whether the window shows a menubar of its own. */
+    get showMenubar(): boolean;
+    set showMenubar(value: boolean);
+    /**
+     * The menubar strip, created once and reused: `strips()` and `extraSlots()` both ask for
+     * it, so whichever runs first builds it and the other finds it.
+     */
+    private menubarSection;
+    /**
+     * Titlebar, then menubar, then content — the order `update_menubar` parents the bar at
+     * (:418) inside a window whose titlebar sits above its own child.
+     */
+    protected strips(): Node[];
+    /** The `menubar` slot, which is where a `GtkPopoverMenuBar` goes. */
+    protected extraSlots(): AdwSlot[];
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string): void;
+    /**
+     * `update_menubar`'s visibility rule (gtkapplicationwindow.c:400-402), BOTH halves: the
+     * property AND at least one item in the section. This element has no `GMenuModel` to ask,
+     * so the second half is the SLOT — an empty `menubar` slot is an empty `menubar_section`.
+     * The observer is what makes the second half live: `bindSlottedChildren` adopts a
+     * `slot="menubar"` child after connect, and a bar that appeared then must appear.
+     */
+    private _followMenubar;
+    private _renderMenubar;
+}

package/lib/types/elements/gtk-aspect-frame.d.ts

@@ -0,0 +1,27 @@
+export declare class GtkAspectFrame extends HTMLElement {
+    static get observedAttributes(): string[];
+    /** `Gtk.AspectFrame:ratio` — the width/height of the child. Ignored under `obey-child`. */
+    get ratio(): number;
+    set ratio(value: number);
+    /** `Gtk.AspectFrame:xalign` — where the child sits horizontally. `0.5` is the centre. */
+    get xalign(): number;
+    set xalign(value: number);
+    /** `Gtk.AspectFrame:yalign` — where the child sits vertically. `0.5` is the centre. */
+    get yalign(): number;
+    set yalign(value: number);
+    /**
+     * `Gtk.AspectFrame:obey-child` — TRUE (the pspec default, and therefore the ABSENCE of
+     * the attribute) takes the ratio from the child and ignores `ratio`. Spelled as
+     * `obey-child="false"` rather than as an inverted attribute, because the default is the
+     * affirmative one and every other boolean on every other element here means "present".
+     */
+    get obeyChild(): boolean;
+    set obeyChild(value: boolean);
+    /** `Gtk.AspectFrame:child` — the single widget the frame shapes. */
+    get child(): HTMLElement | null;
+    set child(value: HTMLElement | null);
+    connectedCallback(): void;
+    attributeChangedCallback(name: string, old: string | null, value: string | null): void;
+    private _normalized;
+    private _sync;
+}

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

@@ -1,4 +1,7 @@
+import type { DispatchedSignals } from '../signals.js';
 export declare class GtkButton extends HTMLElement {
+    /** The GTK signals this element dispatches, each with the DOM event it arrives as (ADR 0093). */
+    static readonly signals: DispatchedSignals;
     private _button;
     private _label;
     private _initialized;
@@ -10,4 +13,10 @@ export declare class GtkButton extends HTMLElement {
     connectedCallback(): void;
     attributeChangedCallback(): void;
     private _render;
+    /**
+     * Last step of every render, after the class and the content are written. A subclass
+     * adds its own state to the inner button here, because `_render` resets `className` and
+     * anything set earlier would be gone with it.
+     */
+    protected decorate(_button: HTMLButtonElement): void;
 }