@gjsify/adwaita-web 0.60.0 → 0.61.0

package/src/file-chooser.spec.ts

@@ -0,0 +1,376 @@
+// The file-chooser door of adwaita-web, held to the shared vectors (real GJS is their oracle, in
+// adwaita-core's `file-chooser.gjs.spec.ts`) through both of its paths — the File System Access
+// pickers and the Origin Private File System — plus what only a browser shows: the filter mapping,
+// a missing user activation, the drawn dialog, the `<input>` copy and the worker write.
+//
+// The pickers are scripted fakes; the handles behind them are REAL OPFS handles in a directory of
+// their own, so every read and write below goes through the browser's storage.
+
+import {
+    driveFileChooserVectors,
+    FILE_CHOOSER_VECTORS,
+    type FileChooserNamespaces,
+    type FileChooserSubject,
+    type ScriptedPick,
+} from '@gjsify/adwaita-core/conformance';
+import { registerFileChooserDriver, type FileChooserRequest, type FileFilterSpec } from '@gjsify/adwaita-core';
+import { describe, expect, it } from '@gjsify/unit';
+
+import type { AdwDialog } from './elements/adw-dialog.js';
+import type { GtkEntry } from './elements/gtk-entry.js';
+import type { GtkListBox } from './elements/gtk-list-box.js';
+import {
+    createWebFileChooserDriver,
+    filePickerOptions,
+    inputAccept,
+    presentOpfsDialog,
+    type FilePickerOptions,
+    type OpfsChoice,
+    type WebFileChooserEnv,
+} from './file-chooser-host.js';
+import * as Gio from './namespace/gio.js';
+import * as GLib from './namespace/glib.js';
+import * as Gtk from './namespace/gtk.js';
+
+let scratchCount = 0;
+
+/** A fresh OPFS directory; the caller removes it with {@link dropScratch}. */
+async function scratch(): Promise<FileSystemDirectoryHandle> {
+    const root = await navigator.storage.getDirectory();
+    return root.getDirectoryHandle(`file-chooser-spec-${Date.now()}-${scratchCount++}`, { create: true });
+}
+
+async function dropScratch(dir: FileSystemDirectoryHandle): Promise<void> {
+    const root = await navigator.storage.getDirectory();
+    await root.removeEntry(dir.name, { recursive: true });
+}
+
+async function put(dir: FileSystemDirectoryHandle, name: string, contents: Uint8Array | string) {
+    const handle = await dir.getFileHandle(name, { create: true });
+    const stream = await handle.createWritable();
+    await stream.write(contents as FileSystemWriteChunkType);
+    await stream.close();
+    return handle;
+}
+
+async function text(dir: FileSystemDirectoryHandle, name: string): Promise<string> {
+    return (await (await dir.getFileHandle(name)).getFile()).text();
+}
+
+const abort = () => new DOMException('The user aborted a request.', 'AbortError');
+
+/** The filters a File System Access options object carries, written the way the vectors write them. */
+function optionGlobs(options: FilePickerOptions): string[][] {
+    const out = (options.types ?? []).map((type) =>
+        Object.entries(type.accept).flatMap(([mime, exts]) =>
+            exts.length > 0 ? exts.map((ext) => `*${ext}`) : [mime],
+        ),
+    );
+    if (options.types && !options.excludeAcceptAllOption) out.push(['*']);
+    return out;
+}
+
+function requestGlobs(request: FileChooserRequest | null): string[][] {
+    return (request?.filters ?? []).map((spec) => [
+        ...(spec.acceptAll ? ['*'] : []),
+        ...[...spec.patterns, ...spec.suffixes].map((ext) => `*.${ext}`),
+        ...spec.mimeTypes,
+    ]);
+}
+
+const namespaces = { GLib, Gio, Gtk } as unknown as FileChooserNamespaces;
+
+/** A subject whose env opens the File System Access pickers, scripted. */
+function pickerSubject(dir: FileSystemDirectoryHandle) {
+    let next: ScriptedPick = null;
+    let lastOptions: FilePickerOptions = {};
+    const env: WebFileChooserEnv = {
+        showOpenFilePicker: async (options) => {
+            lastOptions = options;
+            if (next === null) throw abort();
+            return [await put(dir, next.basename, next.contents ?? '')];
+        },
+        showSaveFilePicker: async (options) => {
+            lastOptions = options;
+            if (next === null) throw abort();
+            return dir.getFileHandle(next.basename, { create: true });
+        },
+        isActive: () => true,
+        opfsRoot: async () => dir,
+        choose: async () => null,
+        canStreamWrite: () => true,
+    };
+    const subject: FileChooserSubject = {
+        ...namespaces,
+        name: 'adwaita-web (File System Access)',
+        isOracle: false,
+        script: (pick) => void (next = pick),
+        pickerFilters: () => optionGlobs(lastOptions),
+        cancelled: () => ({ is_cancelled: () => true }),
+    };
+    return { env, subject };
+}
+
+/** A subject whose env has no pickers: OPFS, with the drawn dialog replaced by the script. */
+function opfsSubject(dir: FileSystemDirectoryHandle) {
+    let next: ScriptedPick = null;
+    let lastRequest: FileChooserRequest | null = null;
+    const env: WebFileChooserEnv = {
+        isActive: () => true,
+        opfsRoot: async () => dir,
+        choose: async (kind, request) => {
+            lastRequest = request;
+            if (next === null) return null;
+            if (kind === 'open') await put(dir, next.basename, next.contents ?? '');
+            return { name: next.basename };
+        },
+        canStreamWrite: () => true,
+    };
+    const subject: FileChooserSubject = {
+        ...namespaces,
+        name: 'adwaita-web (OPFS)',
+        isOracle: false,
+        script: (pick) => void (next = pick),
+        pickerFilters: () => requestGlobs(lastRequest),
+        cancelled: () => ({ is_cancelled: () => true }),
+    };
+    return { env, subject };
+}
+
+async function withEnv<T>(env: WebFileChooserEnv, body: () => Promise<T>): Promise<T> {
+    const previous = registerFileChooserDriver(createWebFileChooserDriver(env));
+    try {
+        return await body();
+    } finally {
+        registerFileChooserDriver(previous);
+    }
+}
+
+const spec = (over: Partial<FileFilterSpec>): FileFilterSpec => ({
+    name: null,
+    patterns: [],
+    suffixes: [],
+    mimeTypes: [],
+    acceptAll: false,
+    ...over,
+});
+
+const asm = spec({ name: 'Assembly Files', patterns: ['asm', 's'] });
+const all = spec({ name: 'All Files', acceptAll: true });
+
+const request = (over: Partial<FileChooserRequest> = {}): FileChooserRequest => ({
+    title: null,
+    filters: [],
+    defaultFilter: null,
+    initialName: null,
+    parent: null,
+    ...over,
+});
+
+type Opened = { get_basename(): string; load_contents_async(c: unknown): Promise<[Uint8Array, unknown]> };
+const openDialog = (filters?: unknown): Promise<Opened> =>
+    (new Gtk.FileDialog(filters ? { filters } : {}).open as unknown as (p: unknown, c: unknown) => Promise<Opened>)(
+        null,
+        null,
+    );
+
+async function rejectionOf(pending: Promise<unknown>): Promise<{ dismissed: boolean; failed: boolean } | 'resolved'> {
+    try {
+        await pending;
+        return 'resolved';
+    } catch (error) {
+        const e = error as { matches(domain: unknown, code: number): boolean };
+        return {
+            dismissed: e.matches(Gtk.DialogError, Gtk.DialogError.DISMISSED),
+            failed: e.matches(Gtk.DialogError, Gtk.DialogError.FAILED),
+        };
+    }
+}
+
+async function readyDialog(): Promise<AdwDialog> {
+    for (let i = 0; i < 200; i++) {
+        const dialog = document.querySelector('adw-dialog[data-ready]') as AdwDialog | null;
+        if (dialog) return dialog;
+        await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+    throw new Error('the OPFS dialog never set data-ready');
+}
+
+const rowNames = (dialog: AdwDialog) =>
+    [...dialog.querySelectorAll('gtk-list-box-row[data-name]')].map((row) => (row as HTMLElement).dataset.name);
+
+export const FileChooserTest = async () => {
+    for (const make of [pickerSubject, opfsSubject]) {
+        const dir = await scratch();
+        const { env, subject } = make(dir);
+        try {
+            await withEnv(env, () => driveFileChooserVectors(subject, { describe, it, expect }, FILE_CHOOSER_VECTORS));
+        } finally {
+            await dropScratch(dir);
+        }
+    }
+
+    await describe('adwaita-web: the File System Access mapping', async () => {
+        await it('maps an extension filter to the octet-stream key and keeps the accept-all option', () => {
+            const options = filePickerOptions(request({ filters: [asm, all], initialName: 'a.asm' }), 'save');
+            expect(JSON.stringify(options)).toBe(
+                JSON.stringify({
+                    types: [{ description: 'Assembly Files', accept: { 'application/octet-stream': ['.asm', '.s'] } }],
+                    excludeAcceptAllOption: false,
+                    suggestedName: 'a.asm',
+                }),
+            );
+        });
+
+        await it('excludes the accept-all option when no filter accepts everything, and keys MIME types', () => {
+            const text = spec({ name: 'Text', suffixes: ['txt'], mimeTypes: ['text/plain'] });
+            const options = filePickerOptions(request({ filters: [text], initialName: 'x.txt' }), 'open');
+            expect(JSON.stringify(options)).toBe(
+                JSON.stringify({
+                    types: [{ description: 'Text', accept: { 'text/plain': ['.txt'] } }],
+                    excludeAcceptAllOption: true,
+                }),
+            );
+        });
+
+        await it('gives <input accept> the extensions and MIME types, and nothing for accept-all', () => {
+            expect(JSON.stringify([inputAccept(asm), inputAccept(all), inputAccept(null)])).toBe(
+                JSON.stringify(['.asm,.s', null, null]),
+            );
+        });
+    });
+
+    await describe('adwaita-web: the driver', async () => {
+        await it('rejects with DialogError.FAILED without a user activation, before any picker opens', async () => {
+            const dir = await scratch();
+            let opened = false;
+            const { env } = pickerSubject(dir);
+            env.isActive = () => false;
+            const picker = env.showOpenFilePicker!;
+            env.showOpenFilePicker = (options) => ((opened = true), picker(options));
+            const result = await withEnv(env, () => rejectionOf(openDialog()));
+            await dropScratch(dir);
+            expect(JSON.stringify([result, opened])).toBe(JSON.stringify([{ dismissed: false, failed: true }, false]));
+        });
+
+        await it('maps AbortError to DISMISSED and any other picker error to FAILED', async () => {
+            const dir = await scratch();
+            const { env } = pickerSubject(dir);
+            const aborted = await withEnv(env, () => rejectionOf(openDialog()));
+            env.showOpenFilePicker = async () => {
+                throw new DOMException('blocked', 'SecurityError');
+            };
+            const blocked = await withEnv(env, () => rejectionOf(openDialog()));
+            await dropScratch(dir);
+            expect(JSON.stringify([aborted, blocked])).toBe(
+                JSON.stringify([
+                    { dismissed: true, failed: false },
+                    { dismissed: false, failed: true },
+                ]),
+            );
+        });
+
+        await it('copies an <input> pick into OPFS under a free name', async () => {
+            const dir = await scratch();
+            await put(dir, 'a.asm', 'old');
+            const env: WebFileChooserEnv = {
+                isActive: () => true,
+                opfsRoot: async () => dir,
+                choose: async () => ({ upload: new File(['new'], 'a.asm') }) as OpfsChoice,
+                canStreamWrite: () => true,
+            };
+            const file = await withEnv(env, () => openDialog());
+            const result = [file.get_basename(), await text(dir, 'a.asm'), await text(dir, 'a (2).asm')];
+            await dropScratch(dir);
+            expect(JSON.stringify(result)).toBe(JSON.stringify(['a (2).asm', 'old', 'new']));
+        });
+
+        await it('writes through a createSyncAccessHandle worker where createWritable is missing', async () => {
+            const dir = await scratch();
+            await put(dir, 'w.txt', 'a longer old content');
+            const driver = createWebFileChooserDriver({
+                isActive: () => true,
+                opfsRoot: async () => dir,
+                choose: async () => ({ name: 'w.txt' }),
+                canStreamWrite: () => false,
+            });
+            const handle = await driver.save(request({ initialName: 'w.txt' }));
+            const writer = await handle.openWriter();
+            await writer.write(new TextEncoder().encode('he'));
+            await writer.write(new TextEncoder().encode('llo'));
+            await writer.close();
+            const result = new TextDecoder().decode(await handle.read());
+            await dropScratch(dir);
+            expect(result).toBe('hello');
+        });
+
+        await it('never creates a download link to save', async () => {
+            const dir = await scratch();
+            const created: string[] = [];
+            const original = document.createElement;
+            document.createElement = function (this: Document, tag: string, options?: ElementCreationOptions) {
+                created.push(tag.toLowerCase());
+                return original.call(this, tag, options);
+            } as typeof document.createElement;
+            try {
+                const { env, subject } = opfsSubject(dir);
+                subject.script({ basename: 'd.txt' });
+                await withEnv(env, async () => {
+                    const save = new Gtk.FileDialog({ initial_name: 'd.txt' }).save as unknown as (
+                        p: unknown,
+                        c: unknown,
+                    ) => Promise<{ replace_contents_async: unknown }>;
+                    await save(null, null);
+                });
+            } finally {
+                document.createElement = original;
+                await dropScratch(dir);
+            }
+            expect(created.includes('a')).toBe(false);
+        });
+    });
+
+    await describe('adwaita-web: the drawn OPFS dialog', async () => {
+        await it('lists what the current filter accepts and opens the selected row', async () => {
+            const dir = await scratch();
+            await put(dir, 'b.asm', '');
+            await put(dir, 'a.asm', '');
+            await put(dir, 'notes.txt', '');
+            const pending = presentOpfsDialog('open', request({ filters: [asm, all] }), dir);
+            const dialog = await readyDialog();
+            const names = rowNames(dialog);
+            const list = dialog.querySelector('gtk-list-box[selection-mode="single"]') as GtkListBox;
+            list.selectRow(list.rows[1]);
+            (dialog.querySelector('gtk-button[label="Open"]') as HTMLElement).click();
+            const choice = await pending;
+            const gone = !dialog.isConnected;
+            await dropScratch(dir);
+            expect(JSON.stringify([names, choice, gone])).toBe(
+                JSON.stringify([['a.asm', 'b.asm'], { name: 'b.asm' }, true]),
+            );
+        });
+
+        await it('saves under the name in the entry, prefilled with the initial name', async () => {
+            const dir = await scratch();
+            const pending = presentOpfsDialog('save', request({ initialName: 'p.asm' }), dir);
+            const dialog = await readyDialog();
+            const entry = dialog.querySelector('gtk-entry') as GtkEntry;
+            const prefilled = entry.value;
+            entry.value = 'q.asm';
+            (dialog.querySelector('gtk-button[label="Save"]') as HTMLElement).click();
+            const choice = await pending;
+            await dropScratch(dir);
+            expect(JSON.stringify([prefilled, choice])).toBe(JSON.stringify(['p.asm', { name: 'q.asm' }]));
+        });
+
+        await it('resolves null when the dialog closes without a choice', async () => {
+            const dir = await scratch();
+            const pending = presentOpfsDialog('open', request(), dir);
+            const dialog = await readyDialog();
+            dialog.close();
+            const choice = await pending;
+            await dropScratch(dir);
+            expect(choice).toBe(null);
+        });
+    });
+};

package/src/gobject-door.ts

@@ -19,12 +19,14 @@ import {
     type RegisteredClass,
     type TemplateScope,
     syncDirection,
+    widgetControllerMembers,
     widgetDisplayMembers,
     widgetTreeMembers,
 } from '@gjsify/adwaita-core';
 import { propertyOf } from '@gjsify/adwaita-core/tags';
 
 import { gdk } from './namespace/gdk.js';
+import { webPlatformHost } from './platform-host.js';
 import { inheritStyles } from './registered-styles.js';
 import { dispatchElement, listenElement } from './gobject-elements.js';
 import { buildTemplateTree, type BuiltTemplateTree } from './shared-tree-builder.js';
@@ -127,7 +129,11 @@ export const webDoor: GObjectDoor = {
 
         const proto = (klass as { prototype: Record<string, unknown> }).prototype;
         // `this.get_display()`, `this.set_direction()`, `this.insert_action_group()` …, as on a Gtk.Widget; a class's own wins.
-        for (const [name, member] of Object.entries({ ...widgetDisplayMembers(gdk), ...widgetTreeMembers() })) {
+        for (const [name, member] of Object.entries({
+            ...widgetDisplayMembers(gdk),
+            ...widgetTreeMembers(),
+            ...widgetControllerMembers(webPlatformHost),
+        })) {
             if (!(name in proto))
                 Object.defineProperty(proto, name, { value: member, writable: true, configurable: true });
         }

package/src/gobject-elements.ts

@@ -148,6 +148,10 @@ export function installElementApi(el: HTMLElement): void {
     });
     define('emit', (signal: string, ...args: unknown[]): void => dispatchElement(el, signal, args));
     define('notify', (name: string): void => notifyElement(el, name));
+    // The `Gtk.Widget` CSS-class calls a template's TypeScript makes on its children.
+    define('add_css_class', (name: string): void => el.classList.add(name));
+    define('remove_css_class', (name: string): void => el.classList.remove(name));
+    define('has_css_class', (name: string): boolean => el.classList.contains(name));
 }
 
 const API_MEMBERS = new Set(['connect', 'disconnect', 'emit', 'notify']);

package/src/gtk-drop-down.spec.ts

@@ -276,6 +276,17 @@ export const GtkDropDownTest = async () => {
             dd.remove();
         });
 
+        await it('get_selected / set_selected are the GTK spelling of `selected`', async () => {
+            const dd = makeDropDown();
+            dd.model = ['a', 'b', 'c'];
+            (dd as unknown as { set_selected(n: number): void }).set_selected(2);
+            expect(dd.selected).toBe(2);
+            expect((dd as unknown as { get_selected(): number }).get_selected()).toBe(2);
+            (dd as unknown as { set_selected(n: number): void }).set_selected(9);
+            expect(dd.selected).toBe(2);
+            dd.remove();
+        });
+
         await it('selected reflects to the attribute + marks the row', async () => {
             const dd = makeDropDown();
             dd.model = ['a', 'b'];

package/src/gtk-label.spec.ts

@@ -207,6 +207,18 @@ export const GtkLabelTest = async () => {
         });
     });
 
+    await describe('<gtk-label> get_label / set_label', async () => {
+        await it('are the GTK spelling of the `label` property', () => {
+            const { el, host } = mount('Hello');
+            const gtk = el as unknown as { get_label(): string; set_label(str: string): void };
+            expect(gtk.get_label()).toBe('Hello');
+            gtk.set_label('World');
+            expect(el.label).toBe('World');
+            expect(el.textContent).toBe('World');
+            host.remove();
+        });
+    });
+
     await describe('<gtk-label> xalign and justify', async () => {
         await it('centres the text in its box by default (xalign 0.5)', () => {
             const { el, host } = mount('Hi');

package/src/gtk-platform.spec.ts

@@ -0,0 +1,19 @@
+// The Gtk platform door of adwaita-web, held to the shared vectors. The door is the namespace module itself,
+// so a member that stops being exported fails here.
+
+import { GTK_PLATFORM_VECTORS, driveGtkPlatformVectors, type GtkPlatformLike } from '@gjsify/adwaita-core/conformance';
+import { describe, expect, it } from '@gjsify/unit';
+
+import * as Gtk from './namespace/gtk.js';
+
+export const GtkPlatformTest = async () => {
+    await driveGtkPlatformVectors(
+        { name: 'adwaita-web', isOracle: false, Gtk: Gtk as unknown as GtkPlatformLike },
+        { describe, it, expect },
+    );
+    await describe('adwaita-web: Gtk platform door', async () => {
+        await it('has a vector row for every vector', () => {
+            expect(GTK_PLATFORM_VECTORS.length > 0).toBe(true);
+        });
+    });
+};

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

@@ -53,6 +53,28 @@ export const GtkTextViewTest = async () => {
             second.remove();
         });
 
+        await it('`buffer.insert_at_cursor` appends at the caret and `cursor_position` follows it', () => {
+            const el = mount('');
+            expect(el.buffer.cursor_position).toBe(0);
+            el.buffer.insert_at_cursor('one', -1);
+            el.buffer.insert_at_cursor('\ntwo', -1);
+            expect(el.text).toBe('one\ntwo');
+            expect(el.buffer.cursor_position).toBe(7);
+            el.buffer.insert_at_cursor('xyz', 1);
+            expect(el.text).toBe('one\ntwox');
+            unmountAll();
+        });
+
+        await it('`buffer.set_text` replaces the text and `get_text` reads it', () => {
+            const el = mount('old');
+            el.buffer.set_text('new', -1);
+            expect(el.buffer.get_text()).toBe('new');
+            el.buffer.set_text('', 0);
+            expect(el.text).toBe('');
+            expect(el.buffer.cursor_position).toBe(0);
+            unmountAll();
+        });
+
         await it("re-emits the buffer's `changed` on an edit", () => {
             const el = mount('a');
             const seen: unknown[] = [];

package/src/namespace/adw.ts

@@ -111,3 +111,4 @@ export { AdwWindowTitle as WindowTitle } from '../elements/adw-window-title.js';
 export { AdwWrapBox as WrapBox } from '../elements/adw-wrap-box.js';
 export { AdwApplication as Application } from '../application.js';
 export { AdwStyleManager as StyleManager } from '../style-manager.js';
+export { ColorScheme } from '@gjsify/adwaita-core';

package/src/namespace/gdk.ts

@@ -5,7 +5,7 @@
 //
 // A TRUE SUBSET: everything else in Gdk is absent, and the `gi://Gdk` arm refuses it by name.
 
-import { createGdk } from '@gjsify/adwaita-core';
+import { CURRENT_TIME as GDK_PLATFORM_CURRENT_TIME, GDK_KEYS, createGdk } from '@gjsify/adwaita-core';
 
 import { webClipboardHost } from '../clipboard-host.js';
 
@@ -15,3 +15,20 @@ export const Display = gdk.Display;
 export const Clipboard = gdk.Clipboard;
 export const ContentProvider = gdk.ContentProvider;
 export const ContentFormats = gdk.ContentFormats;
+
+export const CURRENT_TIME = GDK_PLATFORM_CURRENT_TIME;
+export const {
+    KEY_space,
+    KEY_a,
+    KEY_d,
+    KEY_e,
+    KEY_q,
+    KEY_s,
+    KEY_w,
+    KEY_Return,
+    KEY_Escape,
+    KEY_Left,
+    KEY_Up,
+    KEY_Right,
+    KEY_Down,
+} = GDK_KEYS;

package/src/namespace/gio.ts

@@ -12,10 +12,28 @@
 // `check-vocabulary-alignment.mjs` derives their members from the elements this package
 // defines. GIO defines none: what lands here is the handful of GObject types an Adwaita
 // author CONSTRUCTS while building a tree — today the menu a `menuModel` property takes.
-// `Gio.File`, `Gio.Settings` and the rest of the library are NOT this
-// package's business; a namespace that grows past what the elements consume is a second,
+// `Gio.Settings` is here (ADR 0099, the `localStorage` door); the rest of the library is NOT
+// this package's business; a namespace that grows past what the elements consume is a second,
 // unheld vocabulary.
+//
+// THE ONE OTHER EXCEPTION IS ADR 0100: the `Gio.File` a `Gtk.FileDialog` hands back, with the
+// `ListStore` its `filters` take, the streams `replace_async` opens, `FileCreateFlags`,
+// `IOErrorEnum` and `_promisify`. The subset lives in `@gjsify/adwaita-core`
+// (`file-chooser.ts`), which refuses everything past it by name; `../file-chooser-host.ts`
+// is the browser's driver behind it.
+
+import '../file-chooser-host.js';
 
 export { GioMenu as Menu, GioMenuItem as MenuItem } from '@gjsify/adwaita-core';
+export {
+    GioFile as File,
+    GioListStore as ListStore,
+    GioOutputStream as OutputStream,
+    GioFileOutputStream as FileOutputStream,
+    FileCreateFlags,
+    IOErrorEnum,
+    promisify as _promisify,
+} from '@gjsify/adwaita-core';
 export { SimpleAction, SimpleActionGroup, ApplicationFlags } from '@gjsify/adwaita-core';
 export { GioApplication as Application } from '../application.js';
+export { Settings } from '@gjsify/app-settings/browser';

package/src/namespace/glib.ts

@@ -7,9 +7,14 @@
 // 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.
 //
-// A TRUE SUBSET: everything else in GLib (`MainLoop`, `Source`, `timeout_add_seconds`, `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`.
+//
+// A TRUE SUBSET: everything else in GLib (`MainLoop`, `Source`, `timeout_add_seconds`,
 // `get_home_dir`, …) is absent, and the `gi://GLib` arm refuses it by name.
 
+export { GLibBytes as Bytes, GLibError as Error } from '@gjsify/adwaita-core';
+
 import {
     buildFilenamev,
     createGLibTimers,

package/src/namespace/gtk-enums.ts

@@ -1,10 +1,12 @@
 // The plain GTK enums an application reads off `Gtk` — `Gtk.PolicyType`, `Gtk.TextDirection`,
-// `Gtk.TextExtendSelection` and `Gtk.TextWindowType`, as value tables. The numbers are the typelib's (GIR declaration order),
-// and the same tables the NativeScript port publishes.
+// `Gtk.TextExtendSelection`, `Gtk.TextWindowType` and `Gtk.License`, as value tables. The numbers
+// are the typelib's (GIR declaration order), and the same tables the NativeScript port publishes.
 //
 // Reference: refs/gtk gtk/gtkenums.h (GtkPolicyType, GtkTextDirection), gtk/gtktextview.h (GtkTextWindowType)
 // Copyright (c) The GTK Team. LGPLv2.1+.
 
+import { GTK_LICENSE } from '@gjsify/adwaita-core';
+
 /** `Gtk.PolicyType`: `ALWAYS` 0, `AUTOMATIC` 1, `NEVER` 2, `EXTERNAL` 3. */
 export const PolicyType = Object.freeze({
     ALWAYS: 0,
@@ -32,3 +34,6 @@ export const TextWindowType = Object.freeze({
 
 /** `Gtk.TextExtendSelection`: `WORD` 0 (a double click), `LINE` 1 (a triple click). */
 export const TextExtendSelection = Object.freeze({ WORD: 0, LINE: 1 } as const);
+
+/** `Gtk.License`, the table `Adw.AboutDialog` reads. */
+export const License = GTK_LICENSE;

package/src/namespace/gtk-platform.ts

@@ -0,0 +1,16 @@
+// The web door's `Gtk.StyleContext`, `Gtk.Settings`, `Gtk.IconTheme`, `Gtk.show_uri` and
+// `Gtk.EventControllerKey`: the behaviour is `@gjsify/adwaita-core`'s `gtk-platform.ts`, the browser
+// is `../platform-host.ts`.
+
+import { createGtkPlatform } from '@gjsify/adwaita-core';
+
+import { webPlatformHost } from '../platform-host.js';
+
+const platform = createGtkPlatform(webPlatformHost);
+
+export const CssProvider = platform.CssProvider;
+export const StyleContext = platform.StyleContext;
+export const Settings = platform.Settings;
+export const IconTheme = platform.IconTheme;
+export const EventControllerKey = platform.EventControllerKey;
+export const show_uri = platform.show_uri;

package/src/namespace/gtk.ts

@@ -21,7 +21,10 @@
 // are the same write and nothing in this package had to learn a second input shape.
 
 export { GtkAdjustment as Adjustment } from '@gjsify/adwaita-core';
-export { PolicyType, TextDirection, TextExtendSelection, TextWindowType } from './gtk-enums.js';
+// ADR 0100: the file dialog is no element either — `present`-less, it asks the driver
+// `../file-chooser-host.ts` registers (imported by `./gio.ts`) and resolves a `Gio.File`.
+export { GtkFileDialog as FileDialog, GtkFileFilter as FileFilter, DialogError } from '@gjsify/adwaita-core';
+export { License, PolicyType, TextDirection, TextExtendSelection, TextWindowType } from './gtk-enums.js';
 export { GtkAboutDialog as AboutDialog } from '../elements/gtk-about-dialog.js';
 export { GtkActionBar as ActionBar } from '../elements/gtk-action-bar.js';
 export { GtkApplicationWindow as ApplicationWindow } from '../elements/gtk-application-window.js';
@@ -97,3 +100,11 @@ export { GtkWindowControls as WindowControls } from '../elements/gtk-window-cont
 export { GtkViewport as Viewport } from '../elements/gtk-viewport.js';
 export { GtkWindowHandle as WindowHandle } from '../elements/gtk-window-handle.js';
 export { GtkApplication as Application } from '../application.js';
+export {
+    STYLE_PROVIDER_PRIORITY_APPLICATION,
+    STYLE_PROVIDER_PRIORITY_FALLBACK,
+    STYLE_PROVIDER_PRIORITY_SETTINGS,
+    STYLE_PROVIDER_PRIORITY_THEME,
+    STYLE_PROVIDER_PRIORITY_USER,
+} from '@gjsify/adwaita-core';
+export { CssProvider, EventControllerKey, IconTheme, show_uri, StyleContext, Settings } from './gtk-platform.js';