@gjsify/gtk-host 0.44.0 → 0.46.0

package/lib/types/style/document.d.ts

@@ -0,0 +1,22 @@
+import Gdk from 'gi://Gdk?version=4.0';
+import Gtk from 'gi://Gtk?version=4.0';
+/** A document GTK refused, or one that would have discarded what follows it. */
+export declare class StyleSheetError extends Error {
+    readonly name = "StyleSheetError";
+    constructor(message: string);
+}
+/**
+ * Refuse a document that would take everything after it with it.
+ *
+ * `subject` names what is being loaded, because the two callers have very different
+ * readers: a generated rule is this package's bug, and an application's theme
+ * document is the application's.
+ */
+export declare function assertContained(document: string, subject: string): void;
+/**
+ * Put a provider on a display at `priority`, and say which display that was.
+ *
+ * `subject` names what is being installed, because the failure a caller has to act
+ * on is "there is no display yet" and the fix depends on which document it is.
+ */
+export declare function installProvider(provider: Gtk.CssProvider, subject: string, display: Gdk.Display | null | undefined, priority: number): Gdk.Display;

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

@@ -1,13 +1,16 @@
 export { GTK_CSS_PROBES, GTK_CSS_PROPERTIES, NOT_GTK_CSS } from './gtk-css.js';
 export { GTK_WIDGET_PROPERTIES, GTK_WIDGET_PROPERTY_PROBES, NOT_GTK_WIDGET_PROPERTIES } from './gtk-props.js';
-export { MINIMAL_TOKENS, lookupToken, requireToken } from './tokens.js';
+export { MINIMAL_TOKENS, TAILWIND_DEFAULT_TOKENS, lookupToken, mergeTokens, requireToken, tailwindDefaultHint, } from './tokens.js';
 export type { Scale, StyleTokens } from './tokens.js';
 export { UnknownUtilityError } from './errors.js';
 export { PAINT_PROPERTIES, partitionPaint, resolvePaintUtility } from './paint.js';
 export type { PaintProps } from './paint.js';
 export { LAYOUT_PROPERTIES, partitionLayout, resolveLayoutUtility } from './layout.js';
-export type { AlignValue, Edge, JustifyValue, LayoutIntent, LayoutPartition, LayoutProps, OverlayIntent, } from './layout.js';
+export type { AlignValue, Edge, JustifyValue, LayoutIntent, LayoutPartition, LayoutProps, OverlayIntent, WrapIntent, } from './layout.js';
 export { partition, resolveUtilities, resolveUtility } from './resolve.js';
 export type { Partitioned, StyleProps } from './resolve.js';
-export { StyleSheet, StyleSheetError, VARIANT_PSEUDO } from './sheet.js';
+export { StyleSheet, VARIANT_PSEUDO } from './sheet.js';
 export type { StyleSheetOptions } from './sheet.js';
+export { assertContained, StyleSheetError } from './document.js';
+export { ADWAITA_NAMED_COLORS, NEUTRAL_THEME, NOT_ADWAITA_NAMED_COLORS, THEME_PROVIDER_PRIORITY, ThemeRegistry, } from './theme.js';
+export type { Theme, ThemeRegistryOptions } from './theme.js';

package/lib/types/style/layout.d.ts

@@ -27,6 +27,7 @@ export interface LayoutProps {
     paddingBottom?: string;
     paddingLeft?: string;
     flexDirection?: 'row' | 'column';
+    flexWrap?: 'nowrap' | 'wrap';
     flexGrow?: string;
     alignItems?: AlignValue;
     justifyContent?: JustifyValue;
@@ -114,6 +115,25 @@ export interface LayoutIntent {
      * `relative` would make it undetectable.
      */
     readonly overlay?: OverlayIntent;
+    /**
+     * `flex-wrap` — the element becomes a DIFFERENT WIDGET.
+     *
+     * A `Gtk.Box` lays its children on one line and has no second line to put
+     * anything on. Wrapping on GTK is `Gtk.FlowBox`, which is not another property
+     * on the box but another class — so this is the same shape as
+     * {@link LayoutIntent.distribute}'s `space-between`: L1 names the widget the
+     * answer needs and L2 swaps it, because L1 resolves properties for an element
+     * and has no say in what the element becomes.
+     *
+     * The SPACINGS travel with it, and that is the reason this field carries values
+     * at all rather than being a flag. `Gtk.FlowBox` has NO `spacing` (measured,
+     * `gtk-props.ts`) — it has `row-spacing` and `column-spacing`, both real at once
+     * — so a gap on a wrapping element cannot take the `Gtk.Box:spacing` route the
+     * gap routes below use, and the axis-qualified spellings stop being an
+     * orientation question. Routing them here is what keeps `gap-*` from emitting a
+     * property the widget does not install.
+     */
+    readonly wrap?: WrapIntent;
     /**
      * `text-*` — only a text widget aligns text.
      *
@@ -124,6 +144,20 @@ export interface LayoutIntent {
      */
     readonly textAlign?: 'left' | 'center' | 'right' | 'justify';
 }
+/**
+ * `flex-nowrap` / `flex-wrap`, with the spacings a wrapping widget needs.
+ *
+ * `single` is carried rather than dropped for the reason `relative` is: it is the
+ * half L2 can hold the other half against, and a resolution that never sees it
+ * cannot tell "this element does not wrap" from "nobody asked".
+ */
+export type WrapIntent = {
+    readonly lines: 'single';
+} | {
+    readonly lines: 'multi';
+    readonly rowSpacing?: number;
+    readonly columnSpacing?: number;
+};
 export type OverlayIntent = {
     readonly role: 'context';
 } | {

package/lib/types/style/sheet.d.ts

@@ -1,11 +1,6 @@
 import Gdk from 'gi://Gdk?version=4.0';
 /** A variant this sheet knows how to express, and the pseudo-class it becomes. */
 export declare const VARIANT_PSEUDO: Readonly<Record<string, string>>;
-/** A rule GTK refused, or one that would have poisoned the document. */
-export declare class StyleSheetError extends Error {
-    readonly name = "StyleSheetError";
-    constructor(message: string);
-}
 export interface StyleSheetOptions {
     /**
      * Where the provider is installed. Omitted means the default display — the

package/lib/types/style/theme.d.ts

@@ -0,0 +1,158 @@
+import Gdk from 'gi://Gdk?version=4.0';
+/**
+ * Where a theme document is installed. See decision 2 for why it is this number.
+ *
+ * Exported because it is the fact a reader has to check against their own providers,
+ * and because a consumer installing a fourth document needs to know what it has to
+ * sit between.
+ */
+export declare const THEME_PROVIDER_PRIORITY: number;
+/**
+ * The named colours libadwaita defines, measured rather than read.
+ *
+ * MEASURED on libadwaita 1.9.3 by resolving `var(--<name>, <sentinel>)` on a real
+ * widget and checking the sentinel did NOT come back — the only test that
+ * distinguishes "the name exists" from "the name is a typo that defines nothing".
+ * `theme.spec.ts` re-measures both directions against the libadwaita that is
+ * running, so a release that renames one goes red here rather than in a window.
+ *
+ * The list is what a theme may OVERRIDE, and overriding a name libadwaita does not
+ * define is the exact silent failure this set exists to catch: `--acccent-bg-color`
+ * is a perfectly valid custom property that nothing ever reads.
+ */
+export declare const ADWAITA_NAMED_COLORS: readonly string[];
+/**
+ * Names that are NOT custom properties, and the claim each one carries.
+ *
+ * Without this direction the set above could name every string in GTK and still
+ * pass. `borders` is the interesting row: it is a real Adwaita colour under the
+ * LEGACY `@define-color` mechanism and is not a CSS variable, which is exactly the
+ * confusion decision 1 is about. `accent_bg_color` is the same point in the other
+ * spelling — the underscored legacy name of a variable that does exist.
+ */
+export declare const NOT_ADWAITA_NAMED_COLORS: readonly string[];
+/** One named look: a GTK CSS document, a palette, and which desktops default to it. */
+export interface Theme {
+    /** How the application asks for it. Also what a refusal names. */
+    readonly name: string;
+    /**
+     * The application's own GTK CSS document.
+     *
+     * Goes through the same containment probe as a generated rule, and for a
+     * stronger reason: this is the document this package did not write.
+     */
+    readonly css?: string;
+    /**
+     * Adwaita named colours to redefine, WITHOUT the `--` prefix.
+     *
+     * `{ 'accent-bg-color': 'rgb(53 132 228)' }`. Emitted as a `:root` block ahead of
+     * {@link Theme.css}, so a rule in {@link Theme.css} redefining one of these names
+     * WINS — the last definition in a document is the one that applies.
+     */
+    readonly namedColors?: Readonly<Record<string, string>>;
+    /**
+     * The `process.platform` values this theme is the default for, or `'*'` for any.
+     *
+     * Data on the theme rather than a table in the registry, because "this look
+     * belongs on macOS" is a fact about the look.
+     *
+     * `'*'` exists because `process.platform` has more values than the three desktops
+     * this project targets — `freebsd`, `openbsd`, `android`, `sunos`, … — and GTK
+     * runs on several of them. A registry that only knew `linux`/`darwin`/`win32`
+     * would make `selectDefault(process.platform)`, the call this seam is documented
+     * with, THROW on a platform where nothing is wrong. A fallback theme says so once
+     * instead, and a named theme still wins over it by being registered later.
+     */
+    readonly defaultOn?: readonly string[];
+}
+/**
+ * The one theme shipped now, and it deliberately changes nothing.
+ *
+ * A GTK application should look like the desktop it is running on, and the accent is
+ * the user's — they picked it in Settings and expect their applications to use it.
+ * So the neutral theme is an EMPTY document, and that is a statement rather than a
+ * placeholder: selecting it is how an application returns to Adwaita exactly, which
+ * is measurably true because reloading the provider to the empty string restores
+ * every named colour to libadwaita's own value.
+ *
+ * It is also what makes the registry useful with one theme registered: there is
+ * always something to switch back TO.
+ */
+export declare const NEUTRAL_THEME: Theme;
+export interface ThemeRegistryOptions {
+    /**
+     * Where the provider is installed. Omitted means the default display — the right
+     * answer for an application and the wrong one for a test, which is why it is
+     * injectable at all.
+     */
+    readonly display?: Gdk.Display | null;
+    /** Provider priority. Defaults to {@link THEME_PROVIDER_PRIORITY}; see decision 2. */
+    readonly priority?: number;
+}
+/**
+ * Named themes, one selected, swapped on a single provider.
+ *
+ * NOT a module-level singleton, unlike the token configuration one layer up. A
+ * registry holds a `Gdk.Display` and a `Gtk.CssProvider`, so a test that could not
+ * make its own would have to share the session's — and the registry is exactly the
+ * object whose whole behaviour is "what is installed on the display right now".
+ */
+export declare class ThemeRegistry {
+    #private;
+    constructor(options?: ThemeRegistryOptions);
+    /**
+     * Add a theme, refusing anything that would be a silent no-op.
+     *
+     * The document is PROBED here rather than at selection, so the error names the
+     * line that declared the theme instead of the line that switched to it — which
+     * may be a user clicking a row in the application's settings, hours later.
+     */
+    register(theme: Theme): this;
+    /** The registered names, in registration order. */
+    get names(): readonly string[];
+    /** The selected theme's name, or null before anything is selected. */
+    get current(): string | null;
+    /** The document a theme produces. Exposed because a test that cannot read it proves nothing. */
+    documentOf(theme: Theme): string;
+    /**
+     * Switch to a registered theme, replacing whatever was loaded.
+     *
+     * Idempotent, and cheap enough to call from a settings row's handler: the
+     * document was probed at registration, so this is one `load_from_string` plus, on
+     * the first call only, one `add_provider_for_display`.
+     */
+    select(name: string): void;
+    /**
+     * Select the theme that declares itself the default for `platform`.
+     *
+     * The platform is a PARAMETER and this module never reads `process.platform`
+     * itself — the same discipline the intent seam one layer up argues for. It keeps
+     * a `process` read (and the OS declaration that comes with one) out of a package
+     * whose job is GTK, and it lets a settings screen preview another desktop's look
+     * by passing that desktop's name.
+     *
+     * The last registered match wins, so an application registering its own theme
+     * after the neutral one gets its own — including over a theme that declares
+     * `'*'`, which is how the shipped neutral default stays a fallback rather than a
+     * ceiling.
+     */
+    selectDefault(platform: string): void;
+    /**
+     * Take the theme document off the display, leaving nothing behind.
+     *
+     * Selecting the neutral theme reloads the document to empty, which is all an
+     * application needs. It is NOT all a TEST needs, and the difference was measured
+     * in this file's own spec: a vector that read "libadwaita's own accent" read the
+     * PREVIOUS vector's green instead, because that registry's provider was still on
+     * the shared display with a `--accent-bg-color` in it — and the assertion named
+     * "back to Adwaita exactly" then passed against the green. Ownership belongs with
+     * whoever created the registry, so there has to be a way to give it up.
+     *
+     * The provider is removed from the display it was INSTALLED on rather than from
+     * whatever `Gdk.Display.get_default()` answers now. A later `select()` installs
+     * again: position relative to the generated sheet is decided by the priority
+     * numbers, not by insertion order, so re-installing cannot land in the wrong
+     * place (decision 2).
+     */
+    dispose(): void;
+}

package/lib/types/style/theme.spec.d.ts

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

package/lib/types/style/tokens.d.ts

@@ -43,8 +43,84 @@ export interface StyleTokens {
  * scale would let a project's typo resolve against a value nobody chose, which is
  * the failure the declared-vocabulary rule exists to prevent — and it would make
  * "the values come from the project" false in the common case.
+ *
+ * That decision stands, and {@link TAILWIND_DEFAULT_TOKENS} is not a retreat from
+ * it: the measured gap is that a project REPLACING this default with its own
+ * generated scales loses `0` and `full`, which nothing in its `@theme` was ever
+ * going to declare. The answer is an opt-in a reader can see in their own code, not
+ * a wider default nobody chose. This constant stays as small as it is.
  */
 export declare const MINIMAL_TOKENS: StyleTokens;
+/**
+ * The Tailwind defaults a project's own `@theme` does not replace — OPT-IN.
+ *
+ * MEASURED, and this is the highest-frequency finding of the whole exercise. Running
+ * one production-shaped application's real class vocabulary — 87 distinct utilities,
+ * 826 occurrences — through this partition with tokens generated mechanically from
+ * its Tailwind v4 `@theme` resolves **81 of 87 distinct and 803 of 826 occurrences**.
+ * Five of the six failures are one thing: `rounded-full` (11 uses) and
+ * `inset-0`/`left-0`/`right-0`/`top-0` (9 between them). The project's declared
+ * scales simply have no `full` and no `0`.
+ *
+ * They have no reason to. **`0` and `full` are not design decisions.** A token source
+ * emits the values a designer chose; `inset-0` means "flush" and `rounded-full` means
+ * "a pill", and neither is a number anybody picked. A project that declares its whole
+ * palette still leans on Tailwind for the STRUCTURAL tokens, and finds out one class
+ * at a time.
+ *
+ * So this set is deliberately NOT a copy of Tailwind's default theme, and the name
+ * would be a lie if it carried the numeric ladder: shipping `spacing-4` … `spacing-96`
+ * would be shipping a design decision the project has already made differently, which
+ * is the opposite of the point. It carries the structural tokens and the keyword sets
+ * — the ones a `@theme` has no reason to name — and nothing that is a value someone
+ * chose.
+ *
+ * THREE DIVERGENCES FROM TAILWIND'S OWN NUMBERS, each forced and each measured:
+ *
+ *   - **Every length is px, not rem.** Tailwind v4's spacing is rem-based. A `rem`
+ *     token reaches CSS padding unchanged and is a NAMED ERROR the moment the same
+ *     token is asked to become a margin, because `Gtk.Widget:margin-top` is a `gint`
+ *     of device pixels with no unit conversion behind it. A rem scale here would
+ *     therefore trade "the token is missing" for "the token throws on half the
+ *     families", which is worse.
+ *   - **`full` is `9999px`, not `calc(infinity * 1px)`.** GTK's parser has no
+ *     infinity, and a border radius larger than the box is clamped anyway.
+ *   - **`inherit` is absent from the colours.** `color: inherit` parses, but
+ *     `alpha(inherit, 0.5)` does not (measured: *"inherit" is not a valid color
+ *     name*), so `bg-inherit/50` would be a refusal rather than a colour. The other
+ *     four keywords survive the alpha modifier and are carried.
+ *
+ * Opting in is a VISIBLE LINE in the consumer's code, which is the whole design:
+ *
+ * ```ts
+ * configureStyle({ tokens: mergeTokens(TAILWIND_DEFAULT_TOKENS, projectTokens) });
+ * ```
+ *
+ * Use {@link mergeTokens} and not a spread. `{ ...TAILWIND_DEFAULT_TOKENS,
+ * ...projectTokens }` replaces whole SCALES, so a project declaring any `spacing` at
+ * all loses `0` again — which is the exact bug this constant exists to answer.
+ */
+export declare const TAILWIND_DEFAULT_TOKENS: StyleTokens;
+/**
+ * Several token sets into one, merging PER TOKEN and not per scale.
+ *
+ * The distinction is the whole function. `{ ...defaults, ...project }` is an object
+ * spread over the SCALE names, so a project that declares any `spacing` replaces the
+ * default `spacing` wholesale and loses `0` — silently, and visible only as
+ * `inset-0` throwing much later. Later sets win token by token, which is what a
+ * reader means by "my values on top of the defaults".
+ */
+export declare function mergeTokens(...sets: readonly StyleTokens[]): StyleTokens;
+/**
+ * The sentence a scale-miss error adds when Tailwind's defaults DO define the token.
+ *
+ * The measured six failures each become a one-line fix with this and stay a search
+ * without it: "not in the borderRadius scale. Known: l, m, s" sends a reader to
+ * invent a radius, where naming the opt-in sends them to the line that was missing.
+ * Empty for a token nothing would have answered, so an ordinary typo is not offered
+ * a remedy that would not have helped.
+ */
+export declare function tailwindDefaultHint(scaleName: string, token: string): string;
 /** A token's value, or `undefined` when the scale is absent or does not carry it. */
 export declare const lookupToken: (scale: Scale | undefined, token: string) => string | undefined;
 /**

package/lib/types/style/tokens.spec.d.ts

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

package/lib/types/types.d.ts

@@ -117,12 +117,43 @@ export type ChildPolicy = {
     remove: string;
     wrap: 'list-box-row' | 'flow-box-child' | null;
 }
-/** `Adw.HeaderBar`, `Adw.ToolbarView`, `Adw.ActionRow`: named attachment points. */
+/**
+ * `Adw.HeaderBar`, `Adw.ToolbarView`, `Adw.ActionRow`: named attachment points.
+ *
+ * `remove` is OPTIONAL because a slot can be backed two ways and only one of them
+ * needs it. A `set_`-prefixed slot is emptied by writing `null` back through the
+ * same setter (`detachChild` already does exactly that, via `setterSlotOf`), so a
+ * policy whose slots are ALL setters never reaches a remove method — and
+ * `Adw.NavigationSplitView` / `Adw.OverlaySplitView` have none to name: measured on
+ * libadwaita 1.9.3, their only `remove*` methods are `GtkWidget`'s
+ * (`remove_controller`, `remove_css_class`, …). Declaring `remove: 'remove'` there
+ * would be a claim `descriptorProblems()` correctly rejects.
+ *
+ * An ADDER-backed slot (`add_top_bar`, `pack_start`) is the opposite: nothing takes
+ * a child back out of it but a remove method, so `remove` is REQUIRED the moment one
+ * slot does not start with `set_`. That rule is machine-checked in `policyProblems()`
+ * rather than left to this comment — optional in the type and unchecked would turn
+ * `Adw.ToolbarView` losing its `remove` into a `TypeError` deep inside an unmount.
+ */
  | {
     kind: 'slotted';
     slots: Record<string, string>;
     defaultSlot: string;
-    remove: string;
+    remove?: string;
+    /**
+     * Slots whose adder hands the child to an inner `Gtk.ListBox`, and which
+     * therefore need the same wrap `indexed` declares — keyed by slot, because a
+     * widget can have one such slot and two ordinary ones.
+     *
+     * MEASURED on GTK 4.22.4, and it is the wrap or a leak: `gtk_list_box_remove`
+     * does NOT unwrap. A `Gtk.ListBox` given a non-row child puts it inside an
+     * implicit `GtkListBoxRow`, and removing the ORIGINAL child then answers
+     * `Gtk-WARNING **: Tried to remove non-child 0x…` and leaves it parented —
+     * with a plain `Gtk.Label` and with a `Gtk.Button` alike. `Adw.ExpanderRow`'s
+     * `add_row` is that adder, so its disclosure slot declares the wrap and the
+     * host addresses the row it made.
+     */
+    wrapSlots?: Readonly<Record<string, 'list-box-row'>>;
 }
 /**
  * `Gtk.Stack`, `Adw.NavigationView`: children addressed by name/tag.
@@ -139,6 +170,55 @@ export type ChildPolicy = {
     remove: string;
     nameFrom: string;
     titled: boolean;
+    /**
+     * Take the child out of view BEFORE the parent removes it, and put its
+     * own `visible` back afterwards. Declared per widget, because it is a
+     * defect in one of them rather than a property of being keyed.
+     *
+     * The defect is libadwaita's. `stack_remove` — what both
+     * `adw_view_stack_remove` and dispose call — clears `visible_child`, then
+     * does `g_clear_object (&page->widget)`, and never touches
+     * `last_visible_child`, which can still point at that same page. A later
+     * reader then dereferences a page whose widget is NULL:
+     *
+     *     Gtk-CRITICAL **: gtk_widget_set_child_visible: assertion 'GTK_IS_WIDGET (widget)' failed
+     *
+     * Source: `refs/libadwaita/src/adw-view-stack.c` — `stack_remove` at 1184,
+     * the stale read at 934 in `transition_done_cb`. Read at 42f647f
+     * (1.10.alpha.1); that file is byte-identical at the 1.9.3 tag, which is
+     * what is installed here, so one reading covers both.
+     *
+     * MEASURED on libadwaita 1.9.3 / GTK 4.22.4 / GJS 1.88.1. Reproducer, no
+     * renderer involved: add `a` and `b`, present a window holding the stack,
+     * `set_visible_child_name('b')`, `remove(a)`, then let the window go away.
+     * Each precondition alone is silent, a stack never made visible included —
+     * `set_visible_child` only records `last_visible_child` when
+     * `gtk_widget_is_visible` answers yes. `Gtk.Stack` and
+     * `Adw.NavigationView`, the other two `keyed` descriptors, do not
+     * reproduce it at all, which is why this is a field and not the kind.
+     *
+     * WHICH read fires decides what a test has to do, so it is measured rather
+     * than listed: the UNMAP one. `AdwAnimation` connects `adw_animation_skip`
+     * to its widget's `unmap` (`adw-animation.c`) and the skip runs
+     * `transition_done_cb`, so merely hiding the window is enough and
+     * destroying it does the same — while a queued resize plus draw, and a
+     * direct `measure()`, both stayed quiet. The file's other reads (snapshot,
+     * size-allocate, measure) are real paths this reproducer does not reach.
+     *
+     * Hiding first is libadwaita's OWN cleanup: the visibility notify runs
+     * `update_child_visible`, which does clear `last_visible_child`. Measured
+     * SUFFICIENT and not merely necessary — 400 randomised
+     * add/remove/switch/reorder steps against a live 200 ms transition, three
+     * seeds, 44/23/25 criticals unpatched against 0/0/0 patched.
+     *
+     * The restore is load-bearing. `reorderMode` answers `remove-all` for
+     * `keyed`, and measured, a reversal that hides without restoring leaves the
+     * stack with no visible child and no way back: the last line of
+     * `adw_view_stack_set_visible_child_name` is
+     * `if (gtk_widget_get_visible (page->widget)) set_visible_child (...)`, so
+     * for a hidden page it is a no-op with no warning at all.
+     */
+    hideBeforeRemove?: boolean;
 }
 /** `Gtk.Grid`: position is data on the child, so document order carries nothing. */
  | {
@@ -150,14 +230,14 @@ export type ChildPolicy = {
  * Generated, not curated: the tag exists, its placement rule does not.
  *
  * The generated table adds every concrete GtkWidget descendant the GIR
- * describes — 164 of them — while the curated table measures placement for a
+ * describes, plus the placement carriers, while the curated table measures placement for a
  * fraction. Guessing an adder for the rest would be the worst of the three
  * options: `add` and `append` and `set_child` all exist somewhere in GTK, and
  * calling the wrong one is a warning at exit 0.
  *
  * So the honest state is spelled out. Such a widget can be CREATED and given
  * properties and handlers; inserting a child raises a named error that says
- * which tag needs a curated policy. A leaf widget — most of the 164 — needs
+ * which tag needs a curated policy. A leaf widget — most of the table — needs
  * nothing more.
  */
  | {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gjsify/gtk-host",
-    "version": "0.44.0",
+    "version": "0.46.0",
     "description": "Framework-agnostic GTK4/Adwaita host: the element model UI-framework renderers bind to",
     "type": "module",
     "module": "lib/esm/index.js",
@@ -14,6 +14,10 @@
             "types": "./lib/types/style/index.d.ts",
             "default": "./lib/esm/style/index.js"
         },
+        "./list": {
+            "types": "./lib/types/list/index.d.ts",
+            "default": "./lib/esm/list/index.js"
+        },
         "./vue": {
             "types": "./lib/types/adapters/vue.d.ts",
             "default": "./lib/esm/adapters/vue.js"
@@ -67,11 +71,11 @@
         "build:gjsify": "gjsify build --library 'src/**/*.{ts,js}' --exclude 'src/**/*.spec.{mts,ts}' 'src/test.{mts,ts}'",
         "build:types": "gjsify tsc",
         "build:test": "gjsify run build:test:gjs",
-        "build:test:node": "gjsify build src/test.mts --app node --outfile dist/test.node.mjs --define '__VUE_OPTIONS_API__=false' --define '__VUE_PROD_DEVTOOLS__=false' --define '__VUE_PROD_HYDRATION_MISMATCH_DETAILS__=false' --define 'process.env.NODE_ENV=\"production\"' --exclude-globals navigator",
-        "build:test:gjs": "gjsify build src/test.mts --app gjs --outfile test.gjs.mjs --define '__VUE_OPTIONS_API__=false' --define '__VUE_PROD_DEVTOOLS__=false' --define '__VUE_PROD_HYDRATION_MISMATCH_DETAILS__=false' --define 'process.env.NODE_ENV=\"production\"' --exclude-globals navigator",
+        "build:test:node": "gjsify build src/test.mts --app node --outfile dist/test.node.mjs --define __VUE_OPTIONS_API__=false --define __VUE_PROD_DEVTOOLS__=false --define __VUE_PROD_HYDRATION_MISMATCH_DETAILS__=false --define \"process.env.NODE_ENV='production'\" --exclude-globals navigator",
+        "build:test:gjs": "gjsify build src/test.mts --app gjs --outfile test.gjs.mjs --define __VUE_OPTIONS_API__=false --define __VUE_PROD_DEVTOOLS__=false --define __VUE_PROD_HYDRATION_MISMATCH_DETAILS__=false --define \"process.env.NODE_ENV='production'\" --exclude-globals navigator",
         "test": "gjsify run build:gjsify && gjsify run build:test && gjsify run test:gjs",
         "test:gjs": "gjsify run test.gjs.mjs",
-        "test:gjs-on-node": "gjsify run build:gjsify && gjsify run build:test:node && NODE_GI_NATIVE=${NODE_GI_NATIVE:-prebuild} node dist/test.node.mjs",
+        "test:gjs-on-node": "gjsify run build:gjsify && gjsify run build:test:node && node dist/test.node.mjs",
         "generate": "gjsify build src/generator/main.mts --app gjs --outfile tmp/generate.gjs.mjs && gjsify run tmp/generate.gjs.mjs -- --out src/generated && gjsify format src/generated"
     },
     "keywords": [
@@ -82,14 +86,14 @@
         "host"
     ],
     "dependencies": {
-        "@girs/adw-1": "^4.1.0",
-        "@girs/gdk-4.0": "^4.1.0",
-        "@girs/gio-2.0": "^4.1.0",
-        "@girs/gjs": "^4.1.0",
-        "@girs/glib-2.0": "^4.1.0",
-        "@girs/gobject-2.0": "^4.1.0",
-        "@girs/gtk-4.0": "^4.1.0",
-        "@girs/pango-1.0": "^4.1.0"
+        "@girs/adw-1": "4.6.0",
+        "@girs/gdk-4.0": "4.6.0",
+        "@girs/gio-2.0": "4.6.0",
+        "@girs/gjs": "4.6.0",
+        "@girs/glib-2.0": "4.6.0",
+        "@girs/gobject-2.0": "4.6.0",
+        "@girs/gtk-4.0": "4.6.0",
+        "@girs/pango-1.0": "4.6.0"
     },
     "peerDependencies": {
         "@vue/runtime-core": "^3.5.0",
@@ -112,13 +116,12 @@
         }
     },
     "devDependencies": {
-        "@gjsify/cli": "^0.44.0",
+        "@gjsify/cli": "^0.46.0",
         "@vue/runtime-core": "^3.5.0",
         "solid-js": "^1.9.0",
-        "@gjsify/unit": "^0.44.0",
+        "@gjsify/unit": "^0.46.0",
         "@types/node": "^25.9.2",
         "typescript": "^6.0.3",
-        "@gjsify/domparser": "^0.44.0",
         "@gjsify/node-gi": "file:../../node-gi/node-gi",
         "vue": "^3.5.41",
         "vue-tsc": "^3.3.11",
@@ -134,7 +137,10 @@
             "browser": "none",
             "nativescript": "none"
         },
-        "tier": 3
+        "tier": 3,
+        "widgetVocabulary": {
+            "role": "reference"
+        }
     },
     "license": "MIT",
     "repository": {