@gjsify/adwaita-core 0.56.0 → 0.58.0

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

@@ -0,0 +1,91 @@
+import { type GObjectNamespace } from '../gobject.js';
+import type { ConstructHarness } from './constructs.js';
+/** The rows of ADR 0098 § 1 that carry a claim; every one needs a vector. */
+export declare const APPLICATION_ROWS: readonly ["lifecycle", "order", "unlock", "actions", "windows", "resolution", "refusal"];
+export type ApplicationRow = (typeof APPLICATION_ROWS)[number];
+type Handler = (...args: unknown[]) => unknown;
+/** The part of `Gtk.Application` the vectors read. */
+export interface ApplicationLike {
+    connect(signal: string, handler: Handler): number;
+    runAsync(argv: string[]): Promise<number>;
+    quit(): void;
+    vfunc_startup(): void;
+    vfunc_activate(): void;
+    add_action(action: object): void;
+    lookup_action(name: string): object | null;
+    remove_action(name: string): void;
+    has_action(name: string): boolean;
+    list_actions(): string[];
+    activate_action(name: string, parameter: null): void;
+    add_window(window: object): void;
+    remove_window(window: object): void;
+    get_windows(): object[];
+    get_active_window(): object | null;
+    get_application_id(): string | null;
+    [member: string]: unknown;
+}
+export interface SimpleActionLike {
+    enabled: boolean;
+    connect(signal: 'activate', handler: Handler): number;
+    [member: string]: unknown;
+}
+/** Widgets a window scene needs; absent on a subject that cannot build a window (GJS without a display). */
+export interface ApplicationScene {
+    /** `new Gtk.ApplicationWindow({ application })`. */
+    window(app: ApplicationLike): object;
+    /** A button placed in the window. */
+    buttonIn(window: object): object;
+    /** A button inside a popover owned by a menu button placed in the window. */
+    popoverButtonIn(window: object): object;
+    /** A button with no window above it. */
+    loose(): object;
+    /** `activate_action(name)` of the widget: whether an enabled action ran. */
+    activate(widget: object, name: string): boolean;
+    /** `Gtk.ApplicationWindow.add_action`. */
+    addWindowAction(window: object, action: object): void;
+}
+/** What a driver hands the vectors. */
+export interface ApplicationSubject {
+    readonly name: string;
+    /** True for real GJS: refusal vectors are the subset's own and are not run there. */
+    readonly isOracle: boolean;
+    readonly GObject: GObjectNamespace;
+    /** `Gtk.Application`, or `Gio.Application` where GJS has no display. */
+    readonly Application: new (params?: Record<string, unknown>) => ApplicationLike;
+    readonly SimpleAction: new (params: {
+        name: string;
+        enabled?: boolean;
+    }) => SimpleActionLike;
+    /** `Gio.ApplicationFlags.HANDLES_OPEN`: a flag other than the default. */
+    readonly handlesOpen: number;
+    readonly scene?: ApplicationScene;
+    /**
+     * Runs the application to its end. Ports: `runAsync`. GJS inside a test runner cannot (its own
+     * main loop is running, and `runAsync` refuses), so the oracle registers and activates instead.
+     */
+    run?(app: ApplicationLike): Promise<number>;
+    /** Makes the action API usable before a run (`g_application_register` on GJS); a port needs nothing. */
+    ready?(app: ApplicationLike): void;
+}
+export interface ApplicationVector {
+    readonly row: ApplicationRow;
+    readonly rule: string;
+    readonly holds: 'oracle' | 'subset';
+    /** Needs `subject.scene`. */
+    readonly windowed?: true;
+    /** `Class.vfunc_name` entries of `UNLOCKED_VFUNCS` this vector proves against GJS. */
+    readonly unlocks?: readonly string[];
+    readonly observe: (subject: ApplicationSubject) => unknown;
+    readonly shows: unknown;
+}
+export declare const APPLICATION_VECTORS: readonly ApplicationVector[];
+/** Every `Class.vfunc_name` of `UNLOCKED_VFUNCS`, for the gate that an entry without a vector fails. */
+export declare function unlockedVfuncNames(): string[];
+/**
+ * The entries of `UNLOCKED_VFUNCS` no vector proves. `prefix` narrows the check to the GIR namespace
+ * a vector family owns (`Gio.` here, `GtkSource.` in `@gjsify/gtksource-core`).
+ */
+export declare function unprovenVfuncs(vectors?: readonly Pick<ApplicationVector, 'unlocks'>[], prefix?: string): string[];
+/** Holds a subject to the vectors. Windowed vectors need `subject.scene`. */
+export declare function driveApplicationVectors(subject: ApplicationSubject, harness: ConstructHarness, vectors?: readonly ApplicationVector[]): Promise<void>;
+export {};

package/lib/types/conformance/glib-paths.d.ts

@@ -0,0 +1,23 @@
+import type { ConstructHarness } from './constructs.js';
+/** The part of `GLib` the vectors read. */
+export interface GLibPathsLike {
+    readonly MAXUINT32: number;
+    build_filenamev(elements: string[]): string;
+    get_current_dir(): string;
+    get_system_data_dirs(): string[];
+}
+export interface GLibPathsSubject {
+    readonly name: string;
+    readonly isOracle: boolean;
+    readonly GLib: GLibPathsLike;
+}
+export declare const GLIB_PATH_ROWS: readonly ["constant", "join", "separators", "empty", "shape"];
+export type GLibPathRow = (typeof GLIB_PATH_ROWS)[number];
+export interface GLibPathVector {
+    readonly row: GLibPathRow;
+    readonly rule: string;
+    readonly observe: (subject: GLibPathsSubject) => unknown;
+    readonly shows: unknown;
+}
+export declare const GLIB_PATH_VECTORS: readonly GLibPathVector[];
+export declare function driveGLibPathVectors(subject: GLibPathsSubject, harness: ConstructHarness, vectors?: readonly GLibPathVector[]): Promise<void>;

package/lib/types/conformance/glib-timers.d.ts

@@ -0,0 +1,35 @@
+import type { ConstructHarness } from './constructs.js';
+/** The part of `GLib` the vectors read. */
+export interface GLibTimersLike {
+    readonly PRIORITY_HIGH: number;
+    readonly PRIORITY_DEFAULT: number;
+    readonly PRIORITY_HIGH_IDLE: number;
+    readonly PRIORITY_DEFAULT_IDLE: number;
+    readonly PRIORITY_LOW: number;
+    readonly SOURCE_REMOVE: boolean;
+    readonly SOURCE_CONTINUE: boolean;
+    idle_add(priority: number, run: () => boolean | void): number;
+    timeout_add(priority: number, milliseconds: number, run: () => boolean | void): number;
+    source_remove(sourceId: number): boolean;
+}
+/** What a driver hands the vectors. */
+export interface GLibTimersSubject {
+    readonly name: string;
+    readonly isOracle: boolean;
+    readonly GLib: GLibTimersLike;
+    /** Resolves after `milliseconds` of the subject's own loop; the loop must keep running meanwhile. */
+    settle(milliseconds: number): Promise<void>;
+    /** Runs `body` with the subject's error log silenced (a throwing callback logs by design). */
+    quiet(body: () => Promise<void>): Promise<void>;
+}
+export declare const GLIB_TIMER_ROWS: readonly ["constants", "timeout", "idle", "remove", "throw", "arguments"];
+export type GLibTimerRow = (typeof GLIB_TIMER_ROWS)[number];
+export interface GLibTimerVector {
+    readonly row: GLibTimerRow;
+    readonly rule: string;
+    readonly observe: (subject: GLibTimersSubject) => unknown;
+    readonly shows: unknown;
+}
+export declare const GLIB_TIMER_VECTORS: readonly GLibTimerVector[];
+/** Holds a subject to the vectors. */
+export declare function driveGLibTimerVectors(subject: GLibTimersSubject, harness: ConstructHarness, vectors?: readonly GLibTimerVector[]): Promise<void>;

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

@@ -0,0 +1,35 @@
+import type { BindingFlag, BlueprintTemplate, GObjectConstructor, GObjectInstance, GObjectNamespace } from '../gobject.js';
+import type { ConstructHarness } from './constructs.js';
+/** The rows of ADR 0096 § 2 that carry a claim; every one needs a vector. */
+export declare const GOBJECT_ROWS: readonly ["registerClass", "field-form", "ParamSpec", "Signals", "instance API", "type_ensure", "vfunc", "binding engine", "template"];
+export type GObjectRow = (typeof GOBJECT_ROWS)[number];
+/** A template, in both spellings: GtkBuilder XML for GJS, the projected tree for a port. */
+export interface GObjectTemplateSource {
+    readonly className: string;
+    readonly tree: BlueprintTemplate;
+    readonly xml: string;
+}
+/** What a driver hands the vectors. */
+export interface GObjectSubject {
+    readonly name: string;
+    /** True for real GJS: refusal vectors are the subset's own and are not run there. */
+    readonly isOracle: boolean;
+    readonly GObject: GObjectNamespace;
+    /** The widget base a templated class extends (`Gtk.Box` on GJS); absent when there is no display. */
+    readonly Widget?: GObjectConstructor;
+    /** The value to put in `Template`. */
+    template(source: GObjectTemplateSource): unknown;
+    /** The binding engine; `bind_property` on GJS, which is not exported by the ports. */
+    bind(source: GObjectInstance, sourceProperty: string, target: GObjectInstance, targetProperty: string, flags: readonly BindingFlag[]): void;
+}
+export interface GObjectVector {
+    readonly row: GObjectRow;
+    readonly rule: string;
+    readonly holds: 'oracle' | 'subset';
+    readonly widget?: true;
+    readonly observe: (subject: GObjectSubject) => unknown;
+    readonly shows: unknown;
+}
+export declare const GOBJECT_VECTORS: readonly GObjectVector[];
+/** Holds a subject to the vectors. Widget vectors need `subject.Widget`; the caller reports their absence. */
+export declare function driveGObjectVectors(subject: GObjectSubject, harness: ConstructHarness, vectors?: readonly GObjectVector[]): Promise<void>;

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

@@ -84,3 +84,21 @@ export { SHARED_TREE_BLOCKS_WITHOUT_EXPECTATIONS, SHARED_TREE_TABLES, authoredNo
 export type { SharedTreeExpectation, SharedTreeNode, SharedTreeObservable, SharedTreePlacement, } from './shared-trees.js';
 export { CONSTRUCT_KINDS, BREAKPOINT_VECTOR_SIZES, EXTERN_VECTOR_CLASS, CONSTRUCT_VECTORS, UnsupportedConstructError, assertTreeConstructs, constructUsesOf, driveConstructVectors, } from './constructs.js';
 export type { ConstructCapabilities, ConstructCapability, ConstructHarness, ConstructKind, ConstructRenderer, ConstructUse, ConstructVector, } from './constructs.js';
+export { GOBJECT_ROWS, GOBJECT_VECTORS, driveGObjectVectors } from './gobject.js';
+export { APPLICATION_ROWS, APPLICATION_VECTORS, driveApplicationVectors, unprovenVfuncs, unlockedVfuncNames, } from './application.js';
+export type { ApplicationLike, ApplicationRow, ApplicationScene, ApplicationSubject, ApplicationVector, SimpleActionLike, } from './application.js';
+export { GLIB_TIMER_ROWS, GLIB_TIMER_VECTORS, driveGLibTimerVectors } from './glib-timers.js';
+export type { GLibTimerRow, GLibTimersLike, GLibTimersSubject, GLibTimerVector } from './glib-timers.js';
+export type { GObjectRow, GObjectSubject, GObjectTemplateSource, GObjectVector } from './gobject.js';
+export { POPUP_MENU_PLAN_VECTORS, popupMenuOutline } from './popup-menu-plan.js';
+export type { PopupMenuPlanVector } from './popup-menu-plan.js';
+export { MENU_ACTION_VECTORS, driveMenuActionVectors, registryMenuActionScene } from './menu-actions.js';
+export type { MenuActionGroupSpec, MenuActionScene, MenuActionVector } from './menu-actions.js';
+export { MENU_TREE_VECTORS } from './menu-tree.js';
+export type { MenuTreeVector } from './menu-tree.js';
+export { GLIB_PATH_ROWS, GLIB_PATH_VECTORS, driveGLibPathVectors } from './glib-paths.js';
+export type { GLibPathRow, GLibPathsLike, GLibPathsSubject, GLibPathVector } from './glib-paths.js';
+export { STYLE_MANAGER_ROWS, STYLE_MANAGER_VECTORS, driveStyleManagerVectors } from './style-manager.js';
+export type { AdwStyleLike, StyleManagerLike, StyleManagerRow, StyleManagerSubject, StyleManagerVector, } from './style-manager.js';
+export { SIMPLE_ACTION_GROUP_ROWS, SIMPLE_ACTION_GROUP_VECTORS, driveSimpleActionGroupVectors, } from './simple-action-group.js';
+export type { GioActionsLike, SimpleActionGroupLike, SimpleActionGroupRow, SimpleActionGroupSubject, SimpleActionGroupVector, GioSimpleActionLike, } from './simple-action-group.js';

package/lib/types/conformance/menu-actions.d.ts

@@ -0,0 +1,36 @@
+import type { ConstructHarness } from './constructs.js';
+export interface MenuActionGroupSpec {
+    readonly at: 'outer' | 'button';
+    readonly prefix: string;
+    /** `enabled` of each action by name; the name is also what its handler logs, with `at`. */
+    readonly actions: Readonly<Record<string, boolean>>;
+}
+export interface MenuActionVector {
+    readonly rule: string;
+    readonly groups: readonly MenuActionGroupSpec[];
+    /** The detailed action the one item names. */
+    readonly action: string;
+    readonly sensitive: boolean;
+    readonly fired: readonly string[];
+}
+export declare const MENU_ACTION_VECTORS: ReadonlyArray<MenuActionVector>;
+export interface MenuActionScene {
+    /** A fresh chain: `outer` is the ROOT (the window) and `button` a descendant of it, and is where resolution starts. */
+    chain(): {
+        outer: object;
+        button: object;
+    };
+    /** Insert a group of `actions` (name → enabled) at `widget`; `onActivate` hears each activation by name. */
+    insertGroup(widget: object, prefix: string, actions: Readonly<Record<string, boolean>>, onActivate: (action: string) => void): void;
+    /** Whether an item naming `detailed` reads as sensitive from `button`. */
+    sensitive(button: object, detailed: string): boolean;
+    /** What choosing an item that names `detailed` does from `button`. */
+    activate(button: object, detailed: string): void;
+}
+/** The registry of ADR 0098 over a port's parent link: what the browser and NativeScript drive. */
+export declare function registryMenuActionScene(chain: () => {
+    outer: object;
+    button: object;
+}, parent: (node: object) => object | null | undefined): MenuActionScene;
+/** Runs {@link MENU_ACTION_VECTORS} on a port's tree walk, or on GTK itself (the oracle). */
+export declare function driveMenuActionVectors(name: string, scene: MenuActionScene, { describe, it, expect }: ConstructHarness): Promise<void>;

package/lib/types/conformance/menu-tree.d.ts

@@ -0,0 +1,18 @@
+import type { AdwMenuNode } from '../menu.js';
+export interface MenuTreeVector {
+    readonly rule: string;
+    /** A `GtkMenuButton` tree. */
+    readonly tree: {
+        readonly tag: 'GtkMenuButton';
+        readonly props?: Record<string, string>;
+        readonly menus?: Record<string, readonly AdwMenuNode[]>;
+        readonly menuModels?: Record<string, readonly AdwMenuNode[]>;
+    };
+    /** The `kind` of each top-level node `menuModel` holds, or a fragment of the refusal. */
+    readonly result: {
+        readonly kinds: readonly string[];
+    } | {
+        readonly refused: string;
+    };
+}
+export declare const MENU_TREE_VECTORS: ReadonlyArray<MenuTreeVector>;

package/lib/types/conformance/popup-menu-plan.d.ts

@@ -0,0 +1,30 @@
+import type { AdwMenuActions, AdwMenuInput } from '../menu.js';
+export interface PopupMenuPlanVector {
+    readonly rule: string;
+    readonly input: AdwMenuInput;
+    readonly actions?: AdwMenuActions;
+    /** The groups, in order, as {@link popupMenuOutline} writes them. */
+    readonly outline: readonly string[];
+    /** The refusals by name; empty when the menu is renderable. */
+    readonly refused: readonly string[];
+}
+export declare const POPUP_MENU_PLAN_VECTORS: ReadonlyArray<PopupMenuPlanVector>;
+interface OutlineLevel {
+    groups: ReadonlyArray<{
+        checkable: string;
+        entries: ReadonlyArray<{
+            kind: 'item';
+            title: string;
+            enabled: boolean;
+            checked: boolean;
+            role: string;
+        } | {
+            kind: 'submenu';
+            title: string;
+            level: OutlineLevel;
+        }>;
+    }>;
+}
+/** The plan as the one-line-per-group text the vectors state. */
+export declare function popupMenuOutline(level: OutlineLevel): string[];
+export {};

package/lib/types/conformance/shared-trees.d.ts

@@ -1,3 +1,6 @@
+import type { AdwMenuNode } from '../menu.js';
+/** One node of an authored menu: the normalised model of ADR 0042 (ADR 0097 § 1). */
+export type MenuNodeShape = AdwMenuNode;
 /**
  * One node of an authored tree — the shape `ADWAITA_GALLERY_SHARED_TREES` is written in.
  *
@@ -196,6 +199,16 @@ export interface SharedTreeNode {
      * object back to the code beside the file; none of them is a child of the root.
      */
     siblings?: readonly SharedTreeNode[];
+    /**
+     * Root only: the root `menu id { }` of the file, by id (ADR 0097 § 1). A `menu-model: id`
+     * property stays the scalar id; the builder resolves it here.
+     */
+    menus?: Readonly<Record<string, readonly MenuNodeShape[]>>;
+    /**
+     * The menu written AT a property (`menu-model: menu { }`), by property name: the model itself,
+     * not an id into `menus` (ADR 0097 § 1).
+     */
+    menuModels?: Readonly<Record<string, readonly MenuNodeShape[]>>;
     children?: readonly SharedTreeNode[];
 }
 /**

package/lib/types/conformance/simple-action-group.d.ts

@@ -0,0 +1,35 @@
+import type { ConstructHarness } from './constructs.js';
+export interface GioSimpleActionLike {
+    enabled: boolean;
+    connect(signal: 'activate', handler: () => void): number;
+}
+export interface SimpleActionGroupLike {
+    add_action(action: GioSimpleActionLike): void;
+    remove_action(name: string): void;
+    lookup_action(name: string): unknown;
+    has_action(name: string): boolean;
+    list_actions(): string[];
+    activate_action(name: string, parameter: null): unknown;
+}
+/** The part of `Gio` the vectors read. */
+export interface GioActionsLike {
+    SimpleAction: new (props: {
+        name: string;
+    }) => GioSimpleActionLike;
+    SimpleActionGroup: new () => SimpleActionGroupLike;
+}
+export interface SimpleActionGroupSubject {
+    readonly name: string;
+    readonly isOracle: boolean;
+    readonly Gio: GioActionsLike;
+}
+export declare const SIMPLE_ACTION_GROUP_ROWS: readonly ["lookup", "replace", "list", "remove", "activate", "disabled", "unknown"];
+export type SimpleActionGroupRow = (typeof SIMPLE_ACTION_GROUP_ROWS)[number];
+export interface SimpleActionGroupVector {
+    readonly row: SimpleActionGroupRow;
+    readonly rule: string;
+    readonly observe: (subject: SimpleActionGroupSubject) => unknown;
+    readonly shows: unknown;
+}
+export declare const SIMPLE_ACTION_GROUP_VECTORS: readonly SimpleActionGroupVector[];
+export declare function driveSimpleActionGroupVectors(subject: SimpleActionGroupSubject, harness: ConstructHarness, vectors?: readonly SimpleActionGroupVector[]): Promise<void>;

package/lib/types/conformance/style-manager.d.ts

@@ -0,0 +1,33 @@
+import type { ConstructHarness } from './constructs.js';
+export interface StyleManagerLike {
+    readonly dark: boolean;
+    get_dark(): boolean;
+    connect(signal: string, handler: (manager: StyleManagerLike, pspec: {
+        name: string;
+    }) => void): number;
+    disconnect(id: number): void;
+}
+/** The part of `Adw` the vectors read. */
+export interface AdwStyleLike {
+    StyleManager: {
+        get_default(): StyleManagerLike;
+    };
+}
+export interface StyleManagerSubject {
+    readonly name: string;
+    readonly isOracle: boolean;
+    readonly Adw: AdwStyleLike;
+    /** Makes the interface dark or light the way the subject's platform does. */
+    setDark(dark: boolean): void;
+    settle(): Promise<void>;
+}
+export declare const STYLE_MANAGER_ROWS: readonly ["default", "dark", "notify", "unchanged", "disconnect", "readonly"];
+export type StyleManagerRow = (typeof STYLE_MANAGER_ROWS)[number];
+export interface StyleManagerVector {
+    readonly row: StyleManagerRow;
+    readonly rule: string;
+    readonly observe: (subject: StyleManagerSubject) => unknown;
+    readonly shows: unknown;
+}
+export declare const STYLE_MANAGER_VECTORS: readonly StyleManagerVector[];
+export declare function driveStyleManagerVectors(subject: StyleManagerSubject, harness: ConstructHarness, vectors?: readonly StyleManagerVector[]): Promise<void>;

package/lib/types/gio-actions.d.ts

@@ -0,0 +1,85 @@
+/** `activate` handler: the action that fired and the caller's parameter (`null` when none). */
+export type ActionActivateHandler = (action: SimpleAction, parameter: unknown) => void;
+/** What a registry holds and a widget walk activates. */
+export interface ActionLike {
+    readonly name: string;
+    enabled: boolean;
+    activate(parameter?: unknown): void;
+}
+/** What a group answers; `Gio.ActionMap` and the groups of `insertActionGroup` both do. */
+export interface ActionGroupLike {
+    lookup_action(name: string): ActionLike | null;
+}
+export interface SimpleActionProps {
+    name: string;
+    enabled?: boolean;
+    /** Held, never checked: an action activates with whatever the caller passes. */
+    parameter_type?: unknown;
+}
+/** `Gio.SimpleAction`: `name`, `enabled`, the `activate` signal and `activate()`. */
+export declare class SimpleAction implements ActionLike {
+    readonly name: string;
+    enabled: boolean;
+    readonly parameter_type: unknown;
+    private readonly _handlers;
+    private _nextId;
+    constructor(props: SimpleActionProps);
+    /** `g_signal_connect`. Only `activate` exists; any other name is refused rather than ignored. */
+    connect(signal: 'activate', handler: ActionActivateHandler): number;
+    disconnect(id: number): void;
+    /** `g_action_activate`. A disabled action swallows it, as GIO does. */
+    activate(parameter?: unknown): void;
+}
+/**
+ * `Gio.SimpleActionGroup`: `add_action` (an existing name is replaced), `lookup_action`, `has_action`,
+ * `list_actions`, `remove_action` and `activate_action`. `list_actions()` is in insertion order where
+ * GIO's hash order is unspecified, so a caller must not depend on either. `activate_action` takes the
+ * caller's parameter as is and answers whether an action of that name exists (GIO answers nothing);
+ * a disabled action swallows it. Not here: `change_action_state`, `query_action`, `add_action_entries`
+ * and the `action-added` / `action-removed` signals.
+ */
+export declare class SimpleActionGroup implements ActionGroupLike {
+    private readonly _actions;
+    add_action(action: SimpleAction): void;
+    remove_action(name: string): void;
+    lookup_action(name: string): SimpleAction | null;
+    has_action(name: string): boolean;
+    list_actions(): string[];
+    /** `g_action_group_activate_action`. False when no such action exists. */
+    activate_action(name: string, parameter?: unknown): boolean;
+}
+/** The registry behind `Gio.ActionMap` and `Gio.ActionGroup`. */
+export declare class ActionRegistry implements ActionGroupLike {
+    private readonly _actions;
+    /** `g_action_map_add_action`: an existing name is replaced. */
+    add(action: ActionLike): void;
+    remove(name: string): void;
+    lookup_action(name: string): ActionLike | null;
+    has(name: string): boolean;
+    list(): string[];
+}
+/** The registry an owner (an application, a window) carries; made on first use. */
+export declare function actionRegistryOf(owner: object, create?: boolean): ActionRegistry | undefined;
+/**
+ * Gives a prototype `Gio.ActionMap` (`add_action`, `lookup_action`, `remove_action`) and, with
+ * `group`, `Gio.ActionGroup`. A window is an ActionMap only: its `activate_action` is the WIDGET's,
+ * which takes `win.x`, so the group half stays off it.
+ */
+export declare function installActionMap(proto: object, group?: boolean): void;
+/** `gtk_widget_insert_action_group`: `group`'s actions resolve as `prefix.name` below `widget`. `null` removes it. */
+export declare function insertActionGroup(widget: object, prefix: string, group: ActionGroupLike | null): void;
+/** The application a window belongs to (`Gtk.Window:application`), or `null`. */
+export declare function applicationOfWindow(window: object): ActionGroupLike | null;
+/** Records or clears the application of a window. `Application.add_window` / `remove_window` call it. */
+export declare function linkWindow(window: object, application: ActionGroupLike | null): void;
+/**
+ * The group a widget finds for `prefix`: the nearest explicit group up the chain, the `win` actions
+ * of the first node that carries an ActionMap, and the application of the first node that is a window
+ * of one (`app`). A widget with no window above it finds none, which is not an empty group (ADR 0042 § 2).
+ */
+export declare function findActionGroup(widget: object, prefix: string, parent: (node: object) => object | null | undefined): ActionGroupLike | null;
+/**
+ * What a `Gtk.Actionable` does when it fires: split `prefix.name`, find the group, activate. Returns
+ * whether an enabled action ran, so a caller can tell a wired button from a dangling name.
+ */
+export declare function activateWidgetAction(widget: object, fullName: string, parent: (node: object) => object | null | undefined, parameter?: unknown): boolean;

package/lib/types/glib-paths.d.ts

@@ -0,0 +1,16 @@
+/** `G_MAXUINT32`. */
+export declare const MAXUINT32 = 4294967295;
+/**
+ * `g_build_filenamev` on a POSIX host (separator `/`), ported line for line from `g_build_path_va`.
+ *
+ * At each boundary between two elements the trailing separators of the first and the leading ones of
+ * the second are dropped and exactly one is inserted. Empty elements are ignored. The result keeps as
+ * many leading separators as the first non-empty element had and as many trailing ones as the last had;
+ * separators INSIDE an element are left alone (`a//b` stays). Not `path.join`: that normalises `.`,
+ * `..` and inner runs, which GLib never does.
+ */
+export declare function buildFilenamev(elements: readonly string[]): string;
+/** `g_get_current_dir` where the host has no working directory: the root. */
+export declare function getCurrentDir(): string;
+/** `g_get_system_data_dirs` where the host has no system data directories: none. */
+export declare function getSystemDataDirs(): string[];

package/lib/types/glib-paths.gjs.spec.d.ts

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

package/lib/types/glib-paths.spec.d.ts

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

package/lib/types/glib-timers.d.ts

@@ -0,0 +1,21 @@
+/** The slice of a host event loop the timers need. */
+export interface TimerHost {
+    setTimeout(run: () => void, milliseconds: number): unknown;
+    clearTimeout(handle: unknown): void;
+}
+export type SourceFunc = () => boolean | void;
+/** `GLib` as far as this subset goes. */
+export interface GLibTimers {
+    readonly PRIORITY_HIGH: number;
+    readonly PRIORITY_DEFAULT: number;
+    readonly PRIORITY_HIGH_IDLE: number;
+    readonly PRIORITY_DEFAULT_IDLE: number;
+    readonly PRIORITY_LOW: number;
+    readonly SOURCE_REMOVE: boolean;
+    readonly SOURCE_CONTINUE: boolean;
+    idle_add(priority: number, run: SourceFunc): number;
+    timeout_add(priority: number, milliseconds: number, run: SourceFunc): number;
+    source_remove(sourceId: number): boolean;
+}
+/** One main context's worth of sources; the namespace object of a port is one of these. */
+export declare function createGLibTimers(host?: TimerHost): GLibTimers;

package/lib/types/glib-timers.gjs.spec.d.ts

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

package/lib/types/glib-timers.spec.d.ts

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