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

package/src/icon-theme.spec.ts

@@ -1,30 +1,38 @@
 // The colour half of the icon theme, measured through `getComputedStyle` like
-// `icon-registry.spec.ts` measures the symbolic half: a class on the node proves nothing
+// `icon-masks.spec.ts` measures the symbolic half: a class on the node proves nothing
 // about what it paints.
 //
 // The order under test is GLib's (`g_themed_icon_update_names`, which `GtkImage`'s lookup
 // goes through): `X` tries [X, X-symbolic], `X-symbolic` tries [X-symbolic, X], and a name
 // neither answers draws `image-missing`. Over the names the order is gtkicontheme.c's: the
-// current theme (the stylesheet's glyphs) before hicolor, where a colour registration sits.
-// The registry is module-level and outlives a test,
-// so every case registers names of its own.
+// current theme (the stylesheet's glyphs) before hicolor, where an app's resource files sit.
+// Colour icons come from the shared GResource fixture, on the theme's resource path as
+// `GtkApplication` adds `<resource-base-path>/icons/` (ADR 0116 § 4).
+import { ICON_FIXTURE_PATH, gioResourceFixtures } from '@gjsify/adwaita-core/conformance';
 import { describe, expect, it } from '@gjsify/unit';
 
 import { COLOR_ICON_CLASS, type GtkImage } from './elements/gtk-image.js';
-import { fallbackMask, maskOf } from './icon-registry.spec.js';
-import { isIconAvailable, registerIcon } from './icon-registry.js';
-import { registerColorIcon } from './icon-theme.js';
-
-/** A full-colour app icon: a red square on a blue disc, nothing `currentColor` about it. */
-const COLOR_SVG = `<svg height="128" viewBox="0 0 128 128" width="128" xmlns="http://www.w3.org/2000/svg">
-    <circle cx="64" cy="64" r="60" fill="#3584e4"/>
-    <rect x="40" y="40" width="48" height="48" fill="#e01b24"/>
-</svg>`;
-
-/** A symbolic glyph, distinct from the colour one by its path data. */
-const SYMBOLIC_SVG = `<svg height="16px" viewBox="0 0 16 16" width="16px" xmlns="http://www.w3.org/2000/svg">
-    <path d="m 3 3 h 10 v 10 h -10 z m 0 0" fill="currentColor"/>
-</svg>`;
+import { fallbackMask, maskOf } from './icon-masks.spec.js';
+import { isIconAvailable } from './icon-theme.js';
+import { Gio, Gtk } from './index.js';
+
+const theme = Gtk.IconTheme.get_for_display(null);
+
+/** Runs `body` with the fixture's icons on the theme's resource path. */
+async function withIcons(body: () => void): Promise<void> {
+    const resource = Gio.Resource.new_from_data(gioResourceFixtures().icons);
+    Gio.resources_register(resource);
+    const before = theme.get_resource_path();
+    theme.add_resource_path(ICON_FIXTURE_PATH);
+    // `changed` is deferred: let it drop the previous scan's URLs first.
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    try {
+        body();
+    } finally {
+        theme.set_resource_path(before);
+        Gio.resources_unregister(resource);
+    }
+}
 
 function mount(iconName: string): { el: GtkImage; host: HTMLElement } {
     const host = document.createElement('div');
@@ -40,7 +48,7 @@ function maskClasses(el: HTMLElement): string[] {
     return [...el.classList].filter((c) => c.startsWith('adw-icon--'));
 }
 
-/** True when `el` paints the registered colour image and nothing masked. */
+/** True when `el` paints a resource image as-is and nothing masked. */
 function drawsInColor(el: HTMLElement): boolean {
     const style = getComputedStyle(el);
     return (
@@ -48,66 +56,41 @@ function drawsInColor(el: HTMLElement): boolean {
         maskClasses(el).length === 0 &&
         style.maskImage === 'none' &&
         style.backgroundColor === 'rgba(0, 0, 0, 0)' &&
-        // `#e01b24` survives `toDataUri` as `%23e01b24`.
-        style.backgroundImage.includes('%23e01b24')
+        style.backgroundImage.startsWith('url("blob:')
     );
 }
 
 export const AdwIconThemeTest = async () => {
-    await describe('registerColorIcon — a full-colour icon draws as-is', async () => {
-        await it('a reverse-DNS application id draws its image, unmasked and unfilled', () => {
-            const APP_ID = 'org.gjsify.ColorProbe';
-            registerColorIcon(APP_ID, COLOR_SVG);
-
-            const { el, host } = mount(APP_ID);
-            expect(drawsInColor(el)).toBe(true);
-            expect(isIconAvailable(APP_ID)).toBe(true);
-            host.remove();
-        });
-
-        await it('an already-mounted element redraws when the registration lands', () => {
-            const APP_ID = 'org.gjsify.LateColorProbe';
-            const { el, host } = mount(APP_ID);
-            // Before: what GTK draws for a name its theme does not have.
-            expect(maskOf(el)).toBe(fallbackMask());
-
-            registerColorIcon(APP_ID, COLOR_SVG);
-            expect(drawsInColor(el)).toBe(true);
-            host.remove();
-        });
-
-        await it("AdwAboutDialog's application-icon draws in colour", () => {
-            const APP_ID = 'org.gjsify.AboutColorProbe';
-            registerColorIcon(APP_ID, COLOR_SVG);
-
-            const host = document.createElement('div');
-            document.body.appendChild(host);
-            const dialog = document.createElement('adw-about-dialog');
-            dialog.setAttribute('application-icon', APP_ID);
-            host.appendChild(dialog);
-
-            const icon = dialog.querySelector('.adw-about-dialog-icon') as HTMLElement;
-            expect(drawsInColor(icon)).toBe(true);
-            // The 96px box, and NOT a solid square under the image: the about dialog used to
-            // force `background-color: currentColor` on it.
-            expect(getComputedStyle(icon).width).toBe('96px');
-            host.remove();
+    await describe('a full-colour resource icon draws as-is', async () => {
+        await it('draws its image, unmasked and unfilled', async () => {
+            await withIcons(() => {
+                const { el, host } = mount('flat');
+                expect(drawsInColor(el)).toBe(true);
+                expect(isIconAvailable('flat')).toBe(true);
+                host.remove();
+            });
         });
 
-        await it('a URL source resolves against the document', () => {
-            const APP_ID = 'org.gjsify.UrlColorProbe';
-            registerColorIcon(APP_ID, 'icons/org.gjsify.UrlColorProbe.svg');
-
-            const { el, host } = mount(APP_ID);
-            const expected = new URL('icons/org.gjsify.UrlColorProbe.svg', document.baseURI).href;
-            expect(el.classList.contains(COLOR_ICON_CLASS)).toBe(true);
-            expect(getComputedStyle(el).backgroundImage).toBe(`url("${expected}")`);
-            host.remove();
+        await it("AdwAboutDialog's application-icon draws in colour", async () => {
+            await withIcons(() => {
+                const host = document.createElement('div');
+                document.body.appendChild(host);
+                const dialog = document.createElement('adw-about-dialog');
+                dialog.setAttribute('application-icon', 'flat');
+                host.appendChild(dialog);
+
+                const icon = dialog.querySelector('.adw-about-dialog-icon') as HTMLElement;
+                expect(drawsInColor(icon)).toBe(true);
+                // The 96px box, and NOT a solid square under the image: the about dialog used to
+                // force `background-color: currentColor` on it.
+                expect(getComputedStyle(icon).width).toBe('96px');
+                host.remove();
+            });
         });
     });
 
     await describe('the lookup order is GThemedIcon’s', async () => {
-        await it('a symbolic icon still masks — a compiled one with no colour entry', () => {
+        await it('a symbolic icon still masks — a compiled one with no resource', () => {
             const { el, host } = mount('go-next-symbolic');
             expect(el.classList.contains(COLOR_ICON_CLASS)).toBe(false);
             expect(maskClasses(el)).toStrictEqual(['adw-icon--go-next']);
@@ -116,41 +99,28 @@ export const AdwIconThemeTest = async () => {
             host.remove();
         });
 
-        await it("the theme's X-symbolic answers X and X-symbolic before the colour X, as on GTK", () => {
-            const NAME = 'gjsify-theme-both-probe';
-            registerColorIcon(NAME, COLOR_SVG);
-            registerIcon(`${NAME}-symbolic`, SYMBOLIC_SVG);
-
-            // gtkicontheme.c `real_choose_icon`: theme outer, name inner, and the colour icon is
-            // hicolor's, so the current theme's `X-symbolic` comes first (ADR 0115 Amendment 2).
-            const plain = mount(NAME);
-            expect(plain.el.classList.contains(COLOR_ICON_CLASS)).toBe(false);
-            expect(maskOf(plain.el).includes('m%203%203')).toBe(true);
-            plain.host.remove();
-
-            const symbolic = mount(`${NAME}-symbolic`);
-            expect(symbolic.el.classList.contains(COLOR_ICON_CLASS)).toBe(false);
-            expect(maskOf(symbolic.el).includes('m%203%203')).toBe(true);
-            expect(getComputedStyle(symbolic.el).backgroundImage).toBe('none');
-            symbolic.host.remove();
+        await it("the theme's X-symbolic answers X before a resource's colour X, as on GTK", async () => {
+            // The fixture ships a colour `16x16/actions/go-next.png`; gtkicontheme.c
+            // `real_choose_icon` goes theme outer, name inner, and the file is hicolor's.
+            await withIcons(() => {
+                const { el, host } = mount('go-next');
+                expect(el.classList.contains(COLOR_ICON_CLASS)).toBe(false);
+                expect(maskClasses(el)).toStrictEqual(['adw-icon--go-next']);
+                host.remove();
+            });
         });
 
-        await it('X-symbolic falls back to the colour X, and back again once X-symbolic lands', () => {
-            const NAME = 'gjsify-theme-fallback-probe';
-            registerColorIcon(NAME, COLOR_SVG);
-
-            const { el, host } = mount(`${NAME}-symbolic`);
-            expect(drawsInColor(el)).toBe(true);
-            expect(isIconAvailable(`${NAME}-symbolic`)).toBe(true);
-
-            registerIcon(NAME, SYMBOLIC_SVG);
-            expect(el.classList.contains(COLOR_ICON_CLASS)).toBe(false);
-            expect(maskOf(el).includes('m%203%203')).toBe(true);
-            host.remove();
+        await it('X-symbolic falls back to the colour X', async () => {
+            await withIcons(() => {
+                const { el, host } = mount('flat-symbolic');
+                expect(drawsInColor(el)).toBe(true);
+                expect(isIconAvailable('flat-symbolic')).toBe(true);
+                host.remove();
+            });
         });
 
         await it('an unknown name draws image-missing', () => {
-            for (const unknown of ['org.gjsify.NeverRegistered', 'gjsify-theme-never-registered']) {
+            for (const unknown of ['org.gjsify.NeverShipped', 'gjsify-theme-never-shipped', 'flat']) {
                 const { el, host } = mount(unknown);
                 expect(el.classList.contains(COLOR_ICON_CLASS)).toBe(false);
                 expect(maskOf(el)).toBe(fallbackMask());
@@ -159,29 +129,4 @@ export const AdwIconThemeTest = async () => {
             }
         });
     });
-
-    await describe('registerColorIcon rejects what it cannot draw faithfully', async () => {
-        await it('throws on a name that is empty, spaced, or symbolic', () => {
-            expect(() => registerColorIcon('', COLOR_SVG)).toThrow();
-            expect(() => registerColorIcon('a b', COLOR_SVG)).toThrow();
-            // The symbolic half has its own door; GTK's theme treats all three suffixes as
-            // symbolic files.
-            expect(() => registerColorIcon('gjsify-probe-symbolic', COLOR_SVG)).toThrow();
-            expect(() => registerColorIcon('gjsify-probe-symbolic-ltr', COLOR_SVG)).toThrow();
-            expect(() => registerColorIcon('gjsify-probe-symbolic-rtl', COLOR_SVG)).toThrow();
-        });
-
-        await it('throws on a source that is not SVG or an image URL, and registers nothing', () => {
-            const REJECTED = 'org.gjsify.RejectedColorProbe';
-            expect(() => registerColorIcon(REJECTED, '')).toThrow();
-            expect(() => registerColorIcon(REJECTED, '<p>not svg</p>')).toThrow();
-            expect(() => registerColorIcon(REJECTED, 'javascript:alert(1)')).toThrow();
-            expect(() => registerColorIcon(REJECTED, 'data:text/html,<svg></svg>')).toThrow();
-            expect(isIconAvailable(REJECTED)).toBe(false);
-
-            const { el, host } = mount(REJECTED);
-            expect(maskOf(el)).toBe(fallbackMask());
-            host.remove();
-        });
-    });
 };

package/src/icon-theme.ts

@@ -13,25 +13,18 @@
 // and `gtk_icon_theme_lookup_icon` returns the first candidate the theme has, else
 // `image-missing` — it never returns NULL (refs/gtk/gtk/gtkicontheme.c, `choose_icon`).
 //
-// This package compiles and registers symbolic glyphs only (`icon-registry.ts`, the
-// stylesheet's `.adw-icon--<name>` masks). The colour half lives here: a map from an EXACT
-// name to an image URL, filled by {@link registerColorIcon}. With the map empty every lookup
-// ends where it ended before this module existed, so nothing that only uses symbolic icons
-// changes.
-//
-// The colour map is keyed by the raw name, not by `normalizeIconName`: an application icon
-// is named after its application ID (`org.gnome.Builder`, adw-about-dialog.c:1215), which is
-// not a CSS token and never could be a mask class, but is a perfectly good Map key.
+// The stylesheet compiles a SUBSET of Adwaita's symbolic glyphs (the `.adw-icon--<name>`
+// masks); that subset is the port's current theme. Everything else — an application's own
+// symbolic glyphs and its full-colour icons alike — comes from GResource files.
 //
 // RESOURCE PATHS (ADR 0116 § 4). The names go through the `Gtk.IconTheme` resource paths an
 // application added (`GtkApplication` adds `<resource-base-path>/icons/` at startup);
 // `@gjsify/adwaita-core`'s `lookupResourceIcon` decides which file answers, as gtkicontheme.c
-// does, and asks this module only whether the stylesheet holds a symbolic glyph. A colour
-// registration stands in hicolor there, as the file an app ships in `hicolor/scalable/apps/`
-// would: the stylesheet's `X-symbolic` answers `X` before it, as Adwaita's does on GNOME. A file
-// answers as a blob URL of its bytes: a symbolic one is drawn as a mask in `currentColor`, the
-// rest as-is. A browser draws SVG and PNG; an XPM or a compressed entry draws `image-missing`
-// with a warning.
+// does, and asks this module only whether the stylesheet holds a symbolic glyph: the
+// stylesheet's `X-symbolic` answers `X` before a resource's colour `X`, as Adwaita's does on
+// GNOME. A file answers as a blob URL of its bytes: a symbolic one is drawn as a mask in
+// `currentColor`, the rest as-is. A browser draws SVG and PNG; an XPM or a compressed entry
+// draws `image-missing` with a warning.
 //
 // Original implementation.
 
@@ -42,14 +35,11 @@ import {
     resources_lookup_data,
     type IconDirection,
 } from '@gjsify/adwaita-core';
-import { toDataUri } from '@gjsify/adwaita-icons/utils';
 
 import { IconTheme } from './namespace/gtk-platform.js';
 
 /** What one icon name resolves to, in the order GTK's theme would try it. */
 export type IconLookup =
-    /** A registered full-colour image, drawn as-is. `url` is ready for `url("…")`. */
-    | { kind: 'color'; name: string; url: string }
     /**
      * A file under a `Gtk.IconTheme` resource path; `symbolic` files are masks in `currentColor`.
      * `url` is `null` when the browser cannot draw the file (XPM, compressed): draw `image-missing`.
@@ -61,21 +51,9 @@ export type IconLookup =
     | { kind: 'missing' };
 
 /**
- * Every name GTK's theme treats as a symbolic FILE (gtkicontheme.c `icon_name_is_symbolic`):
- * the directional variants are symbolic too, so none of them is a colour icon.
- */
-const SYMBOLIC_FILE_NAME = /-symbolic(?:-ltr|-rtl)?$/;
-
-/** Schemes a colour icon may be fetched from. Anything else can run script or is unknown. */
-const ALLOWED_PROTOCOLS = new Set(['http:', 'https:', 'blob:', 'file:']);
-
-const colorIcons = new Map<string, string>();
-
-/**
- * Elements that drew a lookup result and have to redraw when the theme changes. A symbolic
- * registration is live through CSS and needs no redraw, but a colour one is an inline
- * `background-image`, and GTK's own images re-run their lookup on the theme's `changed`
- * signal for the same reason.
+ * Elements that drew a lookup result and have to redraw when the theme changes. A resource
+ * file is an inline `background-image` or mask, and GTK's own images re-run their lookup on
+ * the theme's `changed` signal for the same reason.
  */
 const listeners = new Set<() => void>();
 
@@ -87,11 +65,6 @@ export function onIconThemeChanged(listener: () => void): () => void {
     };
 }
 
-/** Run every subscriber — after any registration that can change a lookup's answer. */
-export function notifyIconThemeChanged(): void {
-    for (const listener of listeners) listener();
-}
-
 /** Whether a symbolic glyph for an already-normalized name is in the cascade. */
 function hasSymbolic(normalized: string): boolean {
     if (normalized === '') return false;
@@ -102,11 +75,9 @@ function hasSymbolic(normalized: string): boolean {
  * Resolve `iconName` as `gtk_icon_theme_lookup_by_gicon` would for a `GtkImage`. `null` when
  * no name was given — the state where GTK draws nothing, not `image-missing`.
  *
- * When neither a colour registration nor a resource holds a name, the request is returned as a
- * symbolic one WITHOUT checking the cascade: the mask class falls back to `image-missing`
- * through CSS by itself and corrects itself when a later `registerIcon` lands, which is how
- * `<gtk-image>` behaved before this module. The cascade is read only to choose between a
- * symbolic glyph and a colour entry or file.
+ * When no resource holds a name, the request is returned as a symbolic one WITHOUT checking
+ * the cascade: the mask class falls back to `image-missing` through CSS by itself. The cascade
+ * is read only to choose between a symbolic glyph and a resource file.
  */
 export function lookupIcon(iconName: string | null | undefined, request: IconRequest = {}): IconLookup | null {
     if (iconName === null || iconName === undefined || iconName === '') return null;
@@ -133,7 +104,7 @@ const resourceUrls = new Map<string, string | null>();
 theme.connect('changed', () => {
     for (const url of resourceUrls.values()) if (url !== null) URL.revokeObjectURL(url);
     resourceUrls.clear();
-    notifyIconThemeChanged();
+    for (const listener of listeners) listener();
 });
 
 const RESOURCE_TYPES: Record<string, string> = { '.svg': 'image/svg+xml', '.png': 'image/png' };
@@ -159,8 +130,8 @@ function resourceUrl(path: string): string | null {
 }
 
 /**
- * The lookup over the colour registrations and the theme's resource paths; `null` when neither
- * answers any name, a `symbolic` entry when the current theme's glyph comes first.
+ * The lookup over the theme's resource paths; `null` when no resource answers any name, a
+ * `symbolic` entry when the current theme's glyph comes first.
  */
 export function resourceIcon(iconName: string, request: IconRequest): IconLookup | null {
     const match = lookupResourceIcon(theme, {
@@ -170,11 +141,9 @@ export function resourceIcon(iconName: string, request: IconRequest): IconLookup
         },
         scale: request.scale ?? 1,
         themeHas: (name) => hasSymbolic(normalizeIconName(name)),
-        hicolorHas: (name) => colorIcons.has(name),
     });
     if (match === null) return null;
     if (match.kind === 'theme') return { kind: 'symbolic', name: normalizeIconName(match.name) };
-    if (match.kind === 'hicolor') return { kind: 'color', name: match.name, url: colorIcons.get(match.name)! };
     return {
         kind: 'resource',
         name: match.name,
@@ -185,78 +154,19 @@ export function resourceIcon(iconName: string, request: IconRequest): IconLookup
 }
 
 /**
- * Whether `iconName` resolves to something other than `image-missing` — a registered colour
- * icon, a file under a resource path, or a symbolic glyph compiled into the stylesheet or
- * registered at runtime.
+ * Whether `name` draws something other than `image-missing` — a file under a `Gtk.IconTheme`
+ * resource path, or a symbolic glyph compiled into the stylesheet. The name is looked up
+ * exactly as `<gtk-image icon-name>` looks it up.
+ *
+ * Reads the live cascade rather than a generated list, so it answers for a glyph that arrived
+ * by any route, including a consumer's own `--icon-<name>` declaration. It is deliberately the
+ * CUSTOM PROPERTY that is read and not the rendered `mask-image` of a probe element: since
+ * `_icon.scss` gives every icon box the `image-missing` fallback, a rendered mask is never
+ * `none`, and comparing against the fallback would answer `false` for `image-missing` itself.
  */
-export function iconResolves(iconName: string): boolean {
-    const found = lookupIcon(iconName);
+export function isIconAvailable(name: string): boolean {
+    const found = lookupIcon(name);
     if (found === null || found.kind === 'missing') return false;
     if (found.kind === 'resource') return found.url !== null;
-    return found.kind === 'color' || hasSymbolic(found.name);
-}
-
-/** `source` as a URL `background-image` can load, or a thrown reason why not. */
-function colorIconUrl(name: string, source: string): string {
-    if (source.trimStart().startsWith('<')) {
-        const root = new DOMParser().parseFromString(source, 'image/svg+xml').documentElement;
-        if (root.tagName !== 'svg') {
-            throw new TypeError(
-                `registerColorIcon(${JSON.stringify(name)}): the source starts with '<' but parsed ` +
-                    `to <${root.tagName}>, not an <svg> root.`,
-            );
-        }
-        return toDataUri(source);
-    }
-
-    let url: URL;
-    try {
-        url = new URL(source, document.baseURI);
-    } catch {
-        throw new TypeError(`registerColorIcon(${JSON.stringify(name)}): the source is neither SVG source nor a URL.`);
-    }
-    const isImageData = url.protocol === 'data:' && /^data:image\//i.test(url.href);
-    if (!isImageData && !ALLOWED_PROTOCOLS.has(url.protocol)) {
-        throw new TypeError(
-            `registerColorIcon(${JSON.stringify(name)}): ${JSON.stringify(url.protocol)} URLs are not ` +
-                'accepted — use http(s):, blob:, file: or a data:image/ URI.',
-        );
-    }
-    return url.href;
-}
-
-/**
- * Register a FULL-COLOUR icon under `name` — what an application ships in
- * `hicolor/scalable/apps/<app-id>.svg` and GTK finds through its icon theme. Every
- * `<gtk-image>` asking for the name draws the image unrecoloured, the way `AdwAboutDialog`'s
- * `application-icon` does on GNOME.
- *
- * `name` is the EXACT icon name, reverse-DNS application IDs included. A name with a
- * `-symbolic` suffix THROWS: that is the other half of the theme, and {@link registerIcon}
- * is its door. `source` is SVG source, or a URL (resolved against the document) to any
- * image the browser can draw.
- *
- * Re-registering a name replaces the image, and every mounted `<gtk-image>` redraws.
- *
- * CLIENT-SIDE ONLY, like `registerIcon`: it reads `document`.
- */
-export function registerColorIcon(name: string, source: string): void {
-    if (typeof name !== 'string' || name === '' || /\s/.test(name)) {
-        throw new TypeError(
-            `registerColorIcon: ${JSON.stringify(name)} is not an icon name — it must be non-empty ` +
-                'and contain no whitespace.',
-        );
-    }
-    if (SYMBOLIC_FILE_NAME.test(name)) {
-        throw new TypeError(
-            `registerColorIcon: ${JSON.stringify(name)} names a SYMBOLIC icon, which is recoloured ` +
-                'rather than drawn as-is — register it with registerIcon() instead.',
-        );
-    }
-    if (typeof source !== 'string' || source.trim() === '') {
-        throw new TypeError(`registerColorIcon(${JSON.stringify(name)}): the source is empty.`);
-    }
-
-    colorIcons.set(name, colorIconUrl(name, source));
-    notifyIconThemeChanged();
+    return hasSymbolic(found.name);
 }

package/src/index.ts

@@ -85,13 +85,9 @@ export type { BuildOptions, BuiltTree, MountOptions, MountedSharedTree, SizeSour
 export { registerTemplateClass } from './template-classes.js';
 
 // The stylesheet compiles a chosen SUBSET of `@gjsify/adwaita-icons` (the whole set is
-// ~1.07 MB of data-URI), so a name outside it draws the `image-missing` fallback. This is
-// the way in for an app that needs a glyph this package does not ship — see
-// `icon-registry.ts` for the full recipe.
-export { isIconAvailable, registerIcon } from './icon-registry.js';
-// The full-colour half of the icon theme — an application icon drawn as-is, the web stand-in
-// for an app's `hicolor/…/apps/<app-id>.svg`. See `icon-theme.ts` for the lookup order.
-export { registerColorIcon } from './icon-theme.js';
+// ~1.07 MB of data-URI). An app's own icons, symbolic and full-colour, come from its
+// GResource through `Gtk.IconTheme`'s resource paths (ADR 0116); see `icon-theme.ts`.
+export { isIconAvailable } from './icon-theme.js';
 
 // THE WIDGET CLASSES ARE REACHABLE ONLY AS `Adw.<Name>` / `Gtk.<Name>` (ADR 0034
 // clause 2 + § Amendment 6). The namespace used to be the LAST line in the file, under a

package/src/namespace/gdk.ts

@@ -15,6 +15,7 @@ export const Display = gdk.Display;
 export const Clipboard = gdk.Clipboard;
 export const ContentProvider = gdk.ContentProvider;
 export const ContentFormats = gdk.ContentFormats;
+export const AppLaunchContext = gdk.AppLaunchContext;
 
 export const CURRENT_TIME = GDK_PLATFORM_CURRENT_TIME;
 export const {

package/src/namespace/gio.ts

@@ -24,6 +24,10 @@
 
 import '../file-chooser-host.js';
 
+import { createAppInfo } from '@gjsify/adwaita-core';
+
+import { webPlatformHost } from '../platform-host.js';
+
 export { GioMenu as Menu, GioMenuItem as MenuItem } from '@gjsify/adwaita-core';
 export {
     GioFile as File,
@@ -47,3 +51,7 @@ export {
 } from '@gjsify/adwaita-core';
 export { GioApplication as Application } from '../application.js';
 export { Settings } from '@gjsify/app-settings/browser';
+
+// `Gio.AppInfo.launch_default_for_uri` over the host `Gtk.show_uri` uses (ADR 0101): the core's
+// `gio-app-info.ts`.
+export const AppInfo = createAppInfo(webPlatformHost);

package/src/namespace/glib.ts

@@ -7,6 +7,8 @@
 // in `glib-paths.ts` of the core; the host has no filesystem, so `get_current_dir()` is `"/"` and
 // `get_system_data_dirs()` is `[]`. A port that knows better replaces the member in its own file.
 //
+// `uri_escape_string` is the core's `glib-uri.ts`, a pure function over UTF-8 bytes.
+//
 // `Bytes` and `Error` are the ADR 0100 subset a `Gio.File` reads and fails with (`get_data`,
 // `matches`, `code`, `message`), re-exported from the core's `glib-bytes.ts` / `glib-error.ts`.
 //
@@ -21,6 +23,7 @@ import {
     getCurrentDir,
     getSystemDataDirs,
     MAXUINT32 as GLIB_MAXUINT32,
+    uriEscapeString,
 } from '@gjsify/adwaita-core';
 
 const glib = createGLibTimers();
@@ -40,3 +43,4 @@ export const MAXUINT32 = GLIB_MAXUINT32;
 export const build_filenamev = buildFilenamev;
 export const get_current_dir = getCurrentDir;
 export const get_system_data_dirs = getSystemDataDirs;
+export const uri_escape_string = uriEscapeString;

package/src/shared-tree-builder.ts

@@ -28,7 +28,7 @@
 // into a host `<div>` it was never given.
 //
 // Placed flat under `src/`, at parity with this package's other single-purpose modules
-// (`accent.ts`, `breakpoints.ts`, `icon-registry.ts`) rather than a new `conformance/` or
+// (`accent.ts`, `breakpoints.ts`, `icon-theme.ts`) rather than a new `conformance/` or
 // `builder/` directory for one file: unlike `gtk-host`, this package has no existing
 // `conformance/` home to add to. Exported through the existing barrel, `src/index.ts` — the
 // package's `exports` map ships only `.`, and a new subpath would buy nothing for a module
@@ -233,7 +233,7 @@ function refuseSiblings(node: SharedTreeNode, door: string): void {
 function buildTree(node: SharedTreeNode, record: BuildRecord): BuiltTree {
     // ADR 0093 § 2: the whole tree is checked against the capability table before an element is
     // created. A refused `layout` is named with its node and the reason the table gives.
-    assertTreeConstructs('adwaita-web', capabilities, node);
+    assertTreeConstructs('adwaita-web', capabilities, node, Object.keys(ARIA_OF));
     if (node.menus !== undefined) record.menus = node.menus;
     const root = buildNode(node, record);
     const siblings = new Map<string, HTMLElement>();
@@ -512,6 +512,29 @@ function writeLook(el: HTMLElement, node: SharedTreeNode, menus?: SharedTreeNode
     // `.blp`'s `styles ["title-1"]` reached the tree and never the page.
     if (node.styleClasses !== undefined && node.styleClasses.length > 0) el.classList.add(...node.styleClasses);
     writeExtensions(el, node);
+    writeAccessibility(el, node);
+}
+
+/**
+ * The `accessibility { }` names this renderer has a door for, and the ARIA attribute each is.
+ * The rest (states, relations, `row-index`, …) are refused by name before the build, in
+ * {@link assertTreeConstructs}: no element here reads them, so they would be dropped.
+ */
+const ARIA_OF: Readonly<Record<string, string>> = {
+    label: 'aria-label',
+    description: 'aria-description',
+};
+
+/**
+ * `accessibility { label; description; }` as the host's `aria-label` / `aria-description`.
+ * Written after the props, so an element that derives a name from its tooltip sees the
+ * authored one first; an element whose role lives on an inner control forwards both
+ * (`accessible.ts`). A translatable value is written as its source text, as a prop's is.
+ */
+function writeAccessibility(el: HTMLElement, node: SharedTreeNode): void {
+    for (const [name, entry] of Object.entries(node.accessibility ?? {})) {
+        el.setAttribute(ARIA_OF[name], String(entry.value));
+    }
 }
 
 /** The `GtkGridLayoutChild` properties `layout { }` may carry, and the CSS Grid line each one is. */
@@ -586,7 +609,7 @@ export interface BuiltTemplateTree {
  */
 export function buildTemplateTree(tree: SharedTreeNode, scope: TemplateScope, host: HTMLElement): BuiltTemplateTree {
     refuseSiblings(tree, 'buildTemplateTree');
-    assertTreeConstructs('adwaita-web', capabilities, tree);
+    assertTreeConstructs('adwaita-web', capabilities, tree, Object.keys(ARIA_OF));
     const record = newRecord(undefined, undefined, scope);
     record.menus = tree.menus;
     if (tree.id !== undefined) record.ids.set(tree.id, host);

package/src/signals.ts

@@ -9,7 +9,16 @@
 /** GTK signal name → the DOM event type the element dispatches it as. */
 export type DispatchedSignals = Readonly<Record<string, string>>;
 
-/** The signals `el`'s class declares, or none. */
+/**
+ * The signals `el`'s class and every class above it declare, or none. A class inherits its
+ * base's signals as a GObject class does (`map` / `unmap` are declared once, on
+ * `WidgetElement`); where two declare the same name, the more derived class wins.
+ */
 export function dispatchedSignalsOf(el: Element): DispatchedSignals {
-    return (el.constructor as { signals?: DispatchedSignals }).signals ?? {};
+    const chain: DispatchedSignals[] = [];
+    for (let klass: unknown = el.constructor; typeof klass === 'function'; klass = Object.getPrototypeOf(klass)) {
+        const own = Object.getOwnPropertyDescriptor(klass, 'signals')?.value as DispatchedSignals | undefined;
+        if (own !== undefined) chain.unshift(own);
+    }
+    return Object.assign({}, ...chain) as DispatchedSignals;
 }

package/src/source-view/adw-source-view.ts

@@ -36,13 +36,14 @@ import { adwaitaEditorTheme, adwaitaHighlightStyle, ensureSourceViewStyleInjecte
 import { formatHexAddress, formatLineNumber, stripSourceWhitespace } from '@gjsify/adwaita-core';
 import { createGtkImage } from '../elements/gtk-image.js';
 import { createCopyGlyph } from './copy-glyph.js';
+import { WidgetElement } from '../widget-element.js';
 
 /** Parse a boolean attribute: present (any value but "false") ⇒ true. */
 function boolAttr(value: string | null): boolean {
     return value !== null && value !== 'false';
 }
 
-export class AdwSourceView extends HTMLElement {
+export class AdwSourceView extends WidgetElement {
     private _view?: EditorView;
     private _editorHost!: HTMLDivElement;
     private _copyButton!: HTMLButtonElement;