@gjsify/adwaita-web 0.44.0 → 0.46.0

package/src/elements/{adw-menu-button.ts → gtk-menu-button.ts}

@@ -1,11 +1,11 @@
-// <adw-menu-button> — the web counterpart of Gtk.MenuButton, which libadwaita styles
+// <gtk-menu-button> — the web counterpart of Gtk.MenuButton, which libadwaita styles
 // but never subclassed: by default the flat `open-menu-symbolic` app-menu button used
 // at the end of a header bar. Clicking it toggles an Adwaita-styled popover under the
 // button, dismissed on an outside click or Escape, with arrow-key navigation.
 //
-// The popover is `<adw-popover>` and the dismissal/keyboard machine is
+// The popover is `<gtk-popover>` and the dismissal/keyboard machine is
 // `@gjsify/adwaita-core`'s (ADR 0004); this element keeps only what is a menu button:
-// the icon, the item model, the title. Icons go through `<adw-icon>`, whose
+// the icon, the item model, the title. Icons go through `<gtk-image>`, whose
 // `normalizeIconName` guard is what keeps a multi-token `icon-name="a b"` from
 // shipping a stray CSS class — for the button icon and for every menu entry's.
 //
@@ -30,19 +30,28 @@ import {
 import type { AdwMenuEntry, SplitButtonDirection } from '@gjsify/adwaita-core';
 
 // SIDE-EFFECT import, deliberately separate from the type import below: it guarantees
-// `adw-popover` is defined before this module's `customElements.define` can upgrade a
-// server-rendered `<adw-menu-button>` and build one. A combined
-// `import { AdwPopover }` would NOT do it — the binding is only used in type position,
+// `gtk-popover` is defined before this module's `customElements.define` can upgrade a
+// server-rendered `<gtk-menu-button>` and build one. A combined
+// `import { GtkPopover }` would NOT do it — the binding is only used in type position,
 // and this package compiles without `verbatimModuleSyntax`, so TypeScript would elide
 // the statement and take the registration with it.
-import './adw-popover.js';
-import type { AdwPopover } from './adw-popover.js';
+import './gtk-popover.js';
+import type { GtkPopover } from './gtk-popover.js';
 
-import { createAdwIcon } from './adw-icon.js';
+import { createGtkImage } from './gtk-image.js';
 
 /**
- * A menu entry — `@gjsify/adwaita-core`'s {@link AdwMenuEntry}, re-exported under the
- * name this element has always used.
+ * A menu entry — `@gjsify/adwaita-core`'s {@link AdwMenuEntry} under the name both
+ * renderers export it as.
+ *
+ * IT KEEPS THE `Adw` PREFIX WHILE THE ELEMENT ABOVE IT DOES NOT, and the reason is not
+ * "the name it has always used" — ADR 0034 clause 1 just moved every name in this file
+ * that had one. It is that this is not a WIDGET name: clause 1 is about the tag, and
+ * this is the descriptor a consumer writes menu entries with. `@gjsify/adwaita-
+ * nativescript` exports `AdwMenuItem` for the same type, and that port deliberately
+ * keeps `Adw` throughout, so renaming this half would give one object two spellings —
+ * which is the thing the ADR is removing, not applying. (`GtkDropDownOption` next door
+ * DID move: its NativeScript twin exports no such name, so there was nothing to split.)
  *
  * It used to be a SECOND declaration of the same shape, and the NativeScript menu
  * button declared a THIRD that was missing `icon` entirely. One type, so a consumer
@@ -65,9 +74,9 @@ const POPOVER_POSITIONS = {
     right: 'end',
 } as const;
 
-export class AdwMenuButton extends HTMLElement {
+export class GtkMenuButton extends HTMLElement {
     private _buttonEl!: HTMLButtonElement;
-    private _popoverEl!: AdwPopover;
+    private _popoverEl!: GtkPopover;
     private _items: AdwMenuItem[] = [];
     private _menuTitle = '';
     private _initialized = false;
@@ -124,7 +133,7 @@ export class AdwMenuButton extends HTMLElement {
         this._buttonEl.setAttribute('aria-haspopup', 'menu');
         this._buttonEl.setAttribute('aria-expanded', 'false');
 
-        this._popoverEl = document.createElement('adw-popover') as AdwPopover;
+        this._popoverEl = document.createElement('gtk-popover') as GtkPopover;
         this._popoverEl.classList.add('adw-menu-button-popover');
         this._popoverEl.setAttribute('role', 'menu');
         // `gtk_menu_button_set_menu_model` builds a GtkPopoverMenu, whose CSS
@@ -190,7 +199,7 @@ export class AdwMenuButton extends HTMLElement {
 
         this._buttonEl.replaceChildren();
         this._buttonEl.appendChild(
-            createAdwIcon(this.getAttribute('icon-name') ?? 'open-menu', 'adw-menu-button-icon'),
+            createGtkImage(this.getAttribute('icon-name') ?? 'open-menu', 'adw-menu-button-icon'),
         );
         this._buttonEl.setAttribute('aria-label', this.getAttribute('menu-title') || 'Menu');
 
@@ -219,8 +228,8 @@ export class AdwMenuButton extends HTMLElement {
             // An entry that asked for NO icon gets no icon node — the emptiness of the
             // declared name, not whether it resolved. Testing `resolvedIconName` dropped
             // the node for a name that was given and merely undrawable, which is the one
-            // case a reader needs to SEE; `<adw-icon>` draws `image-missing` there.
-            const entryIcon = createAdwIcon(entry.icon ?? null, 'adw-menu-button-item-icon');
+            // case a reader needs to SEE; `<gtk-image>` draws `image-missing` there.
+            const entryIcon = createGtkImage(entry.icon ?? null, 'adw-menu-button-item-icon');
             if (stringIsNotEmpty(entry.icon)) item.appendChild(entryIcon);
             const labelEl = document.createElement('span');
             labelEl.className = 'adw-menu-button-item-label';
@@ -245,4 +254,4 @@ export class AdwMenuButton extends HTMLElement {
     }
 }
 
-customElements.define('adw-menu-button', AdwMenuButton);
+customElements.define('gtk-menu-button', GtkMenuButton);

package/src/elements/{adw-popover.ts → gtk-popover.ts}

@@ -1,6 +1,6 @@
-// <adw-popover> — the elevated surface that pops up next to an anchor, the web
+// <gtk-popover> — the elevated surface that pops up next to an anchor, the web
 // counterpart of GtkPopover as libadwaita styles it. It is the ONE popover in this
-// package: `<adw-menu-button>`, `<adw-drop-down>` and `<adw-split-button>` all use it
+// package: `<gtk-menu-button>`, `<gtk-drop-down>` and `<adw-split-button>` all use it
 // rather than building their own, which is what keeps the 15px radius, the
 // three-layer shadow, Escape dismissal and the wrap arithmetic in one place.
 //
@@ -51,22 +51,22 @@
 import { PopoverState, resolvePopoverKey } from '@gjsify/adwaita-core';
 
 /** Which side of the anchor the surface sits on. */
-export type AdwPopoverPosition = 'bottom' | 'top' | 'start' | 'end';
+export type GtkPopoverPosition = 'bottom' | 'top' | 'start' | 'end';
 
 /** Which edge of the anchor the surface lines up with. */
-export type AdwPopoverAlign = 'start' | 'end';
+export type GtkPopoverAlign = 'start' | 'end';
 
 /** The ARIA role of the surface — it decides the row role consumers give their items. */
-export type AdwPopoverRole = 'menu' | 'listbox';
+export type GtkPopoverRole = 'menu' | 'listbox';
 
-const POSITIONS: readonly AdwPopoverPosition[] = ['bottom', 'top', 'start', 'end'];
-const ALIGNS: readonly AdwPopoverAlign[] = ['start', 'end'];
-const ROLES: readonly AdwPopoverRole[] = ['menu', 'listbox'];
+const POSITIONS: readonly GtkPopoverPosition[] = ['bottom', 'top', 'start', 'end'];
+const ALIGNS: readonly GtkPopoverAlign[] = ['start', 'end'];
+const ROLES: readonly GtkPopoverRole[] = ['menu', 'listbox'];
 
 /** The row selector keyboard navigation walks. */
 const ITEM_SELECTOR = '.adw-popover-item';
 
-export class AdwPopover extends HTMLElement {
+export class GtkPopover extends HTMLElement {
     private readonly _state = new PopoverState();
     private _anchor: HTMLElement | null = null;
     private _initialized = false;
@@ -116,27 +116,27 @@ export class AdwPopover extends HTMLElement {
         this._anchor = value;
     }
 
-    get position(): AdwPopoverPosition {
+    get position(): GtkPopoverPosition {
         const value = this.getAttribute('position');
-        return POSITIONS.includes(value as AdwPopoverPosition) ? (value as AdwPopoverPosition) : 'bottom';
+        return POSITIONS.includes(value as GtkPopoverPosition) ? (value as GtkPopoverPosition) : 'bottom';
     }
 
-    set position(value: AdwPopoverPosition) {
+    set position(value: GtkPopoverPosition) {
         this.setAttribute('position', value);
     }
 
-    get align(): AdwPopoverAlign {
+    get align(): GtkPopoverAlign {
         const value = this.getAttribute('align');
-        return ALIGNS.includes(value as AdwPopoverAlign) ? (value as AdwPopoverAlign) : 'start';
+        return ALIGNS.includes(value as GtkPopoverAlign) ? (value as GtkPopoverAlign) : 'start';
     }
 
-    set align(value: AdwPopoverAlign) {
+    set align(value: GtkPopoverAlign) {
         this.setAttribute('align', value);
     }
 
-    get popoverRole(): AdwPopoverRole {
+    get popoverRole(): GtkPopoverRole {
         const value = this.getAttribute('role');
-        return ROLES.includes(value as AdwPopoverRole) ? (value as AdwPopoverRole) : 'menu';
+        return ROLES.includes(value as GtkPopoverRole) ? (value as GtkPopoverRole) : 'menu';
     }
 
     /** The navigable rows, in DOM order. Hidden rows are skipped — a filtered list navigates what it shows. */
@@ -275,4 +275,4 @@ export class AdwPopover extends HTMLElement {
     }
 }
 
-customElements.define('adw-popover', AdwPopover);
+customElements.define('gtk-popover', GtkPopover);

package/src/elements/{adw-progress-bar.ts → gtk-progress-bar.ts}

@@ -1,4 +1,4 @@
-// <adw-progress-bar> — the DETERMINATE progress indicator, and the partner to
+// <gtk-progress-bar> — the DETERMINATE progress indicator, and the partner to
 // <adw-spinner>, which only ever covers "busy, no idea how long".
 //
 // NO CORE STATE MACHINE: the whole behaviour is `CLAMP(fraction, 0, 1)` plus a pulsing
@@ -9,9 +9,9 @@
 // `gtk_progress_bar_pulse()`'s step semantics (the `pulse-step` default, how the block
 // reflects at the ends, whether it resets `fraction`) are NOT reproduced: GtkProgressBar
 // is a GTK widget, `refs/gtk` is an uninitialized submodule here and libadwaita vendors
-// no `adw-progress-bar.c`, so none of it is verifiable. What ships instead is the
+// no `gtk-progress-bar.c`, so none of it is verifiable. What ships instead is the
 // vendored port's web idiom — a CSS keyframe animation that runs while `pulsing` is set
-// — so {@link AdwProgressBar.pulse} ENTERS that state and is idempotent afterwards. The
+// — so {@link GtkProgressBar.pulse} ENTERS that state and is idempotent afterwards. The
 // default `show-text` label `NN%` is likewise this port's, not GTK's format string.
 //
 // `osd` is libadwaita's `.osd` STYLE CLASS: a 2px troughless bar for under a header bar.
@@ -29,7 +29,7 @@
 
 import { glibClamp } from '@gjsify/adwaita-core';
 
-export class AdwProgressBar extends HTMLElement {
+export class GtkProgressBar extends HTMLElement {
     private _trough!: HTMLSpanElement;
     private _progress!: HTMLSpanElement;
     private _text!: HTMLSpanElement;
@@ -166,4 +166,4 @@ export class AdwProgressBar extends HTMLElement {
     }
 }
 
-customElements.define('adw-progress-bar', AdwProgressBar);
+customElements.define('gtk-progress-bar', GtkProgressBar);

package/src/elements/{adw-switch.ts → gtk-switch.ts}

@@ -1,4 +1,4 @@
-// <adw-switch> — the Adwaita toggle, as an element. A 44×24 track with a hidden
+// <gtk-switch> — the Adwaita toggle, as an element. A 44×24 track with a hidden
 // checkbox behind it and a knob that slides on `active`.
 //
 // The styles are the UNSCOPED `scss/_switch.scss`, so `.adw-switch` exists outside a
@@ -29,7 +29,7 @@
 // Copyright (c) 2025 csm (adwaita-web). MIT License.
 // Modifications: Implemented as a Web Component for @gjsify/adwaita-web.
 
-export class AdwSwitch extends HTMLElement {
+export class GtkSwitch extends HTMLElement {
     private _input!: HTMLInputElement;
     private _slider!: HTMLSpanElement;
     private _initialized = false;
@@ -44,7 +44,7 @@ export class AdwSwitch extends HTMLElement {
      * `adw_switch_row_init` does `gtk_widget_set_can_focus (self->slider, FALSE)`
      * (adw-switch-row.c:159) and makes the ROW activatable instead, so a switch row is ONE
      * tab stop announced as its own title — not a bare checkbox followed by a label that
-     * cannot be reached. A standalone `<adw-switch>` keeps its checkbox focusable.
+     * cannot be reached. A standalone `<gtk-switch>` keeps its checkbox focusable.
      */
     get unfocusable(): boolean {
         return this.hasAttribute('unfocusable');
@@ -125,4 +125,4 @@ export class AdwSwitch extends HTMLElement {
     }
 }
 
-customElements.define('adw-switch', AdwSwitch);
+customElements.define('gtk-switch', GtkSwitch);

package/src/elements/view-switcher-dom.ts

@@ -20,7 +20,7 @@
 import { viewSwitcherIconName } from '@gjsify/adwaita-core';
 import type { AdwViewSwitcherPageInit, ViewSwitcherScheduler, ViewSwitcherTimerHandle } from '@gjsify/adwaita-core';
 
-import { type AdwIcon, createAdwIcon } from './adw-icon.js';
+import { type GtkImage, createGtkImage } from './gtk-image.js';
 
 /**
  * The browser's timer behind the core's scheduler seam. One shared instance rather than
@@ -41,16 +41,16 @@ export const domViewSwitcherScheduler: ViewSwitcherScheduler = {
  *
  * The core resolves NULL/empty to `image-missing` (which the stylesheet carries
  * a real glyph for); the `-symbolic` strip and the CSS-token guard are
- * `normalizeIconName`'s, applied by `<adw-icon>` — that strip is this package's
+ * `normalizeIconName`'s, applied by `<gtk-image>` — that strip is this package's
  * own mask-class convention and has no counterpart in C, where the name reaches
  * `GtkImage` untouched.
  */
-export function createSwitcherIcon(iconName: string, extra: string): AdwIcon {
-    return createAdwIcon(viewSwitcherIconName(iconName), extra);
+export function createSwitcherIcon(iconName: string, extra: string): GtkImage {
+    return createGtkImage(viewSwitcherIconName(iconName), extra);
 }
 
 /** Repaint an existing switcher icon from a page's declared name. */
-export function applySwitcherIcon(icon: AdwIcon, iconName: string): void {
+export function applySwitcherIcon(icon: GtkImage, iconName: string): void {
     icon.iconName = viewSwitcherIconName(iconName);
 }
 

package/src/exported-elements.ts

@@ -0,0 +1,50 @@
+// Every custom-element constructor this package's barrel exports, however it exports it.
+//
+// THE INCIDENT THIS EXISTS TO PREVENT, in the shape it was caught. Two browser drivers
+// derive their element set from the package rather than from a list — `Object.values` of
+// the module namespace, kept to the functions whose prototype is an `HTMLElement`. That
+// read the widget classes because the barrel re-exported every one of them flat. ADR 0034
+// § Amendment 6 removed those re-exports: the same scan would have gone on passing while
+// its subject shrank to the handful of web-only classes that keep a flat name. Measured
+// on chromium: the narrow scan drops 187 of the package's 4633 browser assertions, and
+// the only thing that noticed was `connect-lifecycle.spec.ts`'s `tags.length > 40`
+// floor. A floor catches the collapse; it does not catch a scan that is merely narrower
+// than it reads, and the next removal will be smaller.
+//
+// So the walk goes ONE LEVEL into the exported objects, which is where `Adw` and `Gtk`
+// put their members. `typeof` is what picks them out and it does not care that they are
+// MODULE namespaces rather than plain objects (`export * as Adw from
+// ./namespace/adw.js`) — a module namespace answers `object` and enumerates under
+// `Object.values` like any other. One level and not a recursion: both barrels are flat
+// by construction, and a deep walk would start reporting whatever a future export
+// happens to hang off itself.
+//
+// It is a module rather than a copy in each spec because the second copy is where a
+// helper gets lifted, and this was already the second copy.
+
+/** A constructor the `CustomElementRegistry` could hold — the filter both drivers used. */
+function isElementClass(value: unknown): value is CustomElementConstructor {
+    return typeof value === 'function' && value.prototype instanceof HTMLElement;
+}
+
+/**
+ * The element classes reachable from `barrel`, de-duplicated.
+ *
+ * De-duplicated because a class can arrive twice: `Adw.CheckBox`-style aliasing is not
+ * used today, but a widget that is both a namespace member and a flat web-only export
+ * would otherwise be driven twice and counted twice in the floors below the callers.
+ *
+ * @param barrel the module namespace of `index.ts` (`import * as adwaitaWeb`)
+ */
+export function exportedElementClasses(barrel: Record<string, unknown>): CustomElementConstructor[] {
+    const found = new Set<CustomElementConstructor>();
+    for (const exported of Object.values(barrel)) {
+        if (isElementClass(exported)) {
+            found.add(exported);
+            continue;
+        }
+        if (typeof exported !== 'object' || exported === null) continue;
+        for (const member of Object.values(exported)) if (isElementClass(member)) found.add(member);
+    }
+    return [...found];
+}

package/src/{adw-button.spec.ts → gtk-button.spec.ts}

@@ -1,4 +1,4 @@
-// DOM-level tests for <adw-button>'s style classes.
+// DOM-level tests for <gtk-button>'s style classes.
 //
 // The element and its NativeScript twin each kept their own attribute→class table,
 // and the two disagreed: `circular` was here and not there. The table now lives in
@@ -13,7 +13,7 @@ const WEB_ATTRIBUTES = new Set(['flat', 'suggested', 'destructive', 'circular',
 
 /** Mount a button carrying the given boolean attributes; return the inner classes. */
 function mountWithStyles(names: readonly string[]): string[] {
-    const el = document.createElement('adw-button');
+    const el = document.createElement('gtk-button');
     el.setAttribute('label', 'Click me');
     for (const name of names) el.setAttribute(name, '');
     document.body.appendChild(el);
@@ -22,10 +22,10 @@ function mountWithStyles(names: readonly string[]): string[] {
 }
 
 function unmountAll(): void {
-    for (const el of Array.from(document.querySelectorAll('adw-button'))) el.remove();
+    for (const el of Array.from(document.querySelectorAll('gtk-button'))) el.remove();
 }
 
-export const AdwButtonTest = async () => {
+export const GtkButtonTest = async () => {
     // Rows naming a class the LONG way (`suggested-action`) are the NativeScript
     // variant spelling — this element has no such attribute. They are partitioned
     // out here rather than skipped inside the loop, and the partition is asserted,
@@ -33,7 +33,7 @@ export const AdwButtonTest = async () => {
     const reachable = BUTTON_STYLE_CLASS_VECTORS.filter((v) => v.names.every((n) => WEB_ATTRIBUTES.has(n)));
     const unreachable = BUTTON_STYLE_CLASS_VECTORS.filter((v) => !v.names.every((n) => WEB_ATTRIBUTES.has(n)));
 
-    await describe('<adw-button> style classes', async () => {
+    await describe('<gtk-button> style classes', async () => {
         for (const { names, classes, rule } of reachable) {
             await it(`[${names.join(', ')}] → [${classes.join(', ')}] — ${rule}`, () => {
                 expect(mountWithStyles(names)).toStrictEqual([...classes]);
@@ -47,7 +47,7 @@ export const AdwButtonTest = async () => {
         });
 
         await it('a style attribute added later is picked up', () => {
-            const el = document.createElement('adw-button');
+            const el = document.createElement('gtk-button');
             el.setAttribute('label', 'Send');
             document.body.appendChild(el);
             el.setAttribute('suggested', '');

package/src/{adw-drop-down.spec.ts → gtk-drop-down.spec.ts}

@@ -1,4 +1,4 @@
-// DOM-level behaviour tests for <adw-drop-down>, in a real browser via the
+// DOM-level behaviour tests for <gtk-drop-down>, in a real browser via the
 // @gjsify/adwaita-web browser test axis.
 //
 // The SELECTION half is driven by the SAME table the NativeScript renderer asserts
@@ -14,21 +14,21 @@ import { describe, it, expect } from '@gjsify/unit';
 import { COMBO_SELECTION_VECTORS } from '@gjsify/adwaita-core/conformance';
 import type { ComboSelectionStep, ComboSelectionVector } from '@gjsify/adwaita-core/conformance';
 
-import type { AdwDropDown } from './elements/adw-drop-down.js';
+import type { GtkDropDown } from './elements/gtk-drop-down.js';
 
-function makeDropDown(): AdwDropDown {
-    const el = document.createElement('adw-drop-down') as AdwDropDown;
+function makeDropDown(): GtkDropDown {
+    const el = document.createElement('gtk-drop-down') as GtkDropDown;
     document.body.appendChild(el);
     return el;
 }
 
 /** The text the closed button shows — the rendered `selectedLabel`. */
-function labelText(dd: AdwDropDown): string {
+function labelText(dd: GtkDropDown): string {
     return dd.querySelector('.adw-drop-down-label')?.textContent ?? '';
 }
 
 /** Open the chooser the way a user does. A no-op over an empty model, as the element guards. */
-function openChooser(dd: AdwDropDown): void {
+function openChooser(dd: GtkDropDown): void {
     (dd.querySelector('.adw-drop-down-button') as HTMLButtonElement).click();
 }
 
@@ -36,7 +36,7 @@ function openChooser(dd: AdwDropDown): void {
  * Replay one vector step against the real element — property sets for the
  * programmatic ops, a popover gesture for the interactive one.
  */
-function applyStep(dd: AdwDropDown, step: ComboSelectionStep): void {
+function applyStep(dd: GtkDropDown, step: ComboSelectionStep): void {
     switch (step.op) {
         case 'setOptions':
             dd.options = step.options;
@@ -78,15 +78,15 @@ function vectorNamed(name: string): ComboSelectionVector {
 }
 
 /** Mount a drop-down and record every `change` detail it dispatches. */
-function mountRecording(): { dd: AdwDropDown; changes: unknown[] } {
+function mountRecording(): { dd: GtkDropDown; changes: unknown[] } {
     const dd = makeDropDown();
     const changes: unknown[] = [];
     dd.addEventListener('change', (event) => changes.push((event as CustomEvent).detail));
     return { dd, changes };
 }
 
-export const AdwDropDownTest = async () => {
-    await describe('adw-drop-down selection (libadwaita conformance vectors)', async () => {
+export const GtkDropDownTest = async () => {
+    await describe('gtk-drop-down selection (libadwaita conformance vectors)', async () => {
         for (const vector of COMBO_SELECTION_VECTORS) {
             if (vector.name === DROP_DOWN_REJECTS) continue;
 
@@ -129,7 +129,7 @@ export const AdwDropDownTest = async () => {
         });
     });
 
-    await describe('adw-drop-down options', async () => {
+    await describe('gtk-drop-down options', async () => {
         await it('accepts a string[] (value === label)', async () => {
             const dd = makeDropDown();
             dd.options = ['One', 'Two', 'Three'];
@@ -152,7 +152,7 @@ export const AdwDropDownTest = async () => {
         });
 
         await it('parses options from the JSON attribute', async () => {
-            const dd = document.createElement('adw-drop-down') as AdwDropDown;
+            const dd = document.createElement('gtk-drop-down') as GtkDropDown;
             dd.setAttribute('options', '[{"value":"x","label":"Ex"},{"value":"y","label":"Why"}]');
             dd.setAttribute('selected', '1');
             document.body.appendChild(dd);
@@ -170,7 +170,7 @@ export const AdwDropDownTest = async () => {
         });
     });
 
-    await describe('adw-drop-down selected ↔ value sync', async () => {
+    await describe('gtk-drop-down selected ↔ value sync', async () => {
         await it('selectedValue setter finds the index by value', async () => {
             const dd = makeDropDown();
             dd.options = [
@@ -205,7 +205,7 @@ export const AdwDropDownTest = async () => {
         await it('setting options + selected before connect does not crash + applies on connect', async () => {
             // The property setters can run BEFORE connectedCallback builds the DOM, where
             // _updateLabel would touch an undefined label element.
-            const dd = document.createElement('adw-drop-down') as AdwDropDown;
+            const dd = document.createElement('gtk-drop-down') as GtkDropDown;
             dd.options = ['a', 'b', 'c'];
             dd.selected = 2;
             expect(dd.isConnected).toBe(false);
@@ -217,7 +217,7 @@ export const AdwDropDownTest = async () => {
         });
     });
 
-    await describe('adw-drop-down notify-on-change', async () => {
+    await describe('gtk-drop-down notify-on-change', async () => {
         await it('a programmatic set fires notify::selected but NOT change (DOM <select> semantics)', async () => {
             const dd = makeDropDown();
             dd.options = ['a', 'b', 'c'];
@@ -259,7 +259,7 @@ export const AdwDropDownTest = async () => {
         });
     });
 
-    await describe('adw-drop-down popover behaviour', async () => {
+    await describe('gtk-drop-down popover behaviour', async () => {
         await it('opens on button click and closes on outside pointerdown', async () => {
             const dd = makeDropDown();
             dd.options = ['a', 'b'];
@@ -286,7 +286,7 @@ export const AdwDropDownTest = async () => {
         });
     });
 
-    await describe('adw-drop-down search', async () => {
+    await describe('gtk-drop-down search', async () => {
         await it('renders a search entry and filters the list', async () => {
             const dd = makeDropDown();
             dd.options = ['Apple', 'Banana', 'Cherry'];

package/src/{adw-entry.spec.ts → gtk-entry.spec.ts}

@@ -1,4 +1,4 @@
-// DOM-level tests for <adw-entry>'s length arithmetic.
+// DOM-level tests for <gtk-entry>'s length arithmetic.
 //
 // The element had NO max length and no text length, while its NativeScript twin has
 // composed `@gjsify/adwaita-core`'s since it shipped — so the same consumer got a
@@ -10,22 +10,22 @@
 import { describe, expect, it } from '@gjsify/unit';
 import { ENTRY_MAX_LENGTH_VECTORS, ENTRY_TEXT_LENGTH_VECTORS } from '@gjsify/adwaita-core/conformance';
 
-import type { AdwEntry } from './elements/adw-entry.js';
+import type { GtkEntry } from './elements/gtk-entry.js';
 
 /** Mount an entry with the given attributes. */
-function mountEntry(attrs: Record<string, string> = {}): AdwEntry {
-    const entry = document.createElement('adw-entry') as AdwEntry;
+function mountEntry(attrs: Record<string, string> = {}): GtkEntry {
+    const entry = document.createElement('gtk-entry') as GtkEntry;
     for (const [name, value] of Object.entries(attrs)) entry.setAttribute(name, value);
     document.body.appendChild(entry);
     return entry;
 }
 
 function unmountAll(): void {
-    for (const entry of Array.from(document.querySelectorAll('adw-entry'))) entry.remove();
+    for (const entry of Array.from(document.querySelectorAll('gtk-entry'))) entry.remove();
 }
 
-export const AdwEntryTest = async () => {
-    await describe('<adw-entry> text length', async () => {
+export const GtkEntryTest = async () => {
+    await describe('<gtk-entry> text length', async () => {
         for (const { text, length, rule } of ENTRY_TEXT_LENGTH_VECTORS) {
             await it(`${JSON.stringify(text)} → ${length} — ${rule}`, () => {
                 const entry = mountEntry();
@@ -36,7 +36,7 @@ export const AdwEntryTest = async () => {
         }
     });
 
-    await describe('<adw-entry> max length', async () => {
+    await describe('<gtk-entry> max length', async () => {
         for (const { text, maxLength, clamped, length, rule } of ENTRY_MAX_LENGTH_VECTORS) {
             await it(`${JSON.stringify(text)} @ ${maxLength} — ${rule}`, () => {
                 const entry = mountEntry({ maxlength: String(maxLength) });