@gjsify/adwaita-core 0.64.12 → 0.64.13-next.283

package/lib/types/action-row.d.ts

@@ -65,7 +65,11 @@ export declare class ActionRowState<TWidget = unknown> {
     setTitle(title: string | null | undefined): boolean;
     /** `AdwActionRow:subtitle`. */
     get subtitle(): string;
-    /** Set the subtitle. Returns whether it changed (the `notify::subtitle` gate). */
+    /**
+     * Set the subtitle. Returns whether the write notifies (the `notify::subtitle` gate) —
+     * which is NOT whether the text moved: a `null` write notifies every time
+     * ({@link adwSubtitleWriteNotifies}).
+     */
     setSubtitle(subtitle: string | null | undefined): boolean;
     /** `AdwActionRow:activatable-widget` — `null` when unset. */
     get activatableWidget(): TWidget | null;

package/lib/types/conformance/action-row.d.ts

@@ -164,3 +164,31 @@ export interface WindowTitleVector {
  * the reasoning for why the port normalises before comparing.
  */
 export declare const WINDOW_TITLE_VECTORS: ReadonlyArray<WindowTitleVector>;
+/** One `subtitle` write and whether it notifies. */
+export interface ActionRowSubtitleStep {
+    /** What the caller passed: `null` is a distinct write from `''`. */
+    write: string | null;
+    /** Whether `notify::subtitle` is emitted for this write. */
+    notified: boolean;
+    /** `get_subtitle()` afterwards — never `null`. */
+    subtitle: string;
+}
+/** A scripted sequence of subtitle writes applied to a FRESH `Adw.ActionRow` / `Adw.ExpanderRow`. */
+export interface ActionRowSubtitleVector {
+    name: string;
+    steps: readonly ActionRowSubtitleStep[];
+    rule: string;
+}
+/**
+ * `adw_action_row_set_subtitle` (adw-action-row.c:562-577), which `Adw.ExpanderRow` inherits.
+ *
+ * The guard is `g_strcmp0 (gtk_label_get_text (priv->subtitle), subtitle) == 0`. The label's
+ * text is never `NULL` and `g_strcmp0` never calls `NULL` equal to a string, so a `NULL` write
+ * passes the guard EVERY time, rewrites `""` over `""` and notifies. An empty string against
+ * the empty label is the ordinary idempotent case.
+ *
+ * Every row is a runtime measurement on GJS 1.88.1 / libadwaita 1.9.4 / GTK 4.22.5, on both
+ * `Adw.ActionRow` and `Adw.ExpanderRow`. `title` was measured on the same rows and does NOT
+ * behave this way, so these vectors are about the subtitle alone.
+ */
+export declare const ACTION_ROW_SUBTITLE_VECTORS: ReadonlyArray<ActionRowSubtitleVector>;

package/lib/types/conformance/expander-row.d.ts

@@ -0,0 +1,40 @@
+/** The properties an `Adw.ExpanderRow` write can notify. */
+export type ExpanderRowProperty = 'expanded' | 'enable-expansion';
+/** One write in an {@link ExpanderRowVector} sequence, with its outcome. */
+export interface ExpanderRowStep {
+    /** The property written. */
+    op: ExpanderRowProperty;
+    value: boolean;
+    /** The `notify::*` properties this one write emits, in emission order. */
+    notified: readonly ExpanderRowProperty[];
+    /** `get_expanded()` afterwards. */
+    expanded: boolean;
+    /** `get_enable_expansion()` afterwards. */
+    enableExpansion: boolean;
+    rule: string;
+}
+/** A scripted sequence of writes applied to a FRESH row (`expanded=false`, `enable-expansion=true`). */
+export interface ExpanderRowVector {
+    name: string;
+    steps: readonly ExpanderRowStep[];
+}
+/** The row `adw_expander_row_init` builds: collapsed, expansion enabled. */
+export declare const EXPANDER_ROW_INITIAL: {
+    readonly expanded: false;
+    readonly enableExpansion: true;
+};
+export declare const EXPANDER_ROW_VECTORS: ReadonlyArray<ExpanderRowVector>;
+/**
+ * What a row built with BOTH properties at once ends up holding — construct properties, an XML
+ * attribute pair, a `new Adw.ExpanderRow({…})`. Measured in BOTH key orders on GJS: neither
+ * order lets a disabled row open. A leg applies `enableExpansion` first and `expanded` second,
+ * and the reverse where it can spell it, and expects the same answer.
+ */
+export interface ExpanderRowConstructVector {
+    expanded: boolean;
+    enableExpansion: boolean;
+    /** `get_expanded()` afterwards. */
+    resultExpanded: boolean;
+    rule: string;
+}
+export declare const EXPANDER_ROW_CONSTRUCT_VECTORS: ReadonlyArray<ExpanderRowConstructVector>;

package/lib/types/conformance/index.d.ts

@@ -2,8 +2,8 @@ export { ABOUT_DIALOG_CREDITS_LEGAL_VECTORS, ABOUT_DIALOG_DETAILS_VECTORS, ABOUT
 export type { AboutDialogCreditsLegalVector, AboutDialogDetailsVector, AboutDialogHeaderVector, AboutDialogLabelVector, AboutDialogSupportVector, AcknowledgementSectionsVector, CreditPersonVector, CreditsSectionsVector, LegalSectionVector, LegalSectionsVector, LicenseInfoVector, LicenseSetterStep, LicenseSetterVector, LicenseSpdxVector, LicenseTextVector, TranslatorCreditsVector, } from './about-dialog.js';
 export { AVATAR_COLOR_VECTORS, AVATAR_FONT_SIZE_VECTORS, AVATAR_ICON_SIZE_VECTORS, AVATAR_INITIALS_VECTORS, AVATAR_MODE_VECTORS, } from './avatar.js';
 export type { AvatarColorVector, AvatarFontSizeVector, AvatarIconSizeVector, AvatarInitialsVector, AvatarModeVector, } from './avatar.js';
-export { ACTION_ROW_ACTIVATION_VECTORS, BUTTON_ROW_ACTIVATABLE_VECTORS, BUTTON_ROW_ICON_VECTORS, LABEL_VISIBILITY_VECTORS, SWITCH_ROW_NOTIFY_VECTORS, WINDOW_TITLE_VECTORS, } from './action-row.js';
-export type { ActionRowActivationVector, ActionRowStep, ButtonRowActivatableVector, ButtonRowIconVector, LabelVisibilityVector, SwitchRowNotifyVector, SwitchRowStep, WindowTitleStep, WindowTitleVector, } from './action-row.js';
+export { ACTION_ROW_ACTIVATION_VECTORS, ACTION_ROW_SUBTITLE_VECTORS, BUTTON_ROW_ACTIVATABLE_VECTORS, BUTTON_ROW_ICON_VECTORS, LABEL_VISIBILITY_VECTORS, SWITCH_ROW_NOTIFY_VECTORS, WINDOW_TITLE_VECTORS, } from './action-row.js';
+export type { ActionRowActivationVector, ActionRowSubtitleStep, ActionRowSubtitleVector, ActionRowStep, ButtonRowActivatableVector, ButtonRowIconVector, LabelVisibilityVector, SwitchRowNotifyVector, SwitchRowStep, WindowTitleStep, WindowTitleVector, } from './action-row.js';
 export { BANNER_BUTTON_STYLE_PARSE_VECTORS, BANNER_BUTTON_STYLE_VECTORS, BANNER_BUTTON_TEXT_VECTORS, BANNER_BUTTON_VISIBLE_VECTORS, BANNER_DEFAULT_VECTORS, } from './banner.js';
 export type { BannerButtonStyleParseVector, BannerButtonStyleVector, BannerButtonTextVector, BannerButtonVisibleVector, BannerDefaultVector, } from './banner.js';
 export { BUTTON_CONTENT_DEFAULT_VECTORS, BUTTON_CONTENT_ELLIPSIZE_VECTORS, BUTTON_CONTENT_ICON_VECTORS, BUTTON_CONTENT_LABEL_VECTORS, BUTTON_CONTENT_STYLE_TARGET_VECTORS, BUTTON_CONTENT_TEXT_VECTORS, } from './button-content.js';
@@ -18,6 +18,8 @@ export { CHECK_GROUP_VECTORS, driveCheckGroupVectors } from './check-group.js';
 export type { CheckButtonLike, CheckGroupSubject, CheckGroupVector } from './check-group.js';
 export { COMBO_CHOOSER_VECTORS, COMBO_ITEMS_CHANGED_VECTORS, COMBO_SELECTION_VECTORS, TOGGLE_ACTIVE_NAME_VECTORS, } from './rows.js';
 export type { ComboChooserVector, ComboItemsChangedVector, ComboSelectionStep, ComboSelectionVector, ComboSpliceStep, ToggleActiveNameVector, } from './rows.js';
+export { EXPANDER_ROW_CONSTRUCT_VECTORS, EXPANDER_ROW_INITIAL, EXPANDER_ROW_VECTORS } from './expander-row.js';
+export type { ExpanderRowConstructVector, ExpanderRowProperty, ExpanderRowStep, ExpanderRowVector, } from './expander-row.js';
 export { VIEW_STACK_ICON_NAME_VECTORS, VIEW_STACK_PAGE_VECTORS, VIEW_STACK_VECTORS } from './view-stack.js';
 export type { ViewStackIconNameVector, ViewStackPageDescriptorVector, ViewStackVector, ViewStackVectorChange, ViewStackVectorOp, ViewStackVectorPage, } from './view-stack.js';
 export { NAVIGATION_VIEW_VECTORS, collectNavigationState, navigationEventLog, runNavigationSteps, } from './navigation-view.js';
@@ -74,6 +76,8 @@ export { BOX_ORIENTATION_VECTORS, BOX_SPACING_VECTORS } from './box.js';
 export type { BoxOrientationVector, BoxSpacingVector } from './box.js';
 export { LABEL_CHAR_COUNT_VECTORS, LABEL_DISPLAY_TEXT_VECTORS, LABEL_EFFECTIVE_LINES_VECTORS, LABEL_ELLIPSIZE_OVERFLOW_VECTORS, LABEL_ELLIPSIZE_VECTORS, LABEL_JUSTIFY_VECTORS, LABEL_WIDTH_CHARS_EXTENT_VECTORS, LABEL_WRAP_MODE_VECTORS, LABEL_XALIGN_VECTORS, LABEL_YALIGN_ALIGN_ITEMS_VECTORS, LABEL_YALIGN_VECTORS, } from './label.js';
 export type { LabelCharCountVector, LabelDisplayTextVector, LabelEffectiveLinesVector, LabelEllipsizeOverflowVector, LabelEllipsizeVector, LabelJustifyVector, LabelWidthCharsExtentVector, LabelWrapModeVector, LabelXalignVector, LabelYalignAlignItemsVector, LabelYalignVector, } from './label.js';
+export { LABEL_MARKUP_LINK_VECTORS, LABEL_MARKUP_RUN_VECTORS } from './label-markup.js';
+export type { LabelMarkupLinkExpectation, LabelMarkupLinkVector, LabelMarkupRunExpectation, LabelMarkupRunVector, } from './label-markup.js';
 export { WRAP_BOX_CHILD_ORDER_VECTORS, WRAP_BOX_LENGTH_VECTORS, WRAP_BOX_LINE_VECTORS, WRAP_BOX_NATURAL_LENGTH_VECTORS, WRAP_BOX_NOTIFY_PROPERTIES, WRAP_BOX_POLICY_VECTORS, WRAP_BOX_SPACING_NOTIFY_VECTORS, WRAP_BOX_SPACING_VECTORS, } from './wrap-box.js';
 export type { WrapBoxChildOrderVector, WrapBoxLengthVector, WrapBoxLineVector, WrapBoxNaturalLengthVector, WrapBoxPolicyVector, WrapBoxSpacingNotifyVector, WrapBoxSpacingVector, } from './wrap-box.js';
 export { BREAKPOINT_PICK_VECTORS, BREAKPOINT_TRANSITION_VECTORS } from './breakpoint-bin.js';

package/lib/types/conformance/label-markup.d.ts

@@ -0,0 +1,73 @@
+/** One run a label draws: the characters, and the style pango's nesting resolves to. */
+export interface LabelMarkupRunExpectation {
+    text: string;
+    /** Every flag omitted means "not set", so a row only writes what the markup turns on. */
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    strikethrough?: boolean;
+    monospace?: boolean;
+    /** `<big>` minus `<small>`; absent is 0. */
+    sizeSteps?: number;
+    script?: 'sub' | 'sup';
+    /** The index into the same row's `links`, absent when the run is outside every `<a>`. */
+    link?: number;
+    /** The `<span>` attribute sets over the run, outermost first; absent is none. */
+    spans?: ReadonlyArray<Readonly<Record<string, string>>>;
+}
+/** One markup string and the styled runs both ports draw for it. */
+export interface LabelMarkupRunVector {
+    markup: string;
+    /** `gtk_label_get_text()` for the same string — the runs' text concatenated. */
+    text: string;
+    runs: ReadonlyArray<LabelMarkupRunExpectation>;
+    rule: string;
+}
+/**
+ * THE MERGE IS THE PART A RENDERER GETS WRONG. `<b>a</b><b>b</b>` is ONE bold run, not
+ * two: pango attributes character ranges and two adjacent ranges with equal attributes are
+ * one range. A port that emits one span per element draws two boxes, and a line break or a
+ * selection can then fall between two characters that are typographically one word — so
+ * the row with the two adjacent `<b>` elements is the row that catches it.
+ *
+ * `<big>`/`<small>` ARE COUNTED, NOT FLAGS, because pango multiplies one scale factor per
+ * element: `<big><big>x</big></big>` is two steps up, and `<small>` inside `<big>` is back
+ * to zero. The innermost-wins reading a boolean would give is wrong at both rows.
+ */
+export declare const LABEL_MARKUP_RUN_VECTORS: ReadonlyArray<LabelMarkupRunVector>;
+/** One `<a href>` as a label records it. */
+export interface LabelMarkupLinkExpectation {
+    href: string;
+    title: string | null;
+    cssClass: string | null;
+    /** Where the link's text starts in the display text, in UTF-16 code units. */
+    start: number;
+    /** Where it ends, exclusive. */
+    end: number;
+}
+/** One markup string and the links a label takes from it. */
+export interface LabelMarkupLinkVector {
+    markup: string;
+    /** `null` when the markup does not parse at all, and the raw string stands. */
+    links: ReadonlyArray<LabelMarkupLinkExpectation> | null;
+    /** Whether the label gains the `link` CSS class — any link at all. */
+    cssClass: boolean;
+    /** Whether the label gains `has-tooltip` — any link with a `title`. */
+    hasTooltip: boolean;
+    rule: string;
+}
+/**
+ * `Gtk.Label`'s `<a href>` — the one tag that is the LABEL'S and not pango's.
+ *
+ * THE OFFSETS ARE UTF-16 CODE UNITS, where GTK's are bytes (`pdata->text_len` as
+ * `parse_uri_markup` walks). JavaScript has no byte offsets into a string, and the units
+ * that matter are the ones `String.prototype.slice` takes — a renderer cutting the display
+ * text with these gets the characters GTK's layout attributed. The row with a non-ASCII
+ * character before the link is the one that distinguishes the two.
+ *
+ * THE THREE ATTRIBUTES ARE A CLOSED SET. `href` is required
+ * (`G_MARKUP_ERROR_INVALID_CONTENT` without it), `title` and `class` are optional, and a
+ * fourth attribute is `G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE` — which means the whole string
+ * fails to parse and the label shows it raw, not that the attribute is ignored.
+ */
+export declare const LABEL_MARKUP_LINK_VECTORS: ReadonlyArray<LabelMarkupLinkVector>;

package/lib/types/conformance/split-button.d.ts

@@ -16,7 +16,10 @@ export interface SplitButtonContentStep {
     mode: SplitButtonContentMode;
     /** `get_label()` after the step. */
     label: string | null;
-    /** `get_icon_name()` after the step. */
+    /**
+     * `get_icon_name()` after the step — the READBACK, so an icon name set to `''` reads
+     * back `null` here, as it does in C.
+     */
     iconName: string | null;
     /** The root style classes after the step. */
     styleClasses: readonly SplitButtonStyleClass[];
@@ -32,8 +35,9 @@ export interface SplitButtonContentVector {
  * The content machine.
  *
  * Two things are easy to get wrong and are asserted explicitly. The `notified` ORDER: C
- * freezes, notifies the slots it is about to CLEAR, sets the new one, notifies it, then
- * thaws — so one `set_label()` can emit three notifications. And `child` is notified far
+ * freezes, notifies the property being SET, then the slots that were filled before the
+ * call, then thaws — so one `set_label()` can emit three notifications, led by `label`
+ * itself. And `child` is notified far
  * more often than a reader expects, because `adw_split_button_get_child()` returns
  * GtkButton's INTERNAL label/image widget in label/icon mode (the upstream suite says so)
  * and the C guard tests that pointer, not whether the app ever set a child.

package/lib/types/default-translate.d.ts

@@ -0,0 +1,6 @@
+/** Translates `text`, disambiguated by the `C_()` `context` when there is one. */
+export type DefaultTranslate = (text: string, context?: string) => string;
+/** Install the translator; the last registration wins, as a later `textdomain()` call would. */
+export declare function registerDefaultTranslate(translate: DefaultTranslate | undefined): void;
+/** The installed translator, or `undefined` when no platform filled the slot. */
+export declare function registeredDefaultTranslate(): DefaultTranslate | undefined;

package/lib/types/default-translate.spec.d.ts

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

package/lib/types/glib.d.ts

@@ -22,6 +22,46 @@ export declare function gStrStrip(value: string): string;
  * subtitle.
  */
 export declare function stringIsNotEmpty(value: string | null | undefined): boolean;
+/**
+ * How a `GtkButton` reads an icon name BACK: `''` becomes `NULL`.
+ *
+ * `gtk_button_set_icon_name` holds the name on an internal `GtkImage`, and an empty name
+ * leaves that image EMPTY — so `gtk_button_get_icon_name` answers `NULL` for a button
+ * whose icon name was set to `''`. Only the readback normalises; the write itself is
+ * accepted and does replace the content widget.
+ *
+ * WHY A PORT NEEDS IT. C's idempotence guard is `g_strcmp0 (icon_name, get_icon_name
+ * (self))` — the incoming value against the READBACK, not against what is stored. The
+ * two differ exactly here, so `g_strcmp0 ('', NULL)` is non-zero and EVERY
+ * `icon_name = ''` write passes the guard, rebuilds the internal image and notifies,
+ * for as long as it is repeated. A port that compares against its own field instead
+ * swallows the second write and goes silent where GTK is loud.
+ *
+ * Measured on GJS 1.88.1 / libadwaita 1.9.4 / GTK 4.22.5: `set_icon_name('')` on a fresh
+ * `Adw.SplitButton` emits `notify::icon-name` and reads `null` back; repeating it emits
+ * `notify::icon-name` and `notify::child` again. An `''` LABEL does not behave this way —
+ * `gtk_button_get_label` reads `''` straight back — which is why this is one function
+ * about one property and not a general "empty means unset" rule.
+ */
+export declare function gtkButtonIconNameReadback(stored: string | null): string | null;
+/**
+ * Whether `adw_action_row_set_subtitle` passes its guard (adw-action-row.c:571):
+ * `g_strcmp0 (gtk_label_get_text (priv->subtitle), subtitle) == 0` returns early.
+ *
+ * `g_strcmp0` orders `NULL` before every string, `''` included, so a `NULL` write is NEVER
+ * equal to the label text — which always reads `''`, never `NULL`. A `null` subtitle therefore
+ * passes the guard, relabels with `""` and notifies on EVERY write, held value unmoved. A
+ * `''` write against `''` is the ordinary idempotent case.
+ *
+ * Measured on GJS 1.88.1 / libadwaita 1.9.4: `subtitle = null` on a fresh `Adw.ActionRow` and
+ * `Adw.ExpanderRow` emits `notify::subtitle` each time and reads `""` back; `subtitle = ''`
+ * emits nothing. `title` was measured on the same rows and does NOT behave this way, so this is one
+ * property's rule, not a general one.
+ *
+ * @param held     The label text now, never `null`.
+ * @param written  What the caller passed.
+ */
+export declare function adwSubtitleWriteNotifies(held: string, written: string | null | undefined): boolean;
 /**
  * GLib's `CLAMP`, which tests the HIGH bound FIRST:
  * `x > high ? high : (x < low ? low : x)`.

package/lib/types/glib.spec.d.ts

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

package/lib/types/index.d.ts

@@ -51,12 +51,14 @@ export type { GtkStringListProps } from './gtk-string-list.js';
 export { GjsifyOptionList, GjsifyOptionObject, readModelWrite } from './option-list.js';
 export type { GjsifyOptionListProps } from './option-list.js';
 export { ComboState, ExpanderState, ToggleGroupState, keptToggles, toggleIndexOfName } from './rows.js';
-export type { ComboItemsListener, ComboNotify, ComboNotifyListener, ComboStateChange, ComboStateListener, ComboWatchableModel, ExpanderStateListener, ToggleGroupStateChange, ToggleGroupStateListener, } from './rows.js';
+export type { ComboItemsListener, ComboNotify, ComboNotifyListener, ComboStateChange, ComboStateListener, ComboWatchableModel, ExpanderNotify, ExpanderStateListener, ToggleGroupStateChange, ToggleGroupStateListener, } from './rows.js';
 export { DEFAULT_BOX_SPACING, normalizeBoxOrientation, normalizeBoxSpacing } from './box.js';
 export type { BoxOrientation } from './box.js';
 export { DEFAULT_LABEL_ELLIPSIZE, DEFAULT_LABEL_LINES, DEFAULT_LABEL_MAX_WIDTH_CHARS, DEFAULT_LABEL_WIDTH_CHARS, DEFAULT_LABEL_WRAP_MODE, DEFAULT_LABEL_XALIGN, DEFAULT_LABEL_YALIGN, LABEL_ELLIPSIZE_MODES, LABEL_JUSTIFICATIONS, LABEL_WRAP_MODES, labelDisplayText, labelEffectiveLines, labelEllipsizeOverflowValue, labelMarkupIsUnparseable, labelWidthCharsExtent, labelYalignAlignItems, normalizeLabelEllipsize, normalizeLabelJustify, normalizeLabelLines, normalizeLabelMaxWidthChars, normalizeLabelWidthChars, normalizeLabelWrapMode, normalizeLabelXalign, normalizeLabelYalign, } from './label.js';
 export type { LabelAlignItems, LabelEllipsizeMode, LabelJustification, LabelWidthCharsExtent, LabelWrapMode, } from './label.js';
-export { glibClamp, gStrStrip, stringIsNotEmpty } from './glib.js';
+export { LABEL_MARKUP_STYLE_PLAIN, labelActivateLink, labelHasLinks, labelLinkVisited, labelLinksHaveTooltip, labelLinksInheritVisited, labelMarkupRender, } from './label-markup.js';
+export type { LabelActivateLinkSteps, LabelLink, LabelMarkupRender, LabelMarkupRun, LabelMarkupStyle, } from './label-markup.js';
+export { adwSubtitleWriteNotifies, glibClamp, gStrStrip, gtkButtonIconNameReadback, stringIsNotEmpty } from './glib.js';
 export { AppLaunchContext as GdkAppLaunchContext, ContentFormats, ContentProvider, Clipboard, Display, createGdk, widgetDisplayMembers, } from './gdk.js';
 export { CURRENT_TIME, CssProvider, EventControllerKey, GDK_KEYS, GtkSettings, IconTheme, STYLE_PROVIDER_PRIORITY_APPLICATION, STYLE_PROVIDER_PRIORITY_FALLBACK, STYLE_PROVIDER_PRIORITY_SETTINGS, STYLE_PROVIDER_PRIORITY_THEME, STYLE_PROVIDER_PRIORITY_USER, createGtkPlatform, deliverKeyToControllers, keyvalOfKey, widgetControllerMembers, } from './gtk-platform.js';
 export type { GtkPlatform, HostKeyEvent, PlatformHost } from './gtk-platform.js';
@@ -113,8 +115,8 @@ export type { AdwSwipeEnd, AdwSwipeEndInput, AdwSwipeRange, AdwSwipeSource } fro
 export { CAROUSEL_SCROLL_TIMEOUT_MS, CAROUSEL_SETTLE_EPSILON, CarouselState, carouselClampPosition, carouselClosestSnapPoint, carouselNavigateTarget, carouselPageAllocation, carouselPageAtPosition, carouselRange, carouselReorderShift, carouselSizesFromSnapPoints, carouselSnapPoints, carouselWheelStep, } from './carousel.js';
 export type { CarouselChangeReason, CarouselDirection, CarouselOrientation, CarouselPageAllocation, CarouselPageChangedListener, CarouselPageMeasurement, CarouselRange, CarouselReorderShiftInput, CarouselScrollOptions, CarouselScrollRequest, CarouselScrollSource, CarouselStateChange, CarouselStateListener, CarouselStateOptions, CarouselWheelInput, } from './carousel.js';
 export { UNTITLED_PAGE_LABEL, collectSearchRows, countVisiblePages, createSearchRowSubtitle, defaultCaseFolder, derivePreferencesGroupHeader, makeComparable, rowMatchesQuery, searchPreferences, } from './preferences.js';
-export { PANGO_MARKUP_TAGS, escapeMarkup, parsePangoMarkup, stripMarkup } from './pango-markup.js';
-export type { PangoMarkupNode, PangoMarkupTag } from './pango-markup.js';
+export { PANGO_MARKUP_TAGS, escapeMarkup, parseLabelMarkup, parsePangoMarkup, stripLabelMarkup, stripMarkup, } from './pango-markup.js';
+export type { LabelMarkupNode, PangoMarkupNode, PangoMarkupTag } from './pango-markup.js';
 export type { CaseFolder, MakeComparableOptions, PreferencesGroupHeaderInput, PreferencesGroupHeaderState, PreferencesSearchEntry, PreferencesSearchGroup, PreferencesSearchPage, PreferencesSearchResult, PreferencesSearchRow, SearchPreferencesOptions, SearchRowSubtitleInput, } from './preferences.js';
 export { ADW_CLAMP_DEFAULTS, ADW_CLAMP_SIZE_CLASSES, ADW_SPINNER_MAX_SIZE, ADW_SPINNER_MIN_SIZE, ADW_TOOLBAR_BAR_CLASSES, ADW_TOOLBAR_VIEW_CLASSES, ADW_TOOLBAR_VIEW_DEFAULTS, clampAllocate, clampChildSize, clampSizeFromChild, clampThresholds, normalizeClampSize, parseToolbarStyle, resolveSpinnerSize, spinnerGeometry, toolbarBarStyleClasses, toolbarViewAllocate, toolbarViewClasses, toolbarViewContentForSize, toolbarViewMeasure, } from './chrome.js';
 export type { AdwClampSizeClass, AdwMeasurement, AdwToolbarStyle, ClampAllocation, ClampParams, ClampThresholds, SpinnerGeometry, ToolbarViewAllocateInput, ToolbarViewAllocation, ToolbarViewClassInput, ToolbarViewClasses, ToolbarViewContentForSize, ToolbarViewContentForSizeInput, ToolbarViewMeasureInput, } from './chrome.js';
@@ -142,6 +144,8 @@ export type { ApplicationHost, GtkApplicationMembers, GtkApplicationConstructor
 export { ActionRegistry, SimpleAction, actionRegistryOf, activateWidgetAction, applicationOfWindow, findActionGroup, insertActionGroup, installActionMap, linkWindow, SimpleActionGroup, } from './gio-actions.js';
 export type { ActionActivateHandler, ActionGroupLike, ActionLike, SimpleActionProps } from './gio-actions.js';
 export type { Binding, BindingFlag, BlueprintTemplate, BuiltTemplate, ClassLike, ClassMeta, GInterface, GObjectConstructor, GObjectDoor, GObjectInstance, GObjectNamespace, GType, ParamKind, RegisterClass, RegisteredClass, SignalHandler, SignalMeta, TemplateScope, } from './gobject.js';
+export { registerDefaultTranslate, registeredDefaultTranslate } from './default-translate.js';
+export type { DefaultTranslate } from './default-translate.js';
 export { engineForTarget, registerGObjectEngine, registeredEngine, resetRegisteredEngine } from './engine.js';
 export type { EngineTarget, ForeignClassMeta, ForeignObjectProperty, ForeignProperty, ForeignPropertyKind, ForeignScalarKind, ForeignScalarProperty, ForeignSignal, GObjectEngine, } from './engine.js';
 export { MAXUINT32, buildFilenamev, getCurrentDir, getSystemDataDirs } from './glib-paths.js';

package/lib/types/label-markup.d.ts

@@ -0,0 +1,129 @@
+/**
+ * The style one run of text carries, with pango's nesting already resolved.
+ *
+ * The booleans are pango's own tags; a tag nested inside itself is still just set, which
+ * is why they are booleans and not counts. `sizeSteps` IS a count, because `<big>` and
+ * `<small>` are relative and compose: `<big><big>` is two steps up, and `<small>` inside
+ * `<big>` cancels back to zero — pango applies one `PANGO_SCALE_*` factor per element, so
+ * the steps multiply rather than the innermost winning.
+ */
+export interface LabelMarkupStyle {
+    /** `<b>`. */
+    readonly bold: boolean;
+    /** `<i>`. */
+    readonly italic: boolean;
+    /** `<u>`. */
+    readonly underline: boolean;
+    /** `<s>`. */
+    readonly strikethrough: boolean;
+    /** `<tt>`. */
+    readonly monospace: boolean;
+    /** `<big>` minus `<small>`, so a negative value is smaller text. */
+    readonly sizeSteps: number;
+    /** `<sub>` / `<sup>`, the INNERMOST of the two — one run cannot be both. */
+    readonly script: 'sub' | 'sup' | null;
+    /**
+     * The `<span>` attribute sets the run sits inside, OUTERMOST FIRST.
+     *
+     * A STACK and not one merged record, because the attribute→platform mapping is the
+     * renderer's (`font_weight` is an alias of `weight` on the web, `fontWeight` on
+     * NativeScript, and neither list is the other's). A renderer applies them in order and
+     * the innermost therefore wins per platform property — merging here would need pango's
+     * alias table in core, where no port reads it.
+     */
+    readonly spans: readonly Readonly<Record<string, string>>[];
+}
+/** No tag at all — the style a bare text run carries. */
+export declare const LABEL_MARKUP_STYLE_PLAIN: LabelMarkupStyle;
+/** One `<a href>` of a label's markup, over a range of its display text. */
+export interface LabelLink {
+    /** `<a href>`. */
+    readonly href: string;
+    /** `<a title>` — what GTK shows as the label's tooltip over this link. */
+    readonly title: string | null;
+    /** `<a class>` — the CSS class GTK adds to the link's own node. */
+    readonly cssClass: string | null;
+    /** Where the link's text starts in the display text, in UTF-16 code units. */
+    readonly start: number;
+    /** Where it ends, exclusive. `start === end` is a link with nothing to click. */
+    readonly end: number;
+    /** Whether this link has been followed — see {@link labelLinksInheritVisited}. */
+    readonly visited: boolean;
+}
+/** One run of a label's markup: text, the style over it, and the link it sits in. */
+export interface LabelMarkupRun {
+    readonly text: string;
+    readonly style: LabelMarkupStyle;
+    /**
+     * The index into {@link LabelMarkupRender.links} of the link this run is inside, or
+     * `null`. An INDEX rather than the link itself, so a renderer that updates `visited`
+     * replaces one array entry instead of rewriting every run that points at it.
+     */
+    readonly link: number | null;
+}
+/** A label's markup, ready to draw. */
+export interface LabelMarkupRender {
+    /** `gtk_label_get_text()` — the runs' text concatenated. */
+    readonly text: string;
+    /** The styled runs, in reading order. Empty when the markup has no text at all. */
+    readonly runs: readonly LabelMarkupRun[];
+    /** The `<a href>` elements, in reading order. */
+    readonly links: readonly LabelLink[];
+}
+/**
+ * A label's `label` as the runs and links a renderer draws, or `null` when the markup does
+ * not parse — the same `null` {@link parseLabelMarkup} returns, so a caller takes the C
+ * fallback (show the raw string) on exactly the strings GTK takes it on.
+ *
+ * `previous` is the links the label held BEFORE this value, and only `visited` is read from
+ * it: see {@link labelLinksInheritVisited}.
+ */
+export declare function labelMarkupRender(markup: string, previous?: readonly LabelLink[]): LabelMarkupRender | null;
+/**
+ * `visited` carried across a re-parse by URI (gtklabel.c:3635-3647): a link whose `href`
+ * matches one the label already had keeps that link's `visited`, because following a link
+ * and then rewriting the text around it has not un-followed it.
+ *
+ * FIRST match, as in the C: two links to the same URI are one visited state.
+ */
+export declare function labelLinksInheritVisited(links: readonly LabelLink[], previous: readonly LabelLink[]): readonly LabelLink[];
+/**
+ * `gtk_label_ensure_has_tooltip` — a label gets `has-tooltip` when ANY of its links
+ * carries a `title`, because the tooltip is per-link and the widget has to opt in before
+ * `query-tooltip` is ever asked.
+ */
+export declare function labelLinksHaveTooltip(links: readonly LabelLink[]): boolean;
+/**
+ * The `link` CSS class `gtk_label_set_markup` adds to the WIDGET (gtklabel.c:3896) when its
+ * markup carried at least one `<a href>` — libadwaita's stylesheet selects on it, so a
+ * port that draws the link colour without it is styling by its own rule and not GTK's.
+ */
+export declare function labelHasLinks(links: readonly LabelLink[]): boolean;
+/** What one port supplies to one `::activate-link` emission. */
+export interface LabelActivateLinkSteps {
+    /**
+     * `GTK_IS_WINDOW (gtk_widget_get_root (widget))` — the default handler returns FALSE
+     * for a label with no window above it, and then NOTHING is launched. A port answers
+     * this with whatever "is in a presented window" means for it.
+     */
+    readonly rooted: boolean;
+    /** Emit `activate-link` to the USER's handlers and answer whether one handled it. */
+    emit(): boolean;
+    /** `Gio.AppInfo.launch_default_for_uri` — the port's door, ADR 0101. */
+    launch(uri: string): void;
+}
+/**
+ * `emit_activate_link` — `::activate-link` is RUN_LAST with the boolean handled
+ * accumulator (`HandledAccumulator`, `window-members.ts`), so the order is: the user's
+ * handlers, then — only if none handled it — the class handler, which launches the URI and
+ * counts that as handled.
+ *
+ * Returns whether the link becomes VISITED, which is what GTK does with the signal's
+ * result: a handler that returns TRUE has followed the link its own way, and the default
+ * returning TRUE means the URI went to the host. A label with no window above it returns
+ * FALSE and the link stays unvisited — `gtk_label_activate_link`'s first branch, and the
+ * reason it is not simply "launch and say yes".
+ */
+export declare function labelActivateLink(uri: string, steps: LabelActivateLinkSteps): boolean;
+/** The links of `links` with the one at `index` marked visited; the others untouched. */
+export declare function labelLinkVisited(links: readonly LabelLink[], index: number): readonly LabelLink[];

package/lib/types/label-markup.spec.d.ts

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

package/lib/types/label.d.ts

@@ -11,6 +11,12 @@ export type LabelJustification = (typeof LABEL_JUSTIFICATIONS)[number];
  * of the resulting TEXT, so an `_` inside a tag's attributes is not a mnemonic. Doing it
  * the other way round would let `<span font_desc="Sans">` lose its underscore and stop
  * parsing.
+ *
+ * THE PARSE IS THE LABEL'S, `stripLabelMarkup` — pango's tags PLUS `<a href>`, which is
+ * what `gtk_label_get_text()` returns, because `parse_uri_markup` lifts the `<a>` elements
+ * out before pango ever sees the string. A surface that is NOT a label does not come here:
+ * `Gtk.Inscription` has no `::activate-link` and its `markup` goes through
+ * `pango_parse_markup` alone, so `<a>` is an unknown tag there and the raw string stands.
  */
 export declare function labelDisplayText(label: string, useMarkup: boolean, useUnderline: boolean): string;
 /** Whether `label` carries markup that could not be reduced, so the raw string is shown. */

package/lib/types/pango-markup.d.ts

@@ -17,6 +17,29 @@ export type PangoMarkupNode = {
     readonly attributes: Readonly<Record<string, string>>;
     readonly children: readonly PangoMarkupNode[];
 };
+/**
+ * A piece of LABEL markup: {@link PangoMarkupNode}, plus the `<a href>` run pango knows
+ * nothing about. Every `PangoMarkupNode` IS a `LabelMarkupNode` — the link kind is the
+ * only addition — so a renderer written against this type draws both trees.
+ */
+export type LabelMarkupNode = {
+    readonly kind: 'text';
+    readonly text: string;
+} | {
+    readonly kind: 'element';
+    readonly tag: PangoMarkupTag;
+    readonly attributes: Readonly<Record<string, string>>;
+    readonly children: readonly LabelMarkupNode[];
+} | {
+    readonly kind: 'link';
+    /** `<a>`'s required `href`, entities resolved. */
+    readonly href: string;
+    /** `<a title>`, which GTK shows as the label's tooltip; `null` when absent. */
+    readonly title: string | null;
+    /** `<a class>`, the CSS class GTK puts on the link's own node; `null` when absent. */
+    readonly cssClass: string | null;
+    readonly children: readonly LabelMarkupNode[];
+};
 /**
  * `g_markup_escape_text` — the escape `create_search_row_subtitle` puts a page title
  * through before it becomes a markup subtitle. GLib emits NUMERIC references for the
@@ -50,10 +73,32 @@ export declare function escapeMarkup(text: string): string;
  * discarded).
  */
 export declare function parsePangoMarkup(text: string): PangoMarkupNode[] | null;
+/**
+ * `gtk_label_set_markup`'s whole parse: pango's markup PLUS `<a href>`, which is
+ * `Gtk.Label`'s own extension and not a pango tag at all.
+ *
+ * Same `null`-never-throws contract as {@link parsePangoMarkup}, and the same failures,
+ * with `<a>`'s two added: an attribute other than `href` / `title` / `class`
+ * (`G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE`) and a missing `href`
+ * (`G_MARKUP_ERROR_INVALID_CONTENT`).
+ *
+ * USE THIS ONLY WHERE GTK ITSELF PARSES URI MARKUP — `Gtk.Label`, and the widgets that
+ * are a label (`Gtk.Inscription` is NOT one: it has no `::activate-link`). Everything
+ * else — the search pipeline's `stripMarkup`, `Adw.Banner`, `Adw.AlertDialog` — stays on
+ * {@link parsePangoMarkup}, where `<a>` is an unknown tag and the string falls back to
+ * text, because that is what those surfaces do in the C.
+ */
+export declare function parseLabelMarkup(text: string): LabelMarkupNode[] | null;
 /**
  * The plain text of markup — {@link parsePangoMarkup} reduced to its text runs, and
  * `null` under exactly the same failures. This is what `make_comparable` compares, what
- * `<gtk-label>`/`<gtk-inscription>` show for `use-markup`, and what the C shows when
- * markup does not parse.
+ * `<gtk-inscription>` shows for `markup`, and what the C shows when markup does not parse.
  */
 export declare function stripMarkup(text: string): string | null;
+/**
+ * The plain text of LABEL markup — {@link parseLabelMarkup} reduced the same way, so a
+ * `<a href="…">GTK</a>` shows as `GTK` and not as the raw string. This is what
+ * `gtk_label_get_text` returns: `parse_uri_markup` strips the `<a>` elements out before
+ * pango ever sees the string, and the text GTK keeps is the remainder.
+ */
+export declare function stripLabelMarkup(text: string): string | null;

package/lib/types/rows.d.ts

@@ -6,21 +6,43 @@ export type { SpinStateChange, SpinStateListener, SpinStateRangeListener } from
 /** Subscriber for {@link ExpanderState} changes — receives the new expanded flag. */
 export type ExpanderStateListener = (expanded: boolean) => void;
 /**
- * The disclosure state of an expander row: a single boolean that toggles between
- * revealed and collapsed. Idempotent — setting the current value again is a no-op
- * and fires no notification. Both programmatic and interactive changes notify (as
- * `Adw.ExpanderRow` does).
+ * The `notify::*` an expander-row write emits, in emission order. A renderer that owns real
+ * GObject properties re-emits it verbatim; `expanded` leads `enable-expansion` because the
+ * C setter cross-writes `expanded` before it notifies its own property.
+ */
+export type ExpanderNotify = 'expanded' | 'enable-expansion';
+/**
+ * The state of an expander row: whether the disclosure is revealed, and whether it may be.
+ *
+ * The two are coupled the way `adw-expander-row.c` couples them. `setExpanded` coerces
+ * `expanded && enableExpansion` before its equal-return (C:264), so opening a disabled row is
+ * a silent no-op rather than a refusal. `setEnableExpansion` stores, drives `expanded` to the
+ * new value (C:310) and only then notifies its own property — enabling EXPANDS, disabling
+ * COLLAPSES. Idempotent — setting a current value again fires nothing. Both programmatic and
+ * interactive changes notify (as `Adw.ExpanderRow` does).
  */
 export declare class ExpanderState {
     private _expanded;
+    private _enableExpansion;
     private readonly _listeners;
     /** Subscribe to expanded-state changes. Returns an unsubscribe function. */
     subscribe(listener: ExpanderStateListener): () => void;
     private _emit;
     /** Whether the disclosure is revealed. */
     get expanded(): boolean;
-    /** Set the expanded flag. Notifies only on an actual change. Returns whether it changed. */
+    /** Whether the row can be expanded at all. */
+    get enableExpansion(): boolean;
+    /**
+     * Set the expanded flag, held `false` while expansion is disabled. Notifies only on an
+     * actual change. Returns whether it changed.
+     */
     setExpanded(value: boolean): boolean;
+    /**
+     * Set `enable-expansion` and drive `expanded` to the same value. Returns the properties
+     * the write notifies, in order: empty for an equal write, `['enable-expansion']` when
+     * `expanded` already held the value, `['expanded', 'enable-expansion']` otherwise.
+     */
+    setEnableExpansion(value: boolean): readonly ExpanderNotify[];
     /** Flip expanded↔collapsed (the disclosure tap). Returns whether it changed. */
     toggle(): boolean;
     /** Reveal the disclosure. Returns whether it changed. */