@gjsify/adwaita-core 0.55.0 → 0.57.0

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

@@ -0,0 +1,88 @@
+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. */
+export declare function unprovenVfuncs(vectors?: readonly ApplicationVector[]): 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/constructs.d.ts

@@ -1,6 +1,6 @@
 import type { SharedTreeNode } from './shared-trees.js';
 /** The construct kinds, in the order the tables list them. */
-export declare const CONSTRUCT_KINDS: readonly ["layout", "strings", "responses", "page", "extern", "signal", "bind", "breakpoint"];
+export declare const CONSTRUCT_KINDS: readonly ["layout", "strings", "responses", "page", "extern", "signal", "bind", "breakpoint", "sibling-object"];
 export type ConstructKind = (typeof CONSTRUCT_KINDS)[number];
 /** `implemented`, or the sentence a human can act on — it is the text the error prints. */
 export type ConstructCapability = 'implemented' | {
@@ -52,8 +52,9 @@ export interface ConstructVector {
 }
 export declare const CONSTRUCT_VECTORS: readonly ConstructVector[];
 /**
- * The sizes a renderer feeds the `breakpoint` vector through its own size source, in order, and
- * reads the caption after each: wide, then narrow enough for the condition, then wide again.
+ * The sizes a renderer feeds the `breakpoint` and `sibling-object` vectors through its own size
+ * source, in order, and reads the label after each: wide, then narrow enough for the condition,
+ * then wide again.
  */
 export declare const BREAKPOINT_VECTOR_SIZES: readonly {
     readonly width: number;

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,15 @@ 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';

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.
  *
@@ -189,6 +192,23 @@ export interface SharedTreeNode {
             };
         }[];
     }[];
+    /**
+     * Root only: the OBJECT roots the file declares beside this one — `Adw.AlertDialog dialog { }`
+     * or `$Learn learn { }` after the template — each a tree of its own (ADR 0093). They share the
+     * root's id scope, so a setter or a reference may name one, and a renderer hands the built
+     * 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[];
 }
 /**
@@ -242,7 +262,7 @@ export declare const SHARED_TREE_TABLES: readonly ["BANNER_BUTTON_TEXT_VECTORS",
  */
 export declare const SHARED_TREE_BLOCKS_WITHOUT_EXPECTATIONS: Readonly<Record<string, string>>;
 /** Every authored node of `root`, in pre-order — the sequence a realised tree must reproduce. */
-export declare function authoredNodes(root: SharedTreeNode): {
+export declare function authoredNodes(root: SharedTreeNode, address?: string): {
     node: SharedTreeNode;
     path: string;
 }[];

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

@@ -0,0 +1,67 @@
+/** `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;
+}
+/** 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-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;

package/lib/types/gobject.d.ts

@@ -0,0 +1,202 @@
+import type { SharedTreeNode } from './conformance/shared-trees.js';
+/** What `registerClass` accepts as `Template`: the projected tree of a `?template` import (ADR 0096 § 4). */
+export type BlueprintTemplate = SharedTreeNode;
+/** The subset asked for something it does not list. `feature` is the name that was refused. */
+export declare class UnsupportedGObjectError extends Error {
+    readonly feature: string;
+    constructor(feature: string, message: string);
+}
+/** An opaque GType token: it names a type and proves nothing else. */
+export interface GType {
+    readonly name: string;
+}
+export declare const TYPE_STRING: GType;
+export declare const TYPE_BOOLEAN: GType;
+export declare const TYPE_INT: GType;
+export declare const TYPE_UINT: GType;
+export declare const TYPE_DOUBLE: GType;
+export declare const ParamFlags: {
+    readonly READABLE: 1;
+    readonly WRITABLE: 2;
+    readonly READWRITE: 3;
+    readonly CONSTRUCT: 4;
+    readonly CONSTRUCT_ONLY: 8;
+};
+export type ParamKind = 'boolean' | 'string' | 'int' | 'uint' | 'double';
+export declare class ParamSpec {
+    readonly kind: ParamKind;
+    readonly name: string;
+    readonly nick: string;
+    readonly blurb: string;
+    readonly flags: number;
+    readonly minimum?: number;
+    readonly maximum?: number;
+    private readonly defaultValue;
+    private constructor();
+    static boolean(name: string, nick: string, blurb: string, flags: number, defaultValue: boolean): ParamSpec;
+    static string(name: string, nick: string, blurb: string, flags: number, defaultValue: string | null): ParamSpec;
+    static int(name: string, nick: string, blurb: string, flags: number, minimum: number, maximum: number, defaultValue: number): ParamSpec;
+    static uint(name: string, nick: string, blurb: string, flags: number, minimum: number, maximum: number, defaultValue: number): ParamSpec;
+    static double(name: string, nick: string, blurb: string, flags: number, minimum: number, maximum: number, defaultValue: number): ParamSpec;
+    get_default_value(): unknown;
+}
+/** GJS's own symbols, so a class written in the field form (`static [GObject.properties] = …`) registers. */
+export declare const META_SYMBOLS: {
+    readonly GTypeName: symbol;
+    readonly GTypeFlags: symbol;
+    readonly interfaces: symbol;
+    readonly properties: symbol;
+    readonly signals: symbol;
+    readonly requires: symbol;
+    readonly template: symbol;
+    readonly cssName: symbol;
+    readonly children: symbol;
+    readonly internalChildren: symbol;
+};
+/** What a port's widget tree gives back for one built template. */
+export interface BuiltTemplate {
+    /** The children to attach to the host, in order. */
+    readonly children: readonly object[];
+    /** Every object the template names with an `id`, for `InternalChildren`. */
+    readonly objects: Readonly<Record<string, object>>;
+}
+export type BindingFlag = 'bidirectional' | 'sync-create' | 'invert-boolean';
+export interface Binding {
+    unbind(): void;
+}
+/** What the builder of a port is handed: the instance, its handlers and the binding engine. */
+export interface TemplateScope {
+    /** The template instance — the scope of every handler and the `template` bind source. */
+    readonly instance: object;
+    /** `_createClosure`: looked up on the instance, bound to `options.object` or the instance. */
+    handler(name: string, options?: {
+        object?: object;
+        flags?: readonly string[];
+    }): (...args: unknown[]) => unknown;
+    bind(source: GObjectInstance, sourceProperty: string, target: GObjectInstance, targetProperty: string, flags?: readonly BindingFlag[]): Binding;
+}
+/** The one thing a port implements over its widget model (ADR 0096 § 1). */
+export interface GObjectDoor {
+    readonly name: string;
+    /** Dispatches the named event on a widget that is not the core's to dispatch. */
+    dispatch(target: object, event: string, args: readonly unknown[]): void;
+    /** Listens for it; the handler is called `(target, ...args)`. Returns the disconnect. */
+    listen(target: object, event: string, handler: (...args: unknown[]) => unknown): () => void;
+    /** Creates the widgets of a template, wiring signals and binds through `scope`. */
+    createFromTree(tree: BlueprintTemplate, scope: TemplateScope, host: object): BuiltTemplate;
+    /** Gives the built children to the host. A port may defer the attach to its own lifecycle. */
+    attach(host: object, built: BuiltTemplate): void;
+    /** A class was registered: the port defines its element and its `$GTypeName` template entry. */
+    register(klass: ClassLike, info: RegisteredClass): void;
+}
+export type ClassLike = abstract new (...args: never[]) => object;
+export interface RegisteredClass {
+    readonly klass: ClassLike;
+    readonly typeName: string;
+    readonly gtype: GType;
+    readonly properties: readonly ParamSpec[];
+    /** Signal name → its parameter types. */
+    readonly signals: Readonly<Record<string, readonly GType[]>>;
+    readonly template?: BlueprintTemplate;
+    readonly internalChildren: readonly string[];
+    readonly cssName?: string;
+    readonly door: GObjectDoor;
+}
+export declare function registeredClassOf(klass: object): RegisteredClass | undefined;
+export type SignalHandler = (emitter: GObjectInstance, ...args: unknown[]) => unknown;
+/** The instance surface of a registered class (ADR 0096 § 2, "instance API" row). */
+export interface GObjectInstance {
+    [key: string]: unknown;
+    notify(name: string): void;
+    connect(signal: string, handler: SignalHandler): number;
+    disconnect(id: number): void;
+    emit(signal: string, ...args: unknown[]): void;
+}
+export declare function connectInstance(instance: GObjectInstance, signal: string, handler: SignalHandler): number;
+export declare function disconnectInstance(instance: GObjectInstance, id: number): void;
+export declare function emitInstance(instance: GObjectInstance, signal: string, ...args: unknown[]): void;
+export declare function notifyInstance(instance: GObjectInstance, name: string): void;
+/**
+ * `g_object_bind_property` for the three flags the template builders need. The target follows the
+ * source on every `notify::<source property>`; `bidirectional` makes the source follow the target
+ * back, `invert-boolean` negates what crosses, `sync-create` transfers once at bind time.
+ */
+export declare function bindProperties(source: GObjectInstance, sourceProperty: string, target: GObjectInstance, targetProperty: string, flags?: readonly BindingFlag[]): Binding;
+export declare function createClosure(thisArg: object, handlerName: string, swapped: boolean, connectObject?: object): (...args: unknown[]) => unknown;
+/**
+ * Runs ADR 0096 § 3 steps 4–5 for a registered instance, in GJS's order: every template of the
+ * class chain is built first (base first), then the construct properties are set, and only then
+ * is each `InternalChildren` id installed as `this._<id>`. So `this._x` is `undefined` inside a
+ * property setter that runs during construction and defined once `super(params)` returns.
+ *
+ * Returns the params that are not declared properties, for the port's own construct bag.
+ */
+export declare function constructRegistered(instance: object, params?: Readonly<Record<string, unknown>>): Record<string, unknown>;
+export interface SignalMeta {
+    param_types?: readonly GType[];
+    [refused: string]: unknown;
+}
+export interface ClassMeta {
+    GTypeName?: string;
+    Template?: unknown;
+    InternalChildren?: readonly string[];
+    Properties?: Readonly<Record<string, ParamSpec>>;
+    Signals?: Readonly<Record<string, SignalMeta>>;
+    CssName?: string;
+    [refused: string]: unknown;
+}
+export interface RegisterClass {
+    <T extends ClassLike>(meta: ClassMeta, klass: T): T;
+    <T extends ClassLike>(klass: T): T;
+}
+/** A core class declares the GIR type its `vfunc_*` are listed under in {@link UNLOCKED_VFUNCS}. */
+export declare const GIR_TYPE: unique symbol;
+/**
+ * The `vfunc_*` a registered class may override (ADR 0098 § 1a), keyed by the GIR class that declares
+ * them. Every other `vfunc_*` is refused by name. An entry needs a vector of `APPLICATION_VECTORS`
+ * (`unlocks`) that holds on real GJS; `application.spec.ts` fails an entry without one.
+ */
+export declare const UNLOCKED_VFUNCS: Readonly<Record<string, readonly string[]>>;
+/**
+ * Registers a core class that is no widget and has no template (`Gio.Application`), so its signals
+ * resolve through the registry like a registered class's own. The door is one that names the
+ * missing widget model: such a class has no event system to fall through to.
+ */
+export declare function registerBaseClass(klass: ClassLike, typeName: string, signals: Readonly<Record<string, readonly GType[]>>, properties?: readonly ParamSpec[]): void;
+export type GObjectConstructor = new (params?: Record<string, unknown>) => GObjectInstance;
+/** `GObject.Object` for a registered class with no widget model beneath it. */
+export declare class GObjectObject {
+    [key: string]: unknown;
+    constructor(params?: Record<string, unknown>);
+    notify(name: string): void;
+    connect(signal: string, handler: SignalHandler): number;
+    disconnect(id: number): void;
+    emit(signal: string, ...args: unknown[]): void;
+}
+export interface GObjectNamespace {
+    readonly Object: GObjectConstructor;
+    readonly registerClass: RegisterClass;
+    readonly ParamSpec: typeof ParamSpec;
+    readonly ParamFlags: typeof ParamFlags;
+    readonly TYPE_STRING: GType;
+    readonly TYPE_BOOLEAN: GType;
+    readonly TYPE_INT: GType;
+    readonly TYPE_UINT: GType;
+    readonly TYPE_DOUBLE: GType;
+    readonly GTypeName: symbol;
+    readonly GTypeFlags: symbol;
+    readonly interfaces: symbol;
+    readonly properties: symbol;
+    readonly signals: symbol;
+    readonly requires: symbol;
+    readonly __gtkTemplate__: symbol;
+    readonly __gtkCssName__: symbol;
+    readonly __gtkChildren__: symbol;
+    readonly __gtkInternalChildren__: symbol;
+    type_ensure(gtype: GType): void;
+}
+/**
+ * The `GObject` namespace of a port: `registerClass` registers against `door`. There is no
+ * `bind_property` here until a consumer calls it (ADR 0096 § 2); the engine is {@link bindProperties}.
+ */
+export declare function createGObject(door: GObjectDoor): GObjectNamespace;

package/lib/types/gobject.gjs.spec.d.ts

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

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

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