@gjsify/gtk-host 0.51.1 → 0.53.0

package/lib/types/accessibility.d.ts

@@ -0,0 +1,56 @@
+import GObject from 'gi://GObject?version=2.0';
+import type { AriaTable } from './types.js';
+/** What `accessibility={{ … }}` carries. Keys are ARIA names; `null` clears a slot. */
+export type AccessibilityInput = Readonly<Record<string, unknown>>;
+interface AriaWrite {
+    readonly table: AriaTable;
+    readonly member: number;
+    readonly value: GObject.Value;
+}
+interface AriaReset {
+    readonly table: AriaTable;
+    readonly member: number;
+}
+/**
+ * Everything the three GTK calls need, resolved and refused BEFORE the first one runs.
+ *
+ * Built whole, then applied, for the same reason `setProp` validates before recording:
+ * a refusal half-way through would leave the widget carrying some of the authored
+ * accessibility and the element carrying all of it, and the next patch would compute its
+ * resets against a state that never existed.
+ */
+export interface AccessibilityPlan {
+    readonly writes: readonly AriaWrite[];
+    readonly resets: readonly AriaReset[];
+}
+/**
+ * Resolve an authored accessibility object against the one it replaces.
+ *
+ * Total: every name is looked up, every value is built, and anything GTK would take
+ * silently and wrongly throws here instead. Nothing touches a widget.
+ */
+export declare function planAccessibility(tag: string, previous: AccessibilityInput | null, next: AccessibilityInput | null): AccessibilityPlan;
+/**
+ * Run a plan against a widget, one `update_*` call per table.
+ *
+ * BATCHED PER TABLE because that is the shape of the call: `gtk_accessible_update_state`
+ * takes parallel arrays and applies them together, so three names in one table are one
+ * call and one notification rather than three.
+ *
+ * The method names are DERIVED from the table name (`GtkAccessibleState` -> `update_state`),
+ * which is why `girs-vocabulary.mts` refuses a table it does not know rather than emitting
+ * its names: a derived call into a method GTK never installed is a `TypeError` in the middle
+ * of a render. `generated.spec.ts` holds all six derived names against the installed GTK.
+ */
+export declare function applyAccessibilityPlan(widget: GObject.Object, plan: AccessibilityPlan): void;
+/**
+ * Whether a class can carry accessibility at all.
+ *
+ * Asked of the CLASS, before the widget exists, so `<gtk-string-list accessibility={…}>`
+ * is refused at the call that authored it rather than at materialisation. Not every row of
+ * the generated table is a widget — the list carriers are `GObject`s that hold one — and
+ * `Gtk.StringList` has no `update_property` at all (measured), which would otherwise be a
+ * `TypeError` naming a method instead of a tag.
+ */
+export declare const isAccessibleClass: (klass: GObject.ObjectClass) => boolean;
+export {};

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

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

package/lib/types/attrs.d.ts

@@ -2,6 +2,7 @@ import type Gio from '@girs/gio-2.0';
 import type GObject from '@girs/gobject-2.0';
 import type Gtk from '@girs/gtk-4.0';
 import type { AdwAdjustmentInput, AdwListModelInput, AdwMenuInput } from '@gjsify/adwaita-core';
+import type { AccessibilityAttributes } from './generated/accessibility.js';
 import type { HostNode } from './types.js';
 /**
  * A `notify::` handler.
@@ -61,6 +62,18 @@ export type WithOnce<T> = T & {
 export interface SlotAttribute {
     slot?: string | null;
 }
+/**
+ * GTK's ARIA surface, on every element of every dialect. Read by `setAccessibility()`.
+ *
+ * ONE OBJECT, not 53 flat `aria*` props, and the four reasons are in `setAccessibility`'s
+ * own header — the load-bearing one being that TypeScript exempts a hyphenated JSX
+ * attribute from excess-property checking while a key in a fresh object literal is
+ * checked. `AccessibilityAttributes` is GENERATED, because the names and their value
+ * types are GTK's and are stated nowhere a ParamSpec can be read from.
+ */
+export interface AccessibilityAttribute {
+    accessibility?: AccessibilityAttributes | null;
+}
 /**
  * The `on:<raw-signal-name>` escape hatch, typed.
  *
@@ -87,7 +100,7 @@ export interface RawSignalAttributes {
  * `T` is the widget's own instance type, so `ref={(el) => …}` infers `el` as
  * `Gtk.Box` rather than the `unknown` a DOM renderer settles for.
  */
-export interface JsxAttributes<T> extends SlotAttribute, RawSignalAttributes {
+export interface JsxAttributes<T> extends AccessibilityAttribute, SlotAttribute, RawSignalAttributes {
     children?: ElementChild;
     ref?: T | ((el: T) => void) | undefined;
 }
@@ -100,7 +113,7 @@ export interface JsxAttributes<T> extends SlotAttribute, RawSignalAttributes {
  * leave the property unusable, so the Vue surface adds only what Vue does not —
  * and `children` is a SLOT in Vue, never a prop.
  */
-export interface VueAttributes extends SlotAttribute, RawSignalAttributes {
+export interface VueAttributes extends AccessibilityAttribute, SlotAttribute, RawSignalAttributes {
 }
 /**
  * The properties whose GObject type is a `GMenuModel`, in both spellings.

package/lib/types/conformance/at-context.d.ts

@@ -0,0 +1,31 @@
+import type Gtk from '@girs/gtk-4.0';
+/**
+ * Give this process an in-process accessibility backend, before anything asks for one.
+ *
+ * OVERWRITE is deliberate: CI sets `GTK_A11Y=none` explicitly, and honouring it would
+ * keep the vectors measuring an absent layer rather than the code under test.
+ *
+ * AND THE ORDER IS LOAD-BEARING, which is why this belongs at a test ENTRY POINT and
+ * not beside a `Gtk.init()`. GTK reads the variable lazily but exactly ONCE, at the
+ * first `get_at_context()`, and caches the answer — measured on gtk 4.22.5 starting
+ * from `GTK_A11Y=none`: set after `Gtk.init()` and before any widget is asked for its
+ * context, `test` takes; set after ONE widget has been asked, the answer is `null`
+ * forever. A module body runs after every `import` above it, so an entry point is
+ * early enough only for as long as nothing it imports touches an AT context while
+ * being evaluated. {@link withAtContext} is what NAMES the day that stops being true.
+ */
+export declare function installAccessibilityBackend(): void;
+/**
+ * The widget, or a refusal that says why an ARIA assertion about it cannot mean anything.
+ *
+ * A THROW rather than an `expect`, because the SENTENCE is the whole value here. Without
+ * it the symptom is `Expected: true (boolean) / Actual: false (boolean)`, six times over,
+ * on three OS legs at once — and that shape reads as a marshalling defect in whichever
+ * runtime those legs happen to share. It is not one; it is this.
+ *
+ * It also guards the assertions that expect FALSE, and those are the ones that make this
+ * a gate rather than a nicety: with no AT context they pass VACUOUSLY. A reset vector, a
+ * "nothing was authored here" vector — every one of them is green against a layer that
+ * was never there.
+ */
+export declare function withAtContext<T extends Gtk.Accessible>(widget: T): T;

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

@@ -1,5 +1,7 @@
 export { describeLogRecord, installDiagnosticsGate, isEnvironmentDiagnostic, type DiagnosticsGate, } from './diagnostics.js';
 export { windowChromeCensus, windowChromeProblems, type WindowChromeCensus } from './window-chrome.js';
+export { buildSharedTree } from './shared-tree-builder.js';
+export { installAccessibilityBackend, withAtContext } from './at-context.js';
 import type Gtk from '@girs/gtk-4.0';
 import type { ChildPolicy, HostElement, NodePlacement, WidgetDescriptor } from '../types.js';
 /** Every method name a policy names, so the check does not have to know the shapes. */

package/lib/types/conformance/nick-vectors.d.mts

@@ -0,0 +1,26 @@
+/** What GObject must end up holding, or the refusal that must reach the caller. */
+export type NickOutcome = {
+    readonly holds: number;
+} | {
+    readonly refuses: string;
+};
+export interface NickVector {
+    /** What this row is about — a failing row prints it. */
+    readonly what: string;
+    readonly tag: string;
+    /** Kebab, as GObject knows the property. */
+    readonly prop: string;
+    /** What a template, a JSX file or a renderer writes. */
+    readonly authored: string | number;
+    readonly outcome: NickOutcome;
+}
+/**
+ * Every edge of nick resolution, against four bitfields and three enums.
+ *
+ * MORE THAN ONE BITFIELD TYPE ON PURPOSE. `GtkInputHints` alone would prove the
+ * parser and nothing about the JOIN that finds it: the type surface reaches a
+ * bitfield through `PROP_ENUMS`, keyed by the DECLARING type, so a property inherited
+ * from an interface (`GtkEditable`) and one declared on the class itself take
+ * different routes to the same answer.
+ */
+export declare const NICK_VECTORS: readonly NickVector[];

package/lib/types/conformance/shared-tree-builder.d.ts

@@ -0,0 +1,26 @@
+import type { SharedTreeNode } from '@gjsify/adwaita-core/conformance';
+import type { HostElement } from '../types.js';
+/**
+ * A `SharedTreeNode`, realised: a tag, its authored properties, its placement, its children,
+ * in that order.
+ *
+ * Recursive and total — no tag list, no property list, no per-block case. The authored
+ * property NAMES go to `setProp` verbatim (through `createElement`), which is the point:
+ * `buttonLabel` reaching `button-label` is the host's own coercion, and a caller spelling the
+ * GObject name itself would be testing its own translation table instead of this one's.
+ *
+ * `built` COLLECTS THE ELEMENTS THIS CALL CREATED, in authored order, for a caller that has to
+ * tell them from the widgets libadwaita built AROUND them. Filtering a realised tree by CLASS
+ * cannot: the moment a corpus block authored a `GtkButton`, `AdwEntryRow`'s own apply button
+ * answered to the same name and the walk read one node too many. Identity is the only filter
+ * that stays right as the corpus grows, and only the builder knows it.
+ *
+ * THE SLOT GOES THROUGH THE SAME DOOR, and it is not a table here either. `setProp(el,
+ * 'slot', …)` is `setSlot`, and every framework adapter in this package already writes a
+ * `slot=` attribute through it; placement is then the parent descriptor's `ChildPolicy`,
+ * which refuses a name the parent has no destination for BY NAME. This builder read `tag`,
+ * `props` and `children` and dropped `slot` silently until a real `.blp` authored one — a
+ * `[top]` header bar landed in the content and the window title was then discarded by the
+ * bar's own construction, at exit 0.
+ */
+export declare function buildSharedTree(node: SharedTreeNode, built?: HostElement[]): HostElement;

package/lib/types/errors.d.ts

@@ -16,6 +16,25 @@ export declare class GtkHostError extends Error {
 }
 export declare const err: {
     unknownTag: (tag: string) => GtkHostError;
+    /**
+     * A row of the table naming a class the RUNNING typelib does not carry.
+     *
+     * The one absence a version cannot explain. The table is generated from one
+     * platform's GIR, and a platform does not BUILD every class GTK describes:
+     * the Unix print stack is `#ifdef`-ed out on Windows, so its two dialogs are
+     * in the GIR and in no `Gtk-4.0.typelib` that a Windows build produces. The
+     * generated half is a claim about a library release, not about this host, so
+     * the row is right and the class is not here — and `GtkPageSetupUnixDialog`
+     * is NOT the whole shape of the failure, because the next absent class is not
+     * spelled "Unix" either.
+     *
+     * So nothing in this host dereferences a row's class before asking: the
+     * refusal names the tag instead of letting `undefined.list_properties()` or
+     * `undefined.$gtype` report a defect against whatever row the caller happened
+     * to be walking. Same shape as `unknownTag` — a tag this process cannot
+     * honour is refused BY NAME, because GTK's own failure mode here is silence.
+     */
+    absentClass: (gtype: string) => GtkHostError;
     missingConstructProp: (tag: string, prop: string) => GtkHostError;
     unknownProp: (tag: string, prop: string) => GtkHostError;
     readOnlyProp: (tag: string, prop: string) => GtkHostError;
@@ -35,6 +54,38 @@ export declare const err: {
      */
     listModelMismatch: (tag: string, prop: string, gtypeName: string) => GtkHostError;
     badAdjustment: (tag: string, prop: string, got: string) => GtkHostError;
+    /**
+     * The `accessibility` prop given something that is not an object of ARIA names.
+     *
+     * One grouped prop, so the shape of the value is the first thing that can be wrong —
+     * and a string or an array would reach `Object.entries` and produce refusals about
+     * index names rather than about the prop.
+     */
+    badAccessibility: (tag: string, got: string) => GtkHostError;
+    unknownAria: (tag: string, name: string) => GtkHostError;
+    /**
+     * An ARIA name the SHIPPED table has and the INSTALLED GTK does not.
+     *
+     * The same version-gap question the generated widget table answers with `SINCE`, on the
+     * one axis where GTK's own failure is worst: `update_property` with an out-of-range
+     * member emits `gtk_accessible_value_collect_for_property_value: assertion failed`, then
+     * `gtk_accessible_attribute_set_remove: assertion failed`, and exits 0 (measured).
+     */
+    ariaNotInstalled: (tag: string, name: string, table: string) => GtkHostError;
+    badAriaValue: (tag: string, name: string, wants: string, got: string) => GtkHostError;
+    badAriaEnum: (tag: string, name: string, nick: string, gtypeName: string) => GtkHostError;
+    /**
+     * A relation whose value is another widget — the one part of GTK's ARIA surface this
+     * host cannot express, named rather than half-built.
+     *
+     * `Gtk.AccessibleList.new_from_list([widget])` builds exactly the value GTK wants, so
+     * the MARSHALLING is not what is missing: the ADDRESSING is. This host has no `id` prop,
+     * and `ref` is resolved by each framework AFTER the props of the element that names it
+     * are applied — so a ref read at this point is null on the render that authored it, and
+     * GTK takes a null reference at exit 0.
+     */
+    ariaReference: (tag: string, name: string) => GtkHostError;
+    notAccessible: (tag: string) => GtkHostError;
     badEnum: (tag: string, prop: string, nick: string, gtypeName: string) => GtkHostError;
     unknownSignal: (tag: string, prop: string, signal: string) => GtkHostError;
     signalTaken: (tag: string, prop: string, other: string, signal: string) => GtkHostError;
@@ -54,10 +105,38 @@ export declare const err: {
     eventModifier: (prop: string, modifier: string) => GtkHostError;
     badString: (tag: string, prop: string, got: string) => GtkHostError;
     badBoolean: (tag: string, prop: string, value: string) => GtkHostError;
+    /**
+     * A MEMBER of a flags value that names nothing — not the value as a whole.
+     *
+     * This used to refuse every string on a flags property, because resolving a nick
+     * set was nothing GObject exposed. GTK's `.ui` parser does resolve one, so what is
+     * left to refuse is the typo inside a set that otherwise reads fine, and the
+     * message has to name the SET as well as the type: `"spellcheck|lowecase"` fails
+     * on one member, and reporting only the type sends a reader looking at the wrong
+     * half of their own string.
+     */
     badFlags: (tag: string, prop: string, value: string, gtypeName: string) => GtkHostError;
-    unresolvableEnum: (gtypeName: string) => GtkHostError;
+    /**
+     * The one flags input GTK's own parser answers SILENTLY, so this host does not.
+     *
+     * Measured on GTK 4.22.4: `""` and `" "` both parse to `[true, 0]`, and a leading
+     * empty member is dropped without a word. Zero is a legal flags value, so the
+     * caller gets every flag cleared, no diagnostic and exit 0 — while `"a||b"` and
+     * `"a|"` do raise. Refusing all of them by one name keeps the stray separator a
+     * spelling mistake rather than a value.
+     */
+    blankFlags: (tag: string, prop: string, value: string, gtypeName: string) => GtkHostError;
     textNotAccepted: (tag: string, text: string) => GtkHostError;
     unclaimedChild: (parentTag: string, childTag: string) => GtkHostError;
+    /**
+     * A placement the parent has no destination for.
+     *
+     * The EMPTY case is the common one and it used to print `Known slots: .` — `ordered`,
+     * `indexed` and `none` parents declare no slot names at all, and those are exactly the
+     * parents a stray `slot=` lands on. A reader needs "this parent has none" to act; a
+     * trailing full stop after nothing reads like the message was cut off. Both other
+     * renderers already spell it out, so this is also what makes the three agree.
+     */
     unknownSlot: (parentTag: string, slot: string, known: string[]) => GtkHostError;
     /**
      * An adder-backed slot with nothing that takes the child back out.

package/lib/types/font-dir.d.ts

@@ -54,9 +54,11 @@ export declare function resolveFontSources(options?: ResolveFontSourcesOptions):
  * which is the only party that knows whether the payload became `/usr`, a `--prefix` tree, `/app`,
  * a bundle's `Contents/Resources` or a Windows program directory.
  *
- * There is NO system fallback, and that is the one place this parts company with
- * `resolveLocaleDir`, whose `/usr/share/locale` default is both correct and free. The analogous
- * `/usr/share/fonts` is neither: fontconfig has already scanned it, so walking it again would add
+ * There is NO system fallback, on ANY platform — where `resolveLocaleDir` keeps one for Linux,
+ * whose `/usr/share/locale` default is there both correct and free (it has none for darwin or
+ * win32, which have no such directory). The analogous
+ * `/usr/share/fonts` is correct on no platform: fontconfig has already scanned it, so walking it
+ * again would add
  * hundreds of `add_font_file` calls to every startup to arrive at families the font map holds
  * anyway. `undefined` therefore means "this application ships no faces of its own" — the ordinary
  * case, and a quiet one, because the launcher exports the variable only when it staged a face.

package/lib/types/fonts.d.ts

@@ -133,6 +133,17 @@ export interface InitFontsResult {
      * the map holds afterwards, which is what a match reads.
      */
     readonly matches: readonly FontFamilyMatch[];
+    /**
+     * `true` when this call REPLACED the process's default font map with a fontconfig-backed one
+     * so the faces could be registered at all — see {@link adoptFontconfigMap}.
+     *
+     * Reported because it is a whole-application consequence of one call: every widget created
+     * afterwards renders through FreeType instead of the platform rasteriser. It happens only
+     * where the default map DECLINED registration (a CoreText map — `gjsify run` on a Homebrew
+     * GTK), the faces brought a family that map does not already hold, fontconfig has a
+     * configuration of its own, and nobody pinned `PANGOCAIRO_BACKEND` (ADR 0038 § Amendment 5).
+     */
+    readonly fontconfigFallback: boolean;
 }
 /**
  * Did the font map decline runtime registration outright?
@@ -150,11 +161,26 @@ export interface InitFontsResult {
  * Keyed on the ERROR rather than on `process.platform`, which is the difference between a
  * capability test and a guess about who is asking. It costs no `gjsify.os` declaration (this
  * package makes no OS decision, and ADR 0018's candidate set is derived from the code that reads
- * the host), it stays right if a fontconfig-backed Pango is ever selected on darwin — the backend
- * is chosen by what is compiled in, not per platform, and `PANGOCAIRO_BACKEND=fc` selects one — and
- * it stays right for any other map that declines. The OS name was never the thing being asked.
+ * the host), and it stays right for any other map that declines. The OS name was never the thing
+ * being asked — which stopped being hypothetical: the backend is whichever one is selected rather
+ * than one per platform, and `@gjsify/node-gi`'s loader selects `PANGOCAIRO_BACKEND=fc` on the
+ * bundled windowing runtime (ADR 0038 § Amendment 3), so a darwin process on it reaches this
+ * arm's other side and REGISTERS the faces. A `process.platform` branch would have had to be
+ * found and reversed instead.
  */
 export declare function isUnsupportedByFontMap(error: unknown): boolean;
+/**
+ * `CAIRO_FONT_TYPE_FT` from `cairo.h` — the value `pango_cairo_font_map_new_for_font_type()` maps
+ * to its fontconfig backend.
+ *
+ * A literal rather than `gi://cairo`'s `FontType.FT`: this module runs on both legs (GJS and
+ * `@gjsify/node-gi`), and the enum is part of cairo's ABI, so importing a fourth namespace to
+ * spell one stable integer would add a load-time dependency for nothing.
+ *
+ * Exported so `fonts.spec.ts`'s independent probe spells the SAME integer rather than a second
+ * literal that could drift from this one silently — see § duplication instead of a helper.
+ */
+export declare const CAIRO_FONT_TYPE_FT = 1;
 /**
  * Register every face in the application's shipped font directory with the default font map.
  *

package/lib/types/generated/accessibility.d.ts

@@ -0,0 +1,208 @@
+import type Gtk from '@girs/gtk-4.0';
+import type { AriaSlot } from '../types.js';
+import type { GtkAccessibleAutocompleteNick, GtkAccessibleInvalidStateNick, GtkAccessibleSortNick, GtkAccessibleTristateNick, GtkOrientationNick } from './props.js';
+/**
+ * ARIA name -> the table it belongs to and the kind of value GTK collects for it.
+ *
+ * Keyed by the NAME alone: across the three tables of this GTK the names are distinct,
+ * and `girs-vocabulary.mts` fails the generation rather than emit a map that silently
+ * kept one of two. The table name is what the runtime derives its GTK call from.
+ */
+export declare const ARIA_SLOTS: Readonly<Record<string, AriaSlot>>;
+/**
+ * What `accessibility={{ … }}` accepts.
+ *
+ * ONE OBJECT PROP, NOT 53 FLAT ONES, and the decision is measured rather than
+ * stylistic. Measured in this repo's own type surface: TypeScript exempts every
+ * hyphen-containing JSX attribute from excess-property checking, so a flat `aria-labell`
+ * would be accepted in silence, while a key inside a FRESH object literal is checked —
+ * `accessibility={{ labell: 'x' }}` is TS2561, naming the key and suggesting `label`. A grouped
+ * prop is also the spelling the other surface over this same vocabulary has: a `.blp` author
+ * writes `accessibility { label: "…"; }`, and ADR 0034 exists so two surfaces over one
+ * vocabulary do not invent two spellings for one name.
+ *
+ * KEBAB, THE SPELLING GTK ITSELF USES. A second camelCase spelling would double the
+ * surface for nothing: unlike a JSX attribute, a quoted key in an object literal IS
+ * excess-property checked, so the one spelling already catches the typo.
+ *
+ * `null` clears a slot, as it does for every property on this host — `gtk_accessible_reset_*`
+ * is what GTK offers and what the host calls.
+ */
+export interface AccessibilityAttributes {
+    /**
+     * `GtkAccessibleRelation.active-descendant` — a REFERENCE to another widget, and this host has no way
+     * to name one. There is no `id` prop and `ref` is resolved by the framework after the
+     * props are applied, so the value would be `null` on the render that authors it. Declared
+     * and unwritable rather than absent: GTK has this name, the gap is ours.
+     */
+    'active-descendant'?: never;
+    /** `GtkAccessibleProperty.autocomplete` — a GtkAccessibleAutocomplete, which GTK collects as an int: the nick or the constant. */
+    autocomplete?: GtkAccessibleAutocompleteNick | Gtk.AccessibleAutocomplete | null;
+    /** `GtkAccessibleState.busy` — GTK collects it as a boolean. */
+    busy?: boolean | null;
+    /** `GtkAccessibleState.checked` — a GtkAccessibleTristate, which GTK collects as an int: the nick or the constant. */
+    checked?: GtkAccessibleTristateNick | Gtk.AccessibleTristate | null;
+    /** `GtkAccessibleRelation.col-count` — GTK collects it as an integer. */
+    'col-count'?: number | null;
+    /** `GtkAccessibleRelation.col-index` — GTK collects it as an integer. */
+    'col-index'?: number | null;
+    /** `GtkAccessibleRelation.col-index-text` — GTK collects it as a string. */
+    'col-index-text'?: string | null;
+    /** `GtkAccessibleRelation.col-span` — GTK collects it as an integer. */
+    'col-span'?: number | null;
+    /**
+     * `GtkAccessibleRelation.controlled-by` — a REFERENCE to another widget, and this host has no way
+     * to name one. There is no `id` prop and `ref` is resolved by the framework after the
+     * props are applied, so the value would be `null` on the render that authors it. Declared
+     * and unwritable rather than absent: GTK has this name, the gap is ours.
+     */
+    'controlled-by'?: never;
+    /**
+     * `GtkAccessibleRelation.controls` — a REFERENCE to another widget, and this host has no way
+     * to name one. There is no `id` prop and `ref` is resolved by the framework after the
+     * props are applied, so the value would be `null` on the render that authors it. Declared
+     * and unwritable rather than absent: GTK has this name, the gap is ours.
+     */
+    controls?: never;
+    /**
+     * `GtkAccessibleRelation.described-by` — a REFERENCE to another widget, and this host has no way
+     * to name one. There is no `id` prop and `ref` is resolved by the framework after the
+     * props are applied, so the value would be `null` on the render that authors it. Declared
+     * and unwritable rather than absent: GTK has this name, the gap is ours.
+     */
+    'described-by'?: never;
+    /** `GtkAccessibleProperty.description` — GTK collects it as a string. */
+    description?: string | null;
+    /**
+     * `GtkAccessibleRelation.description-for` — a REFERENCE to another widget, and this host has no way
+     * to name one. There is no `id` prop and `ref` is resolved by the framework after the
+     * props are applied, so the value would be `null` on the render that authors it. Declared
+     * and unwritable rather than absent: GTK has this name, the gap is ours.
+     */
+    'description-for'?: never;
+    /**
+     * `GtkAccessibleRelation.details` — a REFERENCE to another widget, and this host has no way
+     * to name one. There is no `id` prop and `ref` is resolved by the framework after the
+     * props are applied, so the value would be `null` on the render that authors it. Declared
+     * and unwritable rather than absent: GTK has this name, the gap is ours.
+     */
+    details?: never;
+    /**
+     * `GtkAccessibleRelation.details-for` — a REFERENCE to another widget, and this host has no way
+     * to name one. There is no `id` prop and `ref` is resolved by the framework after the
+     * props are applied, so the value would be `null` on the render that authors it. Declared
+     * and unwritable rather than absent: GTK has this name, the gap is ours.
+     */
+    'details-for'?: never;
+    /** `GtkAccessibleState.disabled` — GTK collects it as a boolean. */
+    disabled?: boolean | null;
+    /**
+     * `GtkAccessibleRelation.error-message` — a REFERENCE to another widget, and this host has no way
+     * to name one. There is no `id` prop and `ref` is resolved by the framework after the
+     * props are applied, so the value would be `null` on the render that authors it. Declared
+     * and unwritable rather than absent: GTK has this name, the gap is ours.
+     */
+    'error-message'?: never;
+    /**
+     * `GtkAccessibleRelation.error-message-for` — a REFERENCE to another widget, and this host has no way
+     * to name one. There is no `id` prop and `ref` is resolved by the framework after the
+     * props are applied, so the value would be `null` on the render that authors it. Declared
+     * and unwritable rather than absent: GTK has this name, the gap is ours.
+     */
+    'error-message-for'?: never;
+    /** `GtkAccessibleState.expanded` — GTK collects it as a boolean. */
+    expanded?: boolean | null;
+    /**
+     * `GtkAccessibleRelation.flow-from` — a REFERENCE to another widget, and this host has no way
+     * to name one. There is no `id` prop and `ref` is resolved by the framework after the
+     * props are applied, so the value would be `null` on the render that authors it. Declared
+     * and unwritable rather than absent: GTK has this name, the gap is ours.
+     */
+    'flow-from'?: never;
+    /**
+     * `GtkAccessibleRelation.flow-to` — a REFERENCE to another widget, and this host has no way
+     * to name one. There is no `id` prop and `ref` is resolved by the framework after the
+     * props are applied, so the value would be `null` on the render that authors it. Declared
+     * and unwritable rather than absent: GTK has this name, the gap is ours.
+     */
+    'flow-to'?: never;
+    /** `GtkAccessibleProperty.has-popup` — GTK collects it as a boolean. */
+    'has-popup'?: boolean | null;
+    /** `GtkAccessibleProperty.help-text` — GTK collects it as a string. */
+    'help-text'?: string | null;
+    /** `GtkAccessibleState.hidden` — GTK collects it as a boolean. */
+    hidden?: boolean | null;
+    /** `GtkAccessibleState.invalid` — a GtkAccessibleInvalidState, which GTK collects as an int: the nick or the constant. */
+    invalid?: GtkAccessibleInvalidStateNick | Gtk.AccessibleInvalidState | null;
+    /** `GtkAccessibleProperty.key-shortcuts` — GTK collects it as a string. */
+    'key-shortcuts'?: string | null;
+    /** `GtkAccessibleProperty.label` — GTK collects it as a string. */
+    label?: string | null;
+    /**
+     * `GtkAccessibleRelation.label-for` — a REFERENCE to another widget, and this host has no way
+     * to name one. There is no `id` prop and `ref` is resolved by the framework after the
+     * props are applied, so the value would be `null` on the render that authors it. Declared
+     * and unwritable rather than absent: GTK has this name, the gap is ours.
+     */
+    'label-for'?: never;
+    /**
+     * `GtkAccessibleRelation.labelled-by` — a REFERENCE to another widget, and this host has no way
+     * to name one. There is no `id` prop and `ref` is resolved by the framework after the
+     * props are applied, so the value would be `null` on the render that authors it. Declared
+     * and unwritable rather than absent: GTK has this name, the gap is ours.
+     */
+    'labelled-by'?: never;
+    /** `GtkAccessibleProperty.level` — GTK collects it as an integer. */
+    level?: number | null;
+    /** `GtkAccessibleProperty.modal` — GTK collects it as a boolean. */
+    modal?: boolean | null;
+    /** `GtkAccessibleProperty.multi-line` — GTK collects it as a boolean. */
+    'multi-line'?: boolean | null;
+    /** `GtkAccessibleProperty.multi-selectable` — GTK collects it as a boolean. */
+    'multi-selectable'?: boolean | null;
+    /** `GtkAccessibleProperty.orientation` — a GtkOrientation, which GTK collects as an int: the nick or the constant. */
+    orientation?: GtkOrientationNick | Gtk.Orientation | null;
+    /**
+     * `GtkAccessibleRelation.owns` — a REFERENCE to another widget, and this host has no way
+     * to name one. There is no `id` prop and `ref` is resolved by the framework after the
+     * props are applied, so the value would be `null` on the render that authors it. Declared
+     * and unwritable rather than absent: GTK has this name, the gap is ours.
+     */
+    owns?: never;
+    /** `GtkAccessibleProperty.placeholder` — GTK collects it as a string. */
+    placeholder?: string | null;
+    /** `GtkAccessibleRelation.pos-in-set` — GTK collects it as an integer. */
+    'pos-in-set'?: number | null;
+    /** `GtkAccessibleState.pressed` — a GtkAccessibleTristate, which GTK collects as an int: the nick or the constant. */
+    pressed?: GtkAccessibleTristateNick | Gtk.AccessibleTristate | null;
+    /** `GtkAccessibleProperty.read-only` — GTK collects it as a boolean. */
+    'read-only'?: boolean | null;
+    /** `GtkAccessibleProperty.required` — GTK collects it as a boolean. */
+    required?: boolean | null;
+    /** `GtkAccessibleProperty.role-description` — GTK collects it as a string. */
+    'role-description'?: string | null;
+    /** `GtkAccessibleRelation.row-count` — GTK collects it as an integer. */
+    'row-count'?: number | null;
+    /** `GtkAccessibleRelation.row-index` — GTK collects it as an integer. */
+    'row-index'?: number | null;
+    /** `GtkAccessibleRelation.row-index-text` — GTK collects it as a string. */
+    'row-index-text'?: string | null;
+    /** `GtkAccessibleRelation.row-span` — GTK collects it as an integer. */
+    'row-span'?: number | null;
+    /** `GtkAccessibleState.selected` — GTK collects it as a boolean. */
+    selected?: boolean | null;
+    /** `GtkAccessibleRelation.set-size` — GTK collects it as an integer. */
+    'set-size'?: number | null;
+    /** `GtkAccessibleProperty.sort` — a GtkAccessibleSort, which GTK collects as an int: the nick or the constant. */
+    sort?: GtkAccessibleSortNick | Gtk.AccessibleSort | null;
+    /** `GtkAccessibleProperty.value-max` — GTK collects it as a double. */
+    'value-max'?: number | null;
+    /** `GtkAccessibleProperty.value-min` — GTK collects it as a double. */
+    'value-min'?: number | null;
+    /** `GtkAccessibleProperty.value-now` — GTK collects it as a double. */
+    'value-now'?: number | null;
+    /** `GtkAccessibleProperty.value-text` — GTK collects it as a string. */
+    'value-text'?: string | null;
+    /** `GtkAccessibleState.visited` — GTK collects it as a boolean. */
+    visited?: boolean | null;
+}

package/lib/types/generated/enum-values.d.mts

@@ -5,7 +5,7 @@
  * A value, not only a header comment: `generated.spec.ts` compares it with the
  * running library to decide whether a disagreement is a defect or a version gap.
  */
-export declare const VALUES_PROVENANCE = "Adw-1/1.9.3 Gtk-4.0/4.22.4 Pango-1.0/1.57.1";
+export declare const VALUES_PROVENANCE = "Adw-1/1.9.3 Gio-2.0 Gtk-4.0/4.22.4 Pango-1.0/1.57.1";
 /** `<enum GType>.<nick>` -> the integer the library registers for it. */
 export declare const ENUM_VALUES: Readonly<Record<string, number>>;
 /**