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

package/src/elements/gtk-stack.ts

@@ -93,6 +93,7 @@
 
 import type { DispatchedSignals } from '../signals.js';
 import { STACK_PAGE_ATTRIBUTES, pageChildOf } from './gtk-stack-page.js';
+import { WidgetElement } from '../widget-element.js';
 
 /** `GtkStackTransitionType`, spelled as the GIR's enum nicks (gtkstack.c:95-121). */
 export type StackTransitionType =
@@ -226,7 +227,7 @@ export interface GtkStackPageInfo {
 /** The five `GtkStackPage` string/boolean properties this element reads off a child. */
 const PAGE_ATTRIBUTES = ['name', 'title', 'icon-name', 'use-underline', 'needs-attention'];
 
-export class GtkStack extends HTMLElement {
+export class GtkStack extends WidgetElement {
     /** The GTK signals this element dispatches, each with the DOM event it arrives as (ADR 0093). */
     static readonly signals: DispatchedSignals = {
         'notify::visible-child': 'notify::visible-child',

package/src/elements/gtk-switch.ts

@@ -40,8 +40,9 @@
 // Modifications: Implemented as a Web Component for @gjsify/adwaita-web.
 
 import type { DispatchedSignals } from '../signals.js';
+import { WidgetElement } from '../widget-element.js';
 
-export class GtkSwitch extends HTMLElement {
+export class GtkSwitch extends WidgetElement {
     /** The GTK signals this element dispatches, each with the DOM event it arrives as (ADR 0093). */
     static readonly signals: DispatchedSignals = {
         'notify::active': 'notify::active',

package/src/elements/gtk-text-view.ts

@@ -50,6 +50,7 @@
 import { normalizeLabelJustify, type LabelJustification } from '@gjsify/adwaita-core';
 
 import { JUSTIFY_TEXT_ALIGN } from './justification.js';
+import { WidgetElement } from '../widget-element.js';
 
 /** `Gtk.WrapMode`'s four nicks, in enum order — Pango's enum, and the DEFAULT is `none`. */
 const WRAP_MODES = ['none', 'char', 'word', 'word-char'] as const;
@@ -83,7 +84,7 @@ export interface GtkTextBufferSubset {
     get_text(): string;
 }
 
-export class GtkTextView extends HTMLElement {
+export class GtkTextView extends WidgetElement {
     private _area!: HTMLTextAreaElement;
     private _initialized = false;
 

package/src/elements/gtk-text.ts

@@ -43,8 +43,9 @@
 //   arithmetic composed from @gjsify/adwaita-core.
 
 import { ENTRY_ROW_MAX_LENGTH_LIMIT, clampEntryText, entryTextLength } from '@gjsify/adwaita-core';
+import { WidgetElement } from '../widget-element.js';
 
-export class GtkText extends HTMLElement {
+export class GtkText extends WidgetElement {
     private _input!: HTMLInputElement;
     private _initialized = false;
     private _maxLength = 0;

package/src/elements/gtk-tree-expander.ts

@@ -60,11 +60,12 @@ import {
 
 import { createGtkImage } from './gtk-image.js';
 import { bindSlottedChildren } from '../slotted-children.js';
+import { WidgetElement } from '../widget-element.js';
 
 /** `TIMEOUT_EXPAND` — how long a drag hovers before the row opens (gtktreeexpander.c:717). */
 const TIMEOUT_EXPAND = 500;
 
-export class GtkTreeExpander extends HTMLElement {
+export class GtkTreeExpander extends WidgetElement {
     private _ornaments: HTMLElement[] = [];
     private _expandTimer: ReturnType<typeof setTimeout> | null = null;
     private _initialized = false;

package/src/elements/gtk-video.ts

@@ -65,6 +65,7 @@
 // Reference: refs/libadwaita/src/stylesheet/widgets/_misc.scss:74-81 (the 64/32 osd icon)
 // Copyright (c) The GTK Team. LGPLv2.1+.
 // Modifications: Implemented as a Web Component for @gjsify/adwaita-web.
+import { WidgetElement } from '../widget-element.js';
 
 /** The four overlay glyphs, in the order `update_overlay_icon` tests them (gtkvideo.c:626-646). */
 export type VideoOverlayIcon =
@@ -99,7 +100,7 @@ export const READY_ICON = 'media-playback-start-symbolic';
 /** `gtk_video_reveal_controls`' timeout: 3 s (gtkvideo.c:130). */
 export const CONTROLS_HIDE_MS = 3000;
 
-export class GtkVideo extends HTMLElement {
+export class GtkVideo extends WidgetElement {
     private _initialized = false;
     private _overlayIcon!: HTMLButtonElement;
     private _controlsRevealer!: HTMLDivElement;

package/src/elements/gtk-viewport.ts

@@ -66,6 +66,7 @@
 import { clampAdjustmentValue, normalizeAdjustment, type AdwAdjustment } from '@gjsify/adwaita-core';
 
 import { bindSlottedChildren } from '../slotted-children.js';
+import { WidgetElement } from '../widget-element.js';
 
 /** `viewport_set_adjustment_values`'s two fractions of the visible size. */
 const STEP_FRACTION = 0.1;
@@ -94,7 +95,7 @@ function axisAdjustment(clip: HTMLElement, axis: Axis): AdwAdjustment {
     });
 }
 
-export class GtkViewport extends HTMLElement {
+export class GtkViewport extends WidgetElement {
     private _observer: ResizeObserver | null = null;
     private _watch: MutationObserver | null = null;
 

package/src/elements/gtk-window-controls.ts

@@ -66,6 +66,7 @@
 // Modifications: Implemented as a Web Component for @gjsify/adwaita-web.
 
 import { createGtkImage } from './gtk-image.js';
+import { WidgetElement } from '../widget-element.js';
 
 /** `Gtk.PackType`, spelled as the GIR's enum nicks (gtkwindowcontrols.c:68). */
 type PackSide = 'start' | 'end';
@@ -120,7 +121,7 @@ const WINDOW_ATTRIBUTES = [
 /** `closest` over both window spellings — `Adw.Window` is a `GtkWindow` subclass. */
 const WINDOW_SELECTOR = 'gtk-window, adw-window';
 
-export class GtkWindowControls extends HTMLElement {
+export class GtkWindowControls extends WidgetElement {
     private _initialized = false;
     private _empty = true;
     /** The frame this controls answers to, or `null` outside one (`:257-263`). */

package/src/elements/gtk-window-handle.ts

@@ -47,6 +47,7 @@
 // Modifications: Implemented as a Web Component for @gjsify/adwaita-web.
 
 import { bindSlottedChildren } from '../slotted-children.js';
+import { WidgetElement } from '../widget-element.js';
 
 /** `GtkTitlebarGesture`'s three gestures, as `perform_titlebar_action` decides them. */
 export type GtkTitlebarGesture = 'double-click' | 'middle-click' | 'right-click';
@@ -114,7 +115,7 @@ function gestureOf(button: number, presses: number): GtkTitlebarGesture | null {
  */
 const DRAG_THRESHOLD = 1;
 
-export class GtkWindowHandle extends HTMLElement {
+export class GtkWindowHandle extends WidgetElement {
     /** The gesture in progress, as `priv->drag_start_x` / `_y` are in the C. */
     private _drag: { pointerId: number; x: number; y: number } | null = null;
 

package/src/elements/gtk-window.ts

@@ -108,8 +108,9 @@ import { bindSlottedChildren, type AdwSlot } from '../slotted-children.js';
 import './gtk-window-controls.js';
 import { fillsContainingBlock } from './adw-window-features.js';
 import type { WindowAction } from './gtk-window-controls.js';
+import { WidgetElement } from '../widget-element.js';
 
-export class GtkWindow extends HTMLElement {
+export class GtkWindow extends WidgetElement {
     private _initialized = false;
     /** The `titlebar` strip — `protected` so a subclass can place its own strips around it. */
     protected _titlebar!: HTMLDivElement;

package/src/gio.spec.ts

@@ -1,23 +1,33 @@
-// The `Gio.SimpleActionGroup` door of adwaita-web, held to the shared vectors (real GJS is their
-// oracle, in adwaita-core's `simple-action-group.gjs.spec.ts`). The door is the namespace module itself.
+// The `Gio.SimpleActionGroup` and `Gio.AppInfo` door of adwaita-web, held to the shared vectors (real GJS
+// is their oracle, in adwaita-core's `simple-action-group.gjs.spec.ts` / `gio-app-info.gjs.spec.ts`). The door is the namespace module itself.
 
 import {
+    GIO_APP_INFO_VECTORS,
     SIMPLE_ACTION_GROUP_VECTORS,
+    driveGioAppInfoVectors,
     driveSimpleActionGroupVectors,
     type GioActionsLike,
+    type GioAppInfoSubject,
 } from '@gjsify/adwaita-core/conformance';
 import { describe, expect, it } from '@gjsify/unit';
 
+import * as Gdk from './namespace/gdk.js';
 import * as Gio from './namespace/gio.js';
+import * as GLib from './namespace/glib.js';
 
 export const GioActionsTest = async () => {
     await driveSimpleActionGroupVectors(
         { name: 'adwaita-web', isOracle: false, Gio: Gio as unknown as GioActionsLike },
         { describe, it, expect },
     );
+    await driveGioAppInfoVectors(
+        { name: 'adwaita-web', isOracle: false, display: true, Gio, GLib, Gdk } as unknown as GioAppInfoSubject,
+        { describe, it, expect },
+        GIO_APP_INFO_VECTORS,
+    );
     await describe('adwaita-web: Gio door', async () => {
         await it('has a vector row for every vector', () => {
-            expect(SIMPLE_ACTION_GROUP_VECTORS.length > 0).toBe(true);
+            expect(SIMPLE_ACTION_GROUP_VECTORS.length > 0 && GIO_APP_INFO_VECTORS.length > 0).toBe(true);
         });
     });
 };

package/src/glib.spec.ts

@@ -5,10 +5,13 @@
 import {
     GLIB_PATH_VECTORS,
     GLIB_TIMER_VECTORS,
+    GLIB_URI_VECTORS,
     driveGLibPathVectors,
     driveGLibTimerVectors,
+    driveGLibUriVectors,
     type GLibPathsLike,
     type GLibTimersLike,
+    type GLibUriLike,
 } from '@gjsify/adwaita-core/conformance';
 import { describe, expect, it } from '@gjsify/unit';
 
@@ -36,6 +39,12 @@ export const GLibTest = async () => {
     await driveGLibPathVectors(
         { name: 'adwaita-web', isOracle: false, GLib: GLib as unknown as GLibPathsLike },
         { describe, it, expect },
+        GLIB_PATH_VECTORS,
+    );
+    await driveGLibUriVectors(
+        { name: 'adwaita-web', isOracle: false, GLib: GLib as unknown as GLibUriLike },
+        { describe, it, expect },
+        GLIB_URI_VECTORS,
     );
     await describe('adwaita-web: GLib door', async () => {
         await it('answers the host-bound path questions with the root and no data dirs', () => {

package/src/gobject-elements.ts

@@ -17,6 +17,7 @@
 import { attributeOf, propertyOf } from '@gjsify/adwaita-core/tags';
 
 import { dispatchedSignalsOf } from './signals.js';
+import { watchMapping } from './widget-mapping.js';
 
 type Handler = (emitter: HTMLElement, ...args: unknown[]) => unknown;
 
@@ -60,7 +61,7 @@ function inheritedDescriptor(el: object, member: string): PropertyDescriptor | u
     return undefined;
 }
 
-function notifyElement(el: HTMLElement, name: string): void {
+export function notifyElement(el: HTMLElement, name: string): void {
     const member = propertyOf(name);
     el.dispatchEvent(
         new CustomEvent(eventOf(el, `notify::${name}`), {
@@ -122,7 +123,12 @@ export function listenElement(el: HTMLElement, signal: string, handler: Handler)
         }
     };
     el.addEventListener(event, listener);
-    return () => el.removeEventListener(event, listener);
+    // `map` / `unmap` have no DOM event behind them: the element is watched while one is connected.
+    const unwatch = signal === 'map' || signal === 'unmap' ? watchMapping(el) : undefined;
+    return () => {
+        el.removeEventListener(event, listener);
+        unwatch?.();
+    };
 }
 
 export function dispatchElement(el: HTMLElement, signal: string, args: readonly unknown[]): void {
@@ -156,9 +162,17 @@ export function installSensitive(el: HTMLElement): void {
 
 const VISIBLE_INSTALLED = new WeakSet<Element>();
 
-/** Whether `installVisible` gave `el` its `visible` (an element with its own keeps its own). */
+/** The `visible` getters `WidgetElement` puts on its prototype, so a class's own accessor tells apart. */
+export const WIDGET_VISIBLE_GETTERS = new WeakSet<() => boolean>();
+
+/**
+ * Whether `el` has the port's `visible` — from `installVisible` or from `WidgetElement`. An
+ * element with its own `visible` (`<gtk-stack-page>`) keeps its own and answers false.
+ */
 export function hasInstalledVisible(el: Element): boolean {
-    return VISIBLE_INSTALLED.has(el);
+    if (VISIBLE_INSTALLED.has(el)) return true;
+    const getter = inheritedDescriptor(el, 'visible')?.get;
+    return getter !== undefined && WIDGET_VISIBLE_GETTERS.has(getter as () => boolean);
 }
 
 /**

package/src/gtk-label.spec.ts

@@ -325,6 +325,45 @@ export const GtkLabelTest = async () => {
             host.remove();
         });
 
+        // GtkLabel's wrapping MINIMUM is its longest word, not the width it first wrapped
+        // at. A pinned `width` made the measured block the label's min-content, so a card
+        // around it in a narrower pane (Learn6502's preferences: 343px) grew past the pane.
+        await it('lets a wrapped label shrink below the width it first wrapped at', () => {
+            const long = 'word '.repeat(60).trim();
+            const { el, host } = mount(long);
+            host.style.display = 'flex';
+            const card = document.createElement('div');
+            host.appendChild(card);
+            card.appendChild(el);
+            el.wrap = true;
+            const first = el.querySelector('.adw-label-text')!.getBoundingClientRect().width;
+            expect(first > 300).toBe(true);
+            host.style.width = '200px';
+            expect(card.getBoundingClientRect().width <= 200).toBe(true);
+            expect(el.getBoundingClientRect().width <= 200).toBe(true);
+            host.remove();
+        });
+
+        // gtk_label_measure: a wrapping label's minimum is its widest word, its natural
+        // width the text on one line (capped only by `max-width-chars`).
+        await it('gives a wrapped label its widest word as minimum, one line as natural', () => {
+            const long = 'word '.repeat(60).trim();
+            const { el, host } = mount(long);
+            el.wrap = true;
+            const word = mount('word');
+            const wordWidth = textRect(word.el).width;
+            word.host.remove();
+            const line = mount(long);
+            line.host.style.width = 'max-content';
+            const lineWidth = textRect(line.el).width;
+            line.host.remove();
+            host.style.width = 'min-content';
+            expect(el.getBoundingClientRect().width <= Math.ceil(wordWidth) + 1).toBe(true);
+            host.style.width = 'max-content';
+            expect(Math.abs(el.getBoundingClientRect().width - lineWidth) <= 1).toBe(true);
+            host.remove();
+        });
+
         await it('is not selectable unless asked, as GtkLabel', () => {
             const { el, host } = mount('Hi');
             expect(getComputedStyle(el).userSelect).toBe('none');

package/src/gtk-scrolled-window.spec.ts

@@ -216,24 +216,24 @@ export const GtkScrolledWindowTest = async () => {
             await fill(el, 10);
             // No request is made until one of the two asks for it: GTK only measures the
             // child when `propagate-natural-*` or a NEVER policy does (gtkscrolledwindow.c:1841-1844).
-            expect(el.viewport.style.minHeight).toBe('');
+            expect(el.viewport.style.height).toBe('');
             // The NATURAL request is the child's `max-content` size, propagated up.
             el.setAttribute('propagate-natural-height', '');
             expect(el.propagateNaturalHeight).toBe(true);
-            expect(el.viewport.style.minHeight).toBe('max-content');
+            expect(el.viewport.style.height).toBe('max-content');
             // A NEVER policy adds the child's MINIMUM request instead — and the natural one
             // is the larger of the two, so it wins when both are asked for. Both are FALSE in
             // the pspec, so their ATTRIBUTE is their presence, as `has-frame` is.
             el.removeAttribute('propagate-natural-height');
             el.setAttribute('vscrollbar-policy', 'never');
-            expect(el.viewport.style.minHeight).toBe('min-content');
+            expect(el.viewport.style.height).toBe('min-content');
             // With both asked for on ONE axis the natural wins, and the other axis keeps
             // its own answer.
             el.setAttribute('propagate-natural-width', '');
-            expect(el.viewport.style.minWidth).toBe('max-content');
-            expect(el.viewport.style.minHeight).toBe('min-content');
+            expect(el.viewport.style.width).toBe('max-content');
+            expect(el.viewport.style.height).toBe('min-content');
             el.setAttribute('propagate-natural-height', '');
-            expect(el.viewport.style.minHeight).toBe('max-content');
+            expect(el.viewport.style.height).toBe('max-content');
             host.remove();
         });
     });

package/src/gtk-value-doors.spec.ts

@@ -20,8 +20,15 @@
 import { describe, it, expect } from '@gjsify/unit';
 
 import { GtkAdjustment, GtkStringList } from '@gjsify/adwaita-core';
+import {
+    ROW_ACCESSOR_VECTORS,
+    driveRowAccessorVectors,
+    type ComboRowLike,
+    type SwitchRowLike,
+} from '@gjsify/adwaita-core/conformance';
 
 import type { AdwComboRow } from './elements/adw-combo-row.js';
+import type { AdwSwitchRow } from './elements/adw-switch-row.js';
 import type { AdwSpinRow } from './elements/adw-spin-row.js';
 import type { GtkDropDown } from './elements/gtk-drop-down.js';
 
@@ -101,4 +108,16 @@ export const GtkValueDoorsTest = async () => {
             expect(row.value).toBe(16);
         });
     });
+
+    await driveRowAccessorVectors(
+        {
+            name: 'adwaita-web',
+            isOracle: false,
+            makeComboRow: () => mount<AdwComboRow>('adw-combo-row') as unknown as ComboRowLike,
+            makeSwitchRow: () => mount<AdwSwitchRow>('adw-switch-row') as unknown as SwitchRowLike,
+            StringList: GtkStringList,
+        },
+        { describe, it, expect },
+        ROW_ACCESSOR_VECTORS,
+    );
 };

package/src/gtk-window.spec.ts

@@ -310,11 +310,11 @@ export const GtkWindowTest = async () => {
             const { el, host } = mount();
             let message = '';
             try {
-                el.connect('map', () => {});
+                el.connect('toggled', () => {});
             } catch (error) {
                 message = (error as Error).message;
             }
-            expect(message.includes("'map'")).toBe(true);
+            expect(message.includes("'toggled'")).toBe(true);
             host.remove();
         });
 

package/src/gtksource/gtk-source-view.ts

@@ -20,6 +20,7 @@ import type { Buffer, Gutter } from '@gjsify/gtksource-core';
 import { EditorSession, GutterSet, STOP_EMISSION, toBoolean, toNumber } from '@gjsify/gtksource-core';
 
 import { WebEditorDriver } from './web-editor-driver.js';
+import { WidgetElement } from '../widget-element.js';
 
 const STYLE_ID = 'gjsify-gtk-source-view-style';
 
@@ -130,7 +131,7 @@ const OBSERVED_ATTRIBUTES = [
     'bottom-margin',
 ];
 
-export class GtkSourceView extends HTMLElement {
+export class GtkSourceView extends WidgetElement {
     static get observedAttributes(): string[] {
         return OBSERVED_ATTRIBUTES;
     }

package/src/{icon-registry.spec.ts → icon-masks.spec.ts}

@@ -14,17 +14,12 @@
 // that was never given draws nothing at all.
 import { describe, expect, it } from '@gjsify/unit';
 
-import { isIconAvailable, registerIcon } from './icon-registry.js';
+import { isIconAvailable } from './icon-theme.js';
 import type { GtkImage } from './elements/gtk-image.js';
 
 /** A name no compiled entry can collide with, for the "not shipped" arm. */
 const ABSENT = 'gjsify-registry-probe';
 
-/** An Adwaita symbolic SVG, small and distinctive — a filled 8px square in the 16px grid. */
-const PROBE_SVG = `<svg height="16px" viewBox="0 0 16 16" width="16px" xmlns="http://www.w3.org/2000/svg">
-    <path d="m 4 4 h 8 v 8 h -8 z m 0 0" fill="currentColor"/>
-</svg>`;
-
 function mount(iconName: string | null): { el: GtkImage; host: HTMLElement } {
     const host = document.createElement('div');
     document.body.appendChild(host);
@@ -55,7 +50,7 @@ export function fallbackMask(): string {
     return getComputedStyle(document.documentElement).getPropertyValue('--icon-image-missing').trim();
 }
 
-export const AdwIconRegistryTest = async () => {
+export const AdwIconMasksTest = async () => {
     await describe('<gtk-image> resolves a name to a real mask', async () => {
         await it('a compiled name draws its OWN glyph, not the fallback', () => {
             const { el, host } = mount('go-next');
@@ -136,8 +131,8 @@ export const AdwIconRegistryTest = async () => {
         });
     });
 
-    await describe('registerIcon — the documented way out of the compiled set', async () => {
-        await it('reports an unshipped name as unavailable before registration', () => {
+    await describe('isIconAvailable', async () => {
+        await it('answers for the compiled set and nothing else', () => {
             expect(isIconAvailable(ABSENT)).toBe(false);
             // …and a compiled one as available, so the check is not answering `false` to
             // everything. `image-missing` is the case a fallback-comparison would get wrong.
@@ -145,96 +140,5 @@ export const AdwIconRegistryTest = async () => {
             expect(isIconAvailable('image-missing')).toBe(true);
             expect(isIconAvailable('')).toBe(false);
         });
-
-        await it('makes the name resolve, on an element that is ALREADY mounted', () => {
-            const { el, host } = mount(ABSENT);
-            const before = maskOf(el);
-            expect(before).toBe(fallbackMask());
-
-            registerIcon(ABSENT, PROBE_SVG);
-
-            const after = maskOf(el);
-            expect(after).not.toBe(before);
-            expect(after).not.toBe(fallbackMask());
-            // The glyph really is the SVG that was handed over: `toDataUri` percent-encodes
-            // it, so the path data survives as `m%204%204`.
-            expect(after.includes('m%204%204')).toBe(true);
-            expect(isIconAvailable(ABSENT)).toBe(true);
-            host.remove();
-        });
-
-        await it('serves an element mounted AFTER the registration too', () => {
-            const { el, host } = mount(`${ABSENT}-symbolic`);
-            // The `-symbolic` suffix is stripped on both sides, so a consumer may spell the
-            // name either way at either end.
-            expect(el.resolvedIconName).toBe(ABSENT);
-            expect(maskOf(el).includes('m%204%204')).toBe(true);
-            host.remove();
-        });
-
-        await it('re-registering REPLACES the glyph without a second rule', () => {
-            const sheet = (document.getElementById('adwaita-web-icon-registry') as HTMLStyleElement).sheet;
-            const rulesBefore = (sheet as CSSStyleSheet).cssRules.length;
-
-            registerIcon(ABSENT, PROBE_SVG.replace('m 4 4 h 8 v 8 h -8 z', 'm 2 2 h 12 v 12 h -12 z'));
-
-            const { el, host } = mount(ABSENT);
-            expect(maskOf(el).includes('m%202%202')).toBe(true);
-            expect((sheet as CSSStyleSheet).cssRules.length).toBe(rulesBefore);
-            host.remove();
-        });
-
-        await it('throws on a name that could never be one CSS class', () => {
-            // Silently registering nothing is the exact failure this area exists to end, and
-            // unlike a render this is an explicit call with a wrong argument.
-            expect(() => registerIcon('org.gnome.Builder', PROBE_SVG)).toThrow();
-            expect(() => registerIcon('a b', PROBE_SVG)).toThrow();
-            expect(() => registerIcon('', PROBE_SVG)).toThrow();
-        });
-
-        await it('throws on a payload that is not SVG source, and registers nothing', () => {
-            // The NAME was checked from the start; the payload was not, and a wrong payload
-            // is worse than no registration at all: `toDataUri` percent-encodes anything, so
-            // the mask comes out well-formed and masks NOTHING, the registered class beats
-            // `:where(.adw-icon)` and switches this PR's fallback off, and `isIconAvailable`
-            // answers `true`. Measured in Firefox before the guard: `'not an svg at all'`
-            // gave `url("data:image/svg+xml,not%20an%20svg%20at%20all")` on a box painted 0 %,
-            // where the unregistered control painted the 30 % image-missing glyph.
-            const REJECTED = 'gjsify-registry-payload-probe';
-            expect(() => registerIcon(REJECTED, 'not an svg at all')).toThrow();
-            expect(() => registerIcon(REJECTED, '')).toThrow();
-            // The likeliest wrong argument of all: what the custom property HOLDS, handed
-            // over instead of what it was made from.
-            expect(() => registerIcon(REJECTED, 'url("data:image/svg+xml,%3Csvg%3E%3C/svg%3E")')).toThrow();
-            expect(isIconAvailable(REJECTED)).toBe(false);
-
-            const { el, host } = mount(REJECTED);
-            expect(maskOf(el)).toBe(fallbackMask());
-            host.remove();
-        });
-
-        await it('rebuilds its rules after the <style> element is taken away', () => {
-            // What an SPA head swap or an Astro view transition does. The record of inserted
-            // rules is module-level and outlives the element it describes, so the early
-            // return above used to skip the insert forever: the custom property was re-set
-            // and the rule that consumes it never came back.
-            const LOST = 'gjsify-registry-sheet-probe';
-            registerIcon(LOST, PROBE_SVG);
-            document.getElementById('adwaita-web-icon-registry')?.remove();
-
-            registerIcon(LOST, PROBE_SVG);
-
-            expect(document.getElementById('adwaita-web-icon-registry')).not.toBe(null);
-            const { el, host } = mount(LOST);
-            expect(maskOf(el).includes('m%204%204')).toBe(true);
-            host.remove();
-
-            // …and the names registered BEFORE the swap are on the rebuilt sheet too. Their
-            // custom properties survived on the document element, so re-issuing only the
-            // one name being registered would leave every earlier icon on the fallback.
-            const { el: earlier, host: earlierHost } = mount(ABSENT);
-            expect(maskOf(earlier)).not.toBe(fallbackMask());
-            earlierHost.remove();
-        });
     });
 };