@gtkx/testing 2.0.0-beta.3 → 2.0.0-beta.4

package/src/screenshot.ts

@@ -9,6 +9,7 @@ import { getConfig } from "./config.js";
 import { now } from "./timers.js";
 import { descendants } from "./traversal.js";
 import { waitFor } from "./wait-for.js";
+import { requireWidget } from "./widget-target.js";
 import { activeToplevel, mappedToplevels } from "./window-state.js";
 
 type FrameProbe = {
@@ -301,7 +302,8 @@ const captureUntilPaintable = (
  * @param options Optional scale, timeout, retry interval, and output path.
  * @returns The base64-encoded PNG data along with its mime type and dimensions.
  */
-const screenshot = async (widget: Gtk.Widget, options?: ScreenshotOptions): Promise<ScreenshotResult> => {
+const screenshot = async (target: Gtk.Accessible, options?: ScreenshotOptions): Promise<ScreenshotResult> => {
+    const widget = requireWidget(target);
     const scale = options?.scale ?? 1;
 
     if (!Number.isFinite(scale) || scale <= 0) {

package/src/suggestions.ts

@@ -9,6 +9,7 @@ import {
     getWidgetOwnLabel,
     getWidgetPlaceholderText,
 } from "./widget-accessible-properties.js";
+import { requireWidget } from "./widget-target.js";
 
 /** The query variant a suggestion targets. */
 type Variant = "get" | "getAll" | "query" | "queryAll" | "find" | "findAll";
@@ -75,10 +76,11 @@ const textSuggestion = (queryName: Method, variant: Variant, value: string | nul
  * @returns The best available suggestion, or undefined when no query applies.
  */
 const getSuggestedQuery = (
-    widget: Gtk.Widget,
+    target: Gtk.Accessible,
     variant: Variant = "get",
     method?: Method,
 ): Suggestion | undefined => {
+    const widget = requireWidget(target);
     const builders: Record<Method, () => Suggestion | undefined> = {
         Role: () => roleSuggestion(widget, variant),
         LabelText: () =>

package/src/traversal.ts

@@ -4,14 +4,14 @@ import * as Gtk from "@gtkx/gi/gtk";
  * A scope that resolves to a single root widget: the widget itself, the widget a controller or
  * layout manager is attached to, or a list item's or header's child.
  */
-type QueryContainer = Gtk.Widget | Gtk.EventController | Gtk.LayoutManager | Gtk.ListItem | Gtk.ListHeader;
+type QueryContainer = Gtk.Accessible | Gtk.EventController | Gtk.LayoutManager | Gtk.ListItem | Gtk.ListHeader;
 /**
  * A scope that queries and traversal can run against: a widget, an event
  * controller, a layout manager, a list item or header, an application, or the
  * sentinel representing all current toplevel windows.
  */
 type Container = QueryContainer | Gtk.Application | typeof TOPLEVELS;
-type WidgetClass<T extends Gtk.Widget> = abstract new (...args: never[]) => T;
+type WidgetClass<T extends object> = abstract new (...args: never[]) => T;
 
 /** Container sentinel that widens a query to every toplevel window currently open. */
 const TOPLEVELS: unique symbol = Symbol("gtkx.toplevels");
@@ -60,7 +60,7 @@ const ancestors = function* (widget: Gtk.Widget): Generator<Gtk.Widget> {
     }
 };
 
-const ancestorFor = <T extends Gtk.Widget>(widget: Gtk.Widget, type: WidgetClass<T>): T | null => {
+const ancestorFor = <T extends object>(widget: Gtk.Widget, type: WidgetClass<T>): T | null => {
     for (const ancestor of ancestors(widget)) {
         if (ancestor instanceof type) {
             return ancestor;
@@ -98,7 +98,7 @@ const resolveRoot = (container: QueryContainer): Gtk.Widget | null => {
         return container.getChild();
     }
 
-    return null;
+    throw new TypeError("Query container must resolve to a Gtk.Widget");
 };
 
 const roots = function* (container: Container): Generator<Gtk.Widget> {

package/src/types.ts

@@ -15,9 +15,11 @@ type Matcher = string | number | RegExp | MatcherFunction;
 type NormalizerFn = (text: string) => string;
 /**
  * A widget class usable as a query's `as` constraint, such as `Gtk.Button`. Abstract classes and
- * generated GInterface pseudo-classes are accepted.
+ * generated GInterface pseudo-classes that extend `Gtk.Accessible` are accepted.
  */
-type WidgetType<T extends Gtk.Widget = Gtk.Widget> = abstract new (...args: never[]) => T;
+type WidgetType<T extends Gtk.Accessible = Gtk.Accessible> = abstract new (
+    ...args: never[]
+) => T;
 
 /** Options controlling the default text normalizer. */
 type NormalizerOptions = {
@@ -40,7 +42,7 @@ type WaitForOptions = {
 };
 
 /** Options controlling text matching and, for asynchronous queries, polling behavior. */
-type MatcherOptions<T extends Gtk.Widget = Gtk.Widget> = {
+type MatcherOptions<T extends Gtk.Accessible = Gtk.Accessible> = {
     /** When true (the default), require an exact match; when false, match case-insensitively as a substring. */
     exact?: boolean | undefined;
     /** Custom normalizer replacing the default; cannot be combined with `trim` or `collapseWhitespace`. */
@@ -74,7 +76,7 @@ type ByRoleValue = {
 };
 
 /** Options for role queries: an accessible name matcher plus accessible state and value constraints. */
-type ByRoleOptions<T extends Gtk.Widget = Gtk.Widget> = MatcherOptions<T> & {
+type ByRoleOptions<T extends Gtk.Accessible = Gtk.Accessible> = MatcherOptions<T> & {
     /** Matcher for the widget's accessible name. */
     name?: Matcher | undefined;
     /** Required checked state; a mixed check button reads as neither, so it matches neither value. */
@@ -116,7 +118,7 @@ type BoundQuery<Q extends Query> = Q extends (container: Container, ...args: inf
 type BoundCustomQueries<Q extends QueryMap> = { [K in keyof Q]: BoundQuery<Q[K]> };
 
 /** What each variant of a query family yields for the widget type it matched. */
-type QueryFamilyReturns<T extends Gtk.Widget> = {
+type QueryFamilyReturns<T extends Gtk.Accessible> = {
     /** The single match, or null when nothing matched; throws when more than one matched. */
     queryBy: T | null;
     /** Every match, empty when nothing matched. */
@@ -135,7 +137,7 @@ type QueryFamilyReturns<T extends Gtk.Widget> = {
 type QueryKind = "role" | "text" | "name" | "value";
 
 /** The arguments a query of the given kind takes after the family's leading ones. */
-type QueryArgs<Kind extends QueryKind, T extends Gtk.Widget> = Kind extends "role"
+type QueryArgs<Kind extends QueryKind, T extends Gtk.Accessible> = Kind extends "role"
     ? [role: Gtk.AccessibleRole, options?: ByRoleOptions<T>]
     : Kind extends "name"
         ? [name: Matcher, options?: MatcherOptions<T>]
@@ -148,7 +150,9 @@ type QueryArgs<Kind extends QueryKind, T extends Gtk.Widget> = Kind extends "rol
  * ahead of the family's own arguments.
  */
 type QueryFamily<Suffix extends string, Kind extends QueryKind, Head extends unknown[]> = {
-    [K in keyof QueryFamilyReturns<Gtk.Widget> as `${K & string}${Suffix}`]: <T extends Gtk.Widget = Gtk.Widget>(
+    [K in keyof QueryFamilyReturns<Gtk.Widget> as `${K & string}${Suffix}`]: <
+        T extends Gtk.Accessible = Gtk.Widget,
+    >(
         ...args: [...Head, ...QueryArgs<Kind, T>]
     ) => QueryFamilyReturns<T>[K];
 };
@@ -175,7 +179,7 @@ type RenderOptions<Q extends QueryMap = Record<never, never>> = {
      * out of reach of a pointer and a keyboard, so every `userEvent` helper aimed at it rejects
      * after `actionabilityTimeout`; `fireEvent` drives such a tree instead.
      */
-    container?: Gtk.Widget | RootElement | undefined;
+    container?: Gtk.Accessible | RootElement | undefined;
     /** Root of the subtree that bound queries search. */
     baseElement?: Container | undefined;
     /** Component wrapped around the rendered element, such as a context provider. */

package/src/user-event/controller.ts

@@ -1,4 +1,5 @@
 import type * as Gtk from "@gtkx/gi/gtk";
+import { requireWidget } from "../widget-target.js";
 
 /** An event controller class that can be constructed without arguments, such as `Gtk.GestureClick`. */
 type ControllerConstructor<T extends Gtk.EventController> = new () => T;
@@ -11,9 +12,10 @@ type ControllerConstructor<T extends Gtk.EventController> = new () => T;
  * @returns The matching controllers, or an empty array when the widget has none.
  */
 const queryAllControllers = <T extends Gtk.EventController>(
-    widget: Gtk.Widget,
+    target: Gtk.Accessible,
     controllerType: ControllerConstructor<T>,
 ): T[] => {
+    const widget = requireWidget(target);
     const controllers = widget.observeControllers();
     const nItems = controllers.getNItems();
     const matches: T[] = [];
@@ -37,7 +39,7 @@ const queryAllControllers = <T extends Gtk.EventController>(
  * @returns The first matching controller, or null when the widget has none.
  */
 const queryController = <T extends Gtk.EventController>(
-    widget: Gtk.Widget,
+    widget: Gtk.Accessible,
     controllerType: ControllerConstructor<T>,
 ): T | null => queryAllControllers(widget, controllerType)[0] ?? null;
 
@@ -49,7 +51,7 @@ const queryController = <T extends Gtk.EventController>(
  * @throws When the widget has no controller of that type.
  */
 const getAllControllers = <T extends Gtk.EventController>(
-    widget: Gtk.Widget,
+    widget: Gtk.Accessible,
     controllerType: ControllerConstructor<T>,
 ): T[] => {
     const controllers = queryAllControllers(widget, controllerType);
@@ -69,7 +71,7 @@ const getAllControllers = <T extends Gtk.EventController>(
  * @throws When the widget has no controller of that type.
  */
 const getController = <T extends Gtk.EventController>(
-    widget: Gtk.Widget,
+    widget: Gtk.Accessible,
     controllerType: ControllerConstructor<T>,
 ): T => {
     const [controller] = getAllControllers(widget, controllerType);
@@ -82,9 +84,10 @@ const getController = <T extends Gtk.EventController>(
 };
 
 const getOrCreateControllers = <T extends Gtk.EventController>(
-    widget: Gtk.Widget,
+    target: Gtk.Accessible,
     controllerType: ControllerConstructor<T>,
 ): T[] => {
+    const widget = requireWidget(target);
     const existing = queryAllControllers(widget, controllerType);
 
     if (existing.length > 0) {

package/src/user-event/index.ts

@@ -1,8 +1,19 @@
 import type * as Gtk from "@gtkx/gi/gtk";
 import { delay } from "../timers.js";
+import { requireWidget } from "../widget-target.js";
 import { scroll, slide } from "./adjustment.js";
 import { click, dblClick, tripleClick } from "./click.js";
-import { drag, dragAndDrop, drop, hover, longPress, rotate, swipe, unhover, zoom } from "./gesture.js";
+import {
+    drag,
+    dragAndDrop,
+    drop,
+    hover,
+    longPress,
+    rotate,
+    swipe,
+    unhover,
+    zoom,
+} from "./gesture.js";
 import { keyboard, tab } from "./keyboard.js";
 import { pointer, type PointerInput } from "./pointer.js";
 import { deselectOptions, selectOptions } from "./selection.js";
@@ -20,55 +31,126 @@ type UserEvent = {
     /** Creates an instance with shared keyboard and pointer state. */
     setup: (options?: UserEventOptions) => UserEvent;
     /** Activates or presses and releases a widget. */
-    click: typeof click;
+    click: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof click> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Delivers a double-click gesture. */
-    dblClick: typeof dblClick;
+    dblClick: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof dblClick> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Delivers a triple-click gesture. */
-    tripleClick: typeof tripleClick;
+    tripleClick: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof tripleClick> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Moves focus forward or backward within the root. */
-    tab: typeof tab;
+    tab: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof tab> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Types into an editable widget. */
-    type: typeof type;
+    type: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof type> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Deletes all text from an editable widget. */
-    clear: typeof clear;
+    clear: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof clear> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Copies the current selection. */
-    copy: typeof copy;
+    copy: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof copy> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Cuts the current selection. */
-    cut: typeof cut;
+    cut: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof cut> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Pastes text or clipboard contents. */
-    paste: typeof paste;
+    paste: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof paste> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Selects positions without activating them. */
     selectOptions: typeof selectOptions;
     /** Unselects positions without activating them. */
     deselectOptions: typeof deselectOptions;
     /** Emits a motion `enter` on the widget, adding a motion controller when it has none. */
-    hover: typeof hover;
+    hover: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof hover> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Emits a motion `leave` on the widget, adding a motion controller when it has none. */
-    unhover: typeof unhover;
+    unhover: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof unhover> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Emits `angle-changed` on the widget's rotate gestures. */
-    rotate: typeof rotate;
+    rotate: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof rotate> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Emits `scale-changed` on the widget's zoom gestures. */
-    zoom: typeof zoom;
+    zoom: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof zoom> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Emits `swipe` with the given velocity on the widget's swipe gestures. */
-    swipe: typeof swipe;
+    swipe: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof swipe> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Emits `pressed` at the given point on the widget's long-press gestures. */
-    longPress: typeof longPress;
+    longPress: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof longPress> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Runs a begin, update, and end sequence on the widget's drag gestures, ending at the given offset. */
-    drag: typeof drag;
+    drag: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof drag> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Emits `drop` with the given content on the widget's drop targets. */
-    drop: typeof drop;
+    drop: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof drop> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Requires a drag source on the source widget, then emits `drop` with the content on the target's drop targets. */
-    dragAndDrop: typeof dragAndDrop;
+    dragAndDrop: (
+        source: Gtk.Accessible,
+        target: Gtk.Accessible,
+        ...args: Parameters<typeof dragAndDrop> extends [Gtk.Widget, Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Emits a jump `change-value` on a Gtk.Range so it moves to the given value. */
-    slide: typeof slide;
+    slide: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof slide> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Adds the delta to the adjustments of the widget itself, or of its nearest scrollable ancestor. */
-    scroll: typeof scroll;
+    scroll: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof scroll> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Sends a key sequence through GTK's propagation chain. */
-    keyboard: (widget: Gtk.Widget, input: string) => Promise<void>;
+    keyboard: (widget: Gtk.Accessible, input: string) => Promise<void>;
     /** Applies a pointer token while preserving held-button state. */
-    pointer: (widget: Gtk.Widget, input: PointerInput) => Promise<void>;
+    pointer: (widget: Gtk.Accessible, input: PointerInput) => Promise<void>;
 };
 
+const onWidget =
+    <Args extends unknown[]>(helper: (widget: Gtk.Widget, ...args: Args) => Promise<void>) =>
+        (target: Gtk.Accessible, ...args: Args): Promise<void> =>
+            helper(requireWidget(target), ...args);
+
+const onWidgetPair =
+    <Args extends unknown[]>(helper: (source: Gtk.Widget, target: Gtk.Widget, ...args: Args) => Promise<void>) =>
+        (source: Gtk.Accessible, target: Gtk.Accessible, ...args: Args): Promise<void> =>
+            helper(requireWidget(source), requireWidget(target), ...args);
+
 /** User interactions that dispatch GTK events and gestures. */
 const userEvent: UserEvent = {
     ...createInstance(createInitialState(), {}),
@@ -93,30 +175,34 @@ function createInstance(state: UserEventState, options: UserEventOptions): UserE
 
     return {
         setup: (overrides?: UserEventOptions): UserEvent => createInstance(state, { ...options, ...overrides }),
-        click: after(click),
-        dblClick: after(dblClick),
-        tripleClick: after(tripleClick),
-        tab: after(tab),
-        type: after(type),
-        clear: after(clear),
-        copy: after(copy),
-        cut: after(cut),
-        paste: after(paste),
-        selectOptions: after(selectOptions),
-        deselectOptions: after(deselectOptions),
-        hover: after(hover),
-        unhover: after(unhover),
-        rotate: after(rotate),
-        zoom: after(zoom),
-        swipe: after(swipe),
-        longPress: after(longPress),
-        drag: after(drag),
-        drop: after(drop),
-        dragAndDrop: after(dragAndDrop),
-        slide: after(slide),
-        scroll: after(scroll),
-        keyboard: after((widget: Gtk.Widget, input: string): Promise<void> => keyboard(state, widget, input)),
-        pointer: after((widget: Gtk.Widget, input: PointerInput): Promise<void> => pointer(state, widget, input)),
+        click: after(onWidget(click)),
+        dblClick: after(onWidget(dblClick)),
+        tripleClick: after(onWidget(tripleClick)),
+        tab: after(onWidget(tab)),
+        type: after(onWidget(type)),
+        clear: after(onWidget(clear)),
+        copy: after(onWidget(copy)),
+        cut: after(onWidget(cut)),
+        paste: after(onWidget(paste)),
+        selectOptions: after(onWidget(selectOptions)),
+        deselectOptions: after(onWidget(deselectOptions)),
+        hover: after(onWidget(hover)),
+        unhover: after(onWidget(unhover)),
+        rotate: after(onWidget(rotate)),
+        zoom: after(onWidget(zoom)),
+        swipe: after(onWidget(swipe)),
+        longPress: after(onWidget(longPress)),
+        drag: after(onWidget(drag)),
+        drop: after(onWidget(drop)),
+        dragAndDrop: after(onWidgetPair(dragAndDrop)),
+        slide: after(onWidget(slide)),
+        scroll: after(onWidget(scroll)),
+        keyboard: after(
+            onWidget((widget: Gtk.Widget, input: string): Promise<void> => keyboard(state, widget, input)),
+        ),
+        pointer: after(
+            onWidget((widget: Gtk.Widget, input: PointerInput): Promise<void> => pointer(state, widget, input)),
+        ),
     };
 }
 

package/src/user-event/selection.ts

@@ -153,9 +153,17 @@ const runSelectionEvent = (
         byRole(widget, valueArray);
     });
 
+const requireWidget = (target: Gtk.Accessible): Gtk.Widget => {
+    if (!(target instanceof Gtk.Widget)) {
+        throw new TypeError("Cannot select options on a non-widget accessible");
+    }
+
+    return target;
+};
+
 /** Selects positions without activating them. */
-const selectOptions = (widget: Gtk.Widget, values: number | number[]): Promise<void> =>
-    runSelectionEvent(widget, values, selectInListView, selectByRole);
+const selectOptions = (widget: Gtk.Accessible, values: number | number[]): Promise<void> =>
+    runSelectionEvent(requireWidget(widget), values, selectInListView, selectByRole);
 
 const deselectInListView = (widget: Gtk.ListView | Gtk.GridView | Gtk.ColumnView, valueArray: number[]): void => {
     const selectionModel = requireSelectionModel(widget, "deselect");
@@ -176,7 +184,7 @@ const deselectByRole = (widget: Gtk.Widget, valueArray: number[]): void => {
 };
 
 /** Unselects positions without activating them. */
-const deselectOptions = (widget: Gtk.Widget, values: number | number[]): Promise<void> =>
-    runSelectionEvent(widget, values, deselectInListView, deselectByRole);
+const deselectOptions = (widget: Gtk.Accessible, values: number | number[]): Promise<void> =>
+    runSelectionEvent(requireWidget(widget), values, deselectInListView, deselectByRole);
 
 export { selectOptions, deselectOptions };

package/src/wait-for.ts

@@ -4,12 +4,13 @@ import { runWithActEnvironment } from "./act.js";
 import { getConfig } from "./config.js";
 import { timeoutError } from "./errors.js";
 import { advanceFakeClock, delay, now } from "./timers.js";
+import { requireWidget } from "./widget-target.js";
 
 type PollResult<T> = { status: "resolved"; value: T } | { status: "timedout"; lastError: Error | null };
 /** Widgets watched for removal; null counts as already removed. */
-type RemovalTarget = Gtk.Widget | Gtk.Widget[] | null;
+type RemovalTarget = Gtk.Accessible | Gtk.Accessible[] | null;
 /** The widgets to watch for removal, or a function re-read on every poll to locate them. */
-type ElementOrCallback = Gtk.Widget | Gtk.Widget[] | (() => RemovalTarget);
+type ElementOrCallback = Gtk.Accessible | Gtk.Accessible[] | (() => RemovalTarget);
 
 const DEFAULT_INTERVAL = 50;
 const ELEMENT_NOT_REMOVED = new Error("Element not yet removed");
@@ -102,10 +103,8 @@ const waitFor = <T>(callback: () => T | Promise<T>, options?: WaitForOptions): P
 const getTarget = (elementOrCallback: ElementOrCallback): RemovalTarget =>
     typeof elementOrCallback === "function" ? elementOrCallback() : elementOrCallback;
 
-const isWidgetRemoved = (widget: Gtk.Widget | null): boolean => {
-    if (widget === null) {
-        return true;
-    }
+const isWidgetRemoved = (target: Gtk.Accessible): boolean => {
+    const widget = requireWidget(target);
 
     try {
         return widget.getRoot() === null;
@@ -115,6 +114,10 @@ const isWidgetRemoved = (widget: Gtk.Widget | null): boolean => {
 };
 
 const isTargetRemoved = (target: RemovalTarget): boolean => {
+    if (target === null) {
+        return true;
+    }
+
     if (Array.isArray(target)) {
         return target.every((widget) => isWidgetRemoved(widget));
     }

package/src/widget-accessible-properties.ts

@@ -13,6 +13,7 @@ import { EDITABLE_ROLES, isEditable, readEditableText } from "./editable.js";
 import { isNameFromAuthor, isNameProhibited } from "./role-naming.js";
 import { children, descendants, relationCandidates } from "./traversal.js";
 import { callBooleanGetter, callStringGetter, getCallableMethod } from "./widget-getters.js";
+import { requireWidget } from "./widget-target.js";
 
 type WidgetValueField = "now" | "min" | "max";
 type CheckedState = "checked" | "unchecked" | "mixed";
@@ -64,12 +65,12 @@ const getLabelText = (widget: Gtk.Widget): string | null => {
 };
 
 const stripMnemonic = (text: string): string => text.replaceAll(/_(.)/g, "$1");
-const isUnderlineUsed = (widget: Gtk.Widget): boolean => callBooleanGetter(widget, "getUseUnderline") ?? false;
+const isUnderlineUsed = (widget: object): boolean => callBooleanGetter(widget, "getUseUnderline") ?? false;
 
-const readNamingText = (widget: Gtk.Widget, getter: string, value: string): string =>
+const readNamingText = (widget: object, getter: string, value: string): string =>
     getter !== EDITABLE_TEXT_GETTER && isUnderlineUsed(widget) ? stripMnemonic(value) : value;
 
-const readFirstText = (widget: Gtk.Widget, getters: string[]): string | null => {
+const readFirstText = (widget: object, getters: string[]): string | null => {
     for (const getter of getters) {
         const value = callStringGetter(widget, getter);
 
@@ -87,7 +88,7 @@ const readFirstText = (widget: Gtk.Widget, getters: string[]): string | null =>
  *
  * @param widget The widget to read text from.
  */
-const getWidgetText = (widget: Gtk.Widget): string | null => readFirstText(widget, DEFAULT_TEXT_GETTERS);
+const getWidgetText = (widget: Gtk.Accessible): string | null => readFirstText(widget, DEFAULT_TEXT_GETTERS);
 
 const namingLabelText = (widget: Gtk.Widget): string | null => {
     const text = getLabelText(widget);
@@ -446,7 +447,8 @@ const getWidgetDescribedByText = (widget: Gtk.Widget): string | null => {
  *
  * @param widget The widget to test.
  */
-const isInaccessible = (widget: Gtk.Widget): boolean => {
+const isInaccessible = (target: Gtk.Accessible): boolean => {
+    const widget = requireWidget(target);
     let current: Gtk.Widget | null = widget;
 
     while (current) {

package/src/widget-getters.ts

@@ -1,28 +1,26 @@
-import type * as GObject from "@gtkx/gi/gobject";
-import type * as Gtk from "@gtkx/gi/gtk";
 import { getClassType, getInstanceType, TYPE_INVALID, typeName } from "@gtkx/runtime";
 import { resolveWrapperClass } from "@gtkx/runtime/internal";
 import { type AnyClass, walkClassChain } from "@gtkx/utils";
 
 const UNNAMED_TYPE_TAG = "Object";
 
-const getWidgetMethod = (widget: Gtk.Widget, name: string): unknown => Reflect.get(widget, name);
-const getWidgetTypeName = (widget: Gtk.Widget): string | null => typeName(getInstanceType(widget));
+const getWidgetMethod = (widget: object, name: string): unknown => Reflect.get(widget, name);
+const getWidgetTypeName = (widget: object): string | null => typeName(getInstanceType(widget));
 const isClass = (value: unknown): value is AnyClass => typeof value === "function";
 
 const nonEmpty = (value: unknown): string | undefined =>
     typeof value === "string" && value.length > 0 ? value : undefined;
 
-const getObjectClass = (object: GObject.Object): AnyClass | null => {
+const getObjectClass = (object: object): AnyClass | null => {
     const cls: unknown = object.constructor;
 
     return isClass(cls) ? cls : null;
 };
 
-const getNearestClassName = (object: GObject.Object): string | undefined =>
+const getNearestClassName = (object: object): string | undefined =>
     walkClassChain(getObjectClass(object), (ancestor) => nonEmpty(ancestor.name));
 
-const getUntypedClassName = (object: GObject.Object): string | undefined => {
+const getUntypedClassName = (object: object): string | undefined => {
     const cls = getObjectClass(object);
 
     return cls !== null && getClassType(cls) === TYPE_INVALID ? nonEmpty(cls.name) : undefined;
@@ -34,7 +32,7 @@ const getExactWrapperName = (type: bigint): string | undefined => {
     return wrapper !== null && getClassType(wrapper) === type ? nonEmpty(wrapper.name) : undefined;
 };
 
-const getTypeTag = (object: GObject.Object): string => {
+const getTypeTag = (object: object): string => {
     const type = getInstanceType(object);
 
     return (
@@ -46,15 +44,15 @@ const getTypeTag = (object: GObject.Object): string => {
     );
 };
 
-const isDefaultWidgetName = (widget: Gtk.Widget, name: string): boolean =>
+const isDefaultWidgetName = (widget: object, name: string): boolean =>
     name.length === 0 || name === getWidgetTypeName(widget);
 
-const hasWidgetMethod = (widget: Gtk.Widget, name: string): boolean =>
+const hasWidgetMethod = (widget: object, name: string): boolean =>
     typeof getWidgetMethod(widget, name) === "function";
 
 /* eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- callers name the signature */
 const getCallableMethod = <Args extends unknown[], Result>(
-    widget: Gtk.Widget,
+    widget: object,
     name: string,
 ): ((...args: Args) => Result) | null => {
     const fn = getWidgetMethod(widget, name);
@@ -62,13 +60,13 @@ const getCallableMethod = <Args extends unknown[], Result>(
     return typeof fn === "function" ? (fn as (...args: Args) => Result).bind(widget) : null;
 };
 
-const callBooleanGetter = (widget: Gtk.Widget, method: string): boolean | null => {
+const callBooleanGetter = (widget: object, method: string): boolean | null => {
     const value = getCallableMethod<[], unknown>(widget, method)?.();
 
     return typeof value === "boolean" ? value : null;
 };
 
-const callStringGetter = (widget: Gtk.Widget, method: string): string | null => {
+const callStringGetter = (widget: object, method: string): string | null => {
     const value = getCallableMethod<[], unknown>(widget, method)?.();
 
     return typeof value === "string" ? value : null;

package/src/widget-target.ts

@@ -0,0 +1,11 @@
+import * as Gtk from "@gtkx/gi/gtk";
+
+const requireWidget = (target: object): Gtk.Widget => {
+    if (!(target instanceof Gtk.Widget)) {
+        throw new TypeError("Expected a Gtk.Widget");
+    }
+
+    return target;
+};
+
+export { requireWidget };