@gjsify/adwaita-web 0.56.0 → 0.57.0

package/lib/types/application.d.ts

@@ -0,0 +1,24 @@
+import { GioApplicationBase, type AdwMenuItem, type AdwMenuActions, type AdwMenuModel, type ApplicationHost } from '@gjsify/adwaita-core';
+export declare const webHost: ApplicationHost;
+/** An element's parent for action resolution; a popover is rooted at the widget that owns it. */
+export declare function parentOfElement(node: object): object | null;
+/** What a `Gtk.Actionable` does on activation: the action `prefix.name` found from `widget`. */
+export declare function activateWidgetAction(widget: Element, fullName: string, parameter?: unknown): boolean;
+/** What the items of `model` read from the actions registered above `el` (ADR 0097 § 3). */
+export declare function menuActionsOfElement(el: Element, model: AdwMenuModel): AdwMenuActions;
+/** What choosing `item` in a menu owned by `el` does: the action it names fires. */
+export declare function activateElementMenuItem(el: Element, item: AdwMenuItem): boolean;
+export declare class GioApplication extends GioApplicationBase {
+    static host: ApplicationHost;
+}
+declare const GtkApplication_base: typeof GioApplication & import("@gjsify/adwaita-core").GtkApplicationConstructor;
+export declare class GtkApplication extends GtkApplication_base {
+}
+export declare class AdwApplication extends GtkApplication {
+}
+/**
+ * `Gtk.Window:application` and the window's `Gio.ActionMap` (`win.` actions) on an element class.
+ * Setting the property is `add_window`, as on GTK; setting it to `null` is `remove_window`.
+ */
+export declare function defineWindowApplication(proto: object): void;
+export {};

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

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

package/lib/types/elements/adw-application-window.d.ts

@@ -1,6 +1,8 @@
 import { type AdwMenuInput, type AdwMenuModel } from '@gjsify/adwaita-core';
 import { AdwWindow } from './adw-window.js';
 export declare class AdwApplicationWindow extends AdwWindow {
+    /** `Gtk.Window:application`: setting it is `add_window` (ADR 0098), set by `defineWindowApplication`. */
+    application: object | null;
     private _menubarEl;
     private _model;
     static get observedAttributes(): string[];

package/lib/types/elements/adw-view-stack.d.ts

@@ -1,6 +1,9 @@
 import type { AdwViewStackPageInfo as CorePageInfo } from '@gjsify/adwaita-core';
+import type { DispatchedSignals } from '../signals.js';
 export type AdwViewStackPageInfo = CorePageInfo<HTMLElement>;
 export declare class AdwViewStack extends HTMLElement {
+    /** The GTK signals this element dispatches, each with the DOM event it arrives as (ADR 0093). */
+    static readonly signals: DispatchedSignals;
     private readonly _state;
     private _initialized;
     static get observedAttributes(): string[];

package/lib/types/elements/checks.d.ts

@@ -1,3 +1,4 @@
+import type { DispatchedSignals } from '../signals.js';
 /**
  * The markup + state shared by `<gtk-check-button>` and `<adw-radio>`.
  *
@@ -17,6 +18,9 @@ declare abstract class AdwCheckBase extends HTMLElement {
     protected abstract activate(): void;
     get checked(): boolean;
     set checked(value: boolean);
+    /** `Gtk.CheckButton:active`, the GObject name for {@link checked}. */
+    get active(): boolean;
+    set active(value: boolean);
     /** Whether the control is in the third, inconsistent state. */
     get indeterminate(): boolean;
     set indeterminate(value: boolean);
@@ -33,6 +37,8 @@ declare abstract class AdwCheckBase extends HTMLElement {
 }
 /** The Adwaita checkbox — `checkbutton > check` as a custom element. */
 export declare class GtkCheckButton extends AdwCheckBase {
+    /** The GTK signals this element dispatches, each with the DOM event it arrives as (ADR 0093). */
+    static readonly signals: DispatchedSignals;
     static get observedAttributes(): string[];
     protected get inputType(): 'checkbox';
     protected activate(): void;

package/lib/types/elements/gtk-application-window.d.ts

@@ -1,6 +1,8 @@
 import type { AdwSlot } from '../slotted-children.js';
 import { GtkWindow } from './gtk-window.js';
 export declare class GtkApplicationWindow extends GtkWindow {
+    /** `Gtk.Window:application`: setting it is `add_window` (ADR 0098), set by `defineWindowApplication`. */
+    application: object | null;
     private _menubar;
     private _menubarObserver;
     static get observedAttributes(): string[];

package/lib/types/elements/gtk-drop-down.d.ts

@@ -1,5 +1,6 @@
 import './gtk-popover.js';
 import type { AdwComboOption, AdwListModelInput } from '@gjsify/adwaita-core';
+import type { DispatchedSignals } from '../signals.js';
 /**
  * A dropdown option — `value` is the stable id, `label` the shown text. An alias of
  * core's {@link AdwComboOption}, since the drop-down and the combo row are the same
@@ -7,6 +8,8 @@ import type { AdwComboOption, AdwListModelInput } from '@gjsify/adwaita-core';
  */
 export type GtkDropDownOption = AdwComboOption;
 export declare class GtkDropDown extends HTMLElement {
+    /** The GTK signals this element dispatches, each with the DOM event it arrives as (ADR 0093). */
+    static readonly signals: DispatchedSignals;
     private _buttonEl;
     private _labelEl;
     private _popoverEl;

package/lib/types/elements/gtk-entry.d.ts

@@ -1,3 +1,4 @@
+import type { DispatchedSignals } from '../signals.js';
 export declare class GtkEntry extends HTMLElement {
     /**
      * `protected`, not `private`: `GtkPasswordEntry` and `GtkSearchEntry` subclass this
@@ -8,9 +9,18 @@ export declare class GtkEntry extends HTMLElement {
     protected _input: HTMLInputElement;
     private _initialized;
     private _maxLength;
+    /** The text last announced, so `changed` fires on a real change only — as `gtk_editable_changed` does. */
+    private _announced;
+    /** The GTK signals this element dispatches, each with the DOM event it arrives as (ADR 0093). */
+    static readonly signals: DispatchedSignals;
     static get observedAttributes(): string[];
     get value(): string;
     set value(v: string);
+    /** `Gtk.Editable:text`, the GObject name for {@link value}. */
+    get text(): string;
+    set text(v: string);
+    /** `changed` then `notify::text`, once per real change of the text, typed or set from code. */
+    private _announceText;
     /** `Gtk.Entry:max-length` — 0 means unlimited. Counted in CODE POINTS. */
     get maxLength(): number;
     set maxLength(value: number);

package/lib/types/elements/gtk-menu-button.d.ts

@@ -67,5 +67,7 @@ export declare class GtkMenuButton extends HTMLElement {
     private _parseMenuAttr;
     private _onPopoverToggled;
     private _render;
+    /** The registry's answer, unless the application wrote `actions` itself (ADR 0097 § 2). */
+    private _refreshActions;
     private _renderMenu;
 }

package/lib/types/elements/gtk-scrolled-window.d.ts

@@ -1,3 +1,4 @@
+import type { AdwAdjustment } from '@gjsify/adwaita-core';
 import type { GtkViewport } from './gtk-viewport.js';
 /** `GtkPolicyType`'s four nicks; `automatic` is the pspec's default for both bars. */
 export type GtkPolicyType = 'always' | 'never' | 'automatic' | 'external';
@@ -17,6 +18,9 @@ export declare class GtkScrolledWindow extends HTMLElement {
     private _hoverable;
     private _fadeTimer;
     private _built;
+    /** What an unbuilt window answers before it has a viewport to read. */
+    private readonly _standIn;
+    private readonly _adopted;
     static get observedAttributes(): string[];
     /** `GtkScrolledWindow:hscrollbar-policy` — `automatic` in the pspec. */
     get hscrollbarPolicy(): GtkPolicyType;
@@ -24,6 +28,18 @@ export declare class GtkScrolledWindow extends HTMLElement {
     /** `GtkScrolledWindow:vscrollbar-policy` — `automatic` in the pspec. */
     get vscrollbarPolicy(): GtkPolicyType;
     set vscrollbarPolicy(value: GtkPolicyType);
+    /** `gtk_scrolled_window_get_policy`: `[hscrollbar, vscrollbar]` as `Gtk.PolicyType` constants. */
+    get_policy(): [number, number];
+    /** `gtk_scrolled_window_set_policy`; a value that is not a `Gtk.PolicyType` throws, as GJS's enum marshalling does. */
+    set_policy(hscrollbar_policy: number, vscrollbar_policy: number): void;
+    /** `GtkScrollable:hadjustment` as the window reports it: the one it was given, else the viewport's. */
+    get hadjustment(): AdwAdjustment;
+    get vadjustment(): AdwAdjustment;
+    get_hadjustment(): AdwAdjustment;
+    get_vadjustment(): AdwAdjustment;
+    /** Adopts `adjustment` as what `get_hadjustment` answers; the scroll position keeps following the viewport. */
+    set_hadjustment(adjustment: AdwAdjustment): void;
+    set_vadjustment(adjustment: AdwAdjustment): void;
     /** `GtkScrolledWindow:window-placement` — where the contents sit against the bars. */
     get windowPlacement(): GtkCornerType;
     set windowPlacement(value: GtkCornerType);

package/lib/types/elements/gtk-stack.d.ts

@@ -1,3 +1,4 @@
+import type { DispatchedSignals } from '../signals.js';
 /** `GtkStackTransitionType`, spelled as the GIR's enum nicks (gtkstack.c:95-121). */
 export type StackTransitionType = 'none' | 'crossfade' | 'slide-right' | 'slide-left' | 'slide-up' | 'slide-down' | 'slide-left-right' | 'slide-up-down' | 'over-up' | 'over-down' | 'over-left' | 'over-right' | 'under-up' | 'under-down' | 'under-left' | 'under-right' | 'over-up-down' | 'over-down-up' | 'over-left-right' | 'over-right-left' | 'rotate-left' | 'rotate-right' | 'rotate-left-right';
 /** The browser's page descriptor — the stand-in for the `GtkStackPage` GObject. */
@@ -18,6 +19,8 @@ export interface GtkStackPageInfo {
     child: HTMLElement;
 }
 export declare class GtkStack extends HTMLElement {
+    /** The GTK signals this element dispatches, each with the DOM event it arrives as (ADR 0093). */
+    static readonly signals: DispatchedSignals;
     /** The child that is visible, or `null` — C's `priv->visible_child`. */
     private _visible;
     /** C's `priv->last_visible_child`: the page being animated away. */

package/lib/types/elements/gtk-switch.d.ts

@@ -1,4 +1,7 @@
+import type { DispatchedSignals } from '../signals.js';
 export declare class GtkSwitch extends HTMLElement {
+    /** The GTK signals this element dispatches, each with the DOM event it arrives as (ADR 0093). */
+    static readonly signals: DispatchedSignals;
     private _input;
     private _slider;
     private _initialized;

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

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

package/lib/types/gobject-door.d.ts

@@ -0,0 +1,4 @@
+import { type GObjectDoor } from '@gjsify/adwaita-core';
+/** `Hexdump` → `gjsify-hexdump`, `GoVecNotify` → `gjsify-go-vec-notify`. */
+export declare function tagForTypeName(typeName: string): string;
+export declare const webDoor: GObjectDoor;

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

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

package/lib/types/gobject-elements.d.ts

@@ -0,0 +1,17 @@
+type Handler = (emitter: HTMLElement, ...args: unknown[]) => unknown;
+/** Whether `el` got its four methods from {@link installElementApi} (a registered class has the core's). */
+export declare function hasElementApi(el: object): boolean;
+/** Makes every change of `property` on `el` reach a `notify::<property>` listener, connected or not. */
+export declare function ensureNotifying(el: HTMLElement, property: string): void;
+/** Calls `handler(el, ...args)` for `signal`; returns the disconnect. */
+export declare function listenElement(el: HTMLElement, signal: string, handler: Handler): () => void;
+export declare function dispatchElement(el: HTMLElement, signal: string, args: readonly unknown[]): void;
+/** Gives `el` the instance API of a registered class, over the events it declares. */
+export declare function installElementApi(el: HTMLElement): void;
+/**
+ * The end of a bind the core's engine drives. An element speaks camelCase members where a `.blp`
+ * says `dash-name`, so a built element is wrapped to translate the name; a registered class
+ * already has the core's accessors and aliases and is returned as it is.
+ */
+export declare function endpointOf(el: HTMLElement): HTMLElement;
+export {};

package/lib/types/gtksource/gtk-source-view.d.ts

@@ -0,0 +1,77 @@
+import { GtkAdjustment } from '@gjsify/adwaita-core';
+import type { Buffer } from '@gjsify/gtksource-core';
+export declare class GtkSourceView extends HTMLElement {
+    static get observedAttributes(): string[];
+    private readonly session;
+    private readonly driver;
+    private unsubscribe;
+    private built;
+    private readonly gutter;
+    private readonly backdrop;
+    private readonly area;
+    private readonly vadj;
+    private readonly hadj;
+    private direction;
+    constructor();
+    private syncAdjustments;
+    private readonly onAreaScroll;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    /** `GtkSource.View:buffer`. */
+    get buffer(): Buffer;
+    set buffer(value: Buffer);
+    get autoIndent(): boolean;
+    set autoIndent(value: boolean | string);
+    /** Held and read back; a textarea has no indent step to apply it to (ADR 0094). */
+    get indentWidth(): number;
+    set indentWidth(value: number | string);
+    get showLineNumbers(): boolean;
+    set showLineNumbers(value: boolean | string);
+    get highlightCurrentLine(): boolean;
+    set highlightCurrentLine(value: boolean | string);
+    get monospace(): boolean;
+    set monospace(value: boolean | string);
+    get editable(): boolean;
+    set editable(value: boolean | string);
+    /** `GtkTextView:cursor-visible` — whether the insertion cursor is drawn; TRUE by default. */
+    get cursorVisible(): boolean;
+    set cursorVisible(value: boolean | string);
+    get cursor_visible(): boolean;
+    set cursor_visible(value: boolean);
+    get_cursor_visible(): boolean;
+    set_cursor_visible(value: boolean): void;
+    get_editable(): boolean;
+    set_editable(value: boolean): void;
+    get highlight_current_line(): boolean;
+    set highlight_current_line(value: boolean);
+    get show_line_numbers(): boolean;
+    set show_line_numbers(value: boolean);
+    /** `GtkScrollable:vadjustment` — one stable adjustment that follows the textarea's scroll. */
+    get vadjustment(): GtkAdjustment;
+    get hadjustment(): GtkAdjustment;
+    get_vadjustment(): GtkAdjustment;
+    get_hadjustment(): GtkAdjustment;
+    /** `gtk_widget_set_direction`: held, and mirrored onto `dir` for LTR and RTL. */
+    set_direction(direction: number): void;
+    get_direction(): number;
+    /** A view has no widget children of its own here: its parts are the browser's. */
+    get_first_child(): null;
+    get_next_sibling(): Element | null;
+    get_parent(): Element | null;
+    /** Gutters are slice 6 (ADR 0094). */
+    get_gutter(_window_type: number): never;
+    get leftMargin(): number;
+    set leftMargin(value: number | string);
+    get rightMargin(): number;
+    set rightMargin(value: number | string);
+    get topMargin(): number;
+    set topMargin(value: number | string);
+    get bottomMargin(): number;
+    set bottomMargin(value: number | string);
+    /** GJS `connect(name, cb) → id`; the handler's first argument is this view. */
+    connect(name: string, callback: (self: GtkSourceView, ...args: never[]) => void): number;
+    disconnect(id: number): void;
+    /** The inner textarea, for focus and tests. */
+    get textarea(): HTMLTextAreaElement;
+}

package/lib/types/gtksource/gtk-source-view.spec.d.ts

@@ -0,0 +1,2 @@
+import './gtk-source-view.js';
+export declare const GtkSourceViewTest: () => Promise<void>;

package/lib/types/gtksource/web-editor-driver.d.ts

@@ -0,0 +1,44 @@
+import type { EditorDriver, EditorHost, EditorLayout, EditorPalette, StyledRun } from '@gjsify/gtksource-core';
+export interface EditorParts {
+    readonly root: HTMLElement;
+    readonly area: HTMLTextAreaElement;
+    readonly backdrop: HTMLElement;
+    readonly gutter: HTMLElement;
+}
+export declare class WebEditorDriver implements EditorDriver {
+    private readonly parts;
+    private host;
+    private text;
+    private caret;
+    private reported;
+    private layout;
+    private readonly runs;
+    private scheduled;
+    private listening;
+    private palette;
+    private attached;
+    constructor(parts: EditorParts);
+    bind(host: EditorHost): void;
+    /** Starts listening to the textarea; the counterpart of the Android `attach()`. */
+    attach(): void;
+    detach(): void;
+    private onInput;
+    private onSelection;
+    /** `accepts-tab` is GTK's default; a textarea would move focus, so Tab inserts a tab. */
+    private onKey;
+    setText(text: string): void;
+    replaceRange(start: number, end: number, text: string): void;
+    setSelection(start: number, end: number): void;
+    setLineCount(): void;
+    setLayout(layout: EditorLayout): void;
+    /** Attributes and styles on the host wait for `attach()`: a custom element's constructor may not write them. */
+    private applyLayout;
+    setPalette(palette: EditorPalette): void;
+    private applyPalette;
+    spliceLines(first: number, removed: number, inserted: number): void;
+    paintLine(line: number, _lineStart: number, runs: readonly StyledRun[]): void;
+    clearAll(): void;
+    /** One repaint per task: a burst of `paintLine` calls from one edit costs one DOM rebuild. */
+    private scheduleRender;
+    private render;
+}

package/lib/types/index.d.ts

@@ -12,6 +12,9 @@ export { isIconAvailable, registerIcon } from './icon-registry.js';
 export * as Adw from './namespace/adw.js';
 export * as Gtk from './namespace/gtk.js';
 export * as Gio from './namespace/gio.js';
+export * as GLib from './namespace/glib.js';
+export * as GObject from './namespace/gobject.js';
+export * as GtkSource from './namespace/gtksource.js';
 export { AdwCard } from './elements/adw-card.js';
 export { AdwDataGrid } from './elements/adw-data-grid.js';
 export type { AdwDataGridAlign, AdwDataGridColumn, AdwDataGridRow, AdwDataGridRowVariant, } from './elements/adw-data-grid.js';

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

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

package/lib/types/namespace/adw.d.ts

@@ -54,3 +54,4 @@ export { AdwViewSwitcherBar as ViewSwitcherBar } from '../elements/adw-view-swit
 export { AdwWindow as Window } from '../elements/adw-window.js';
 export { AdwWindowTitle as WindowTitle } from '../elements/adw-window-title.js';
 export { AdwWrapBox as WrapBox } from '../elements/adw-wrap-box.js';
+export { AdwApplication as Application } from '../application.js';

package/lib/types/namespace/gio.d.ts

@@ -1 +1,3 @@
 export { GioMenu as Menu, GioMenuItem as MenuItem } from '@gjsify/adwaita-core';
+export { SimpleAction, ApplicationFlags } from '@gjsify/adwaita-core';
+export { GioApplication as Application } from '../application.js';

package/lib/types/namespace/glib.d.ts

@@ -0,0 +1,10 @@
+export declare const PRIORITY_HIGH: number;
+export declare const PRIORITY_DEFAULT: number;
+export declare const PRIORITY_HIGH_IDLE: number;
+export declare const PRIORITY_DEFAULT_IDLE: number;
+export declare const PRIORITY_LOW: number;
+export declare const SOURCE_REMOVE: boolean;
+export declare const SOURCE_CONTINUE: boolean;
+export declare const idle_add: (priority: number, run: import("@gjsify/adwaita-core").SourceFunc) => number;
+export declare const timeout_add: (priority: number, milliseconds: number, run: import("@gjsify/adwaita-core").SourceFunc) => number;
+export declare const source_remove: (sourceId: number) => boolean;

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

@@ -0,0 +1,27 @@
+declare const GObjectObject: import("@gjsify/adwaita-core").GObjectConstructor;
+export { GObjectObject as Object };
+export declare const registerClass: import("@gjsify/adwaita-core").RegisterClass;
+export declare const type_ensure: (gtype: import("@gjsify/adwaita-core").GType) => void;
+export declare const ParamSpec: typeof import("@gjsify/adwaita-core").ParamSpec;
+export declare const ParamFlags: {
+    readonly READABLE: 1;
+    readonly WRITABLE: 2;
+    readonly READWRITE: 3;
+    readonly CONSTRUCT: 4;
+    readonly CONSTRUCT_ONLY: 8;
+};
+export declare const TYPE_STRING: import("@gjsify/adwaita-core").GType;
+export declare const TYPE_BOOLEAN: import("@gjsify/adwaita-core").GType;
+export declare const TYPE_INT: import("@gjsify/adwaita-core").GType;
+export declare const TYPE_UINT: import("@gjsify/adwaita-core").GType;
+export declare const TYPE_DOUBLE: import("@gjsify/adwaita-core").GType;
+export declare const GTypeName: symbol;
+export declare const GTypeFlags: symbol;
+export declare const interfaces: symbol;
+export declare const properties: symbol;
+export declare const signals: symbol;
+export declare const requires: symbol;
+export declare const __gtkTemplate__: symbol;
+export declare const __gtkCssName__: symbol;
+export declare const __gtkChildren__: symbol;
+export declare const __gtkInternalChildren__: symbol;

package/lib/types/namespace/gtk-enums.d.ts

@@ -0,0 +1,22 @@
+/** `Gtk.PolicyType`: `ALWAYS` 0, `AUTOMATIC` 1, `NEVER` 2, `EXTERNAL` 3. */
+export declare const PolicyType: Readonly<{
+    readonly ALWAYS: 0;
+    readonly AUTOMATIC: 1;
+    readonly NEVER: 2;
+    readonly EXTERNAL: 3;
+}>;
+/** `Gtk.TextDirection`: `NONE` 0, `LTR` 1, `RTL` 2. */
+export declare const TextDirection: Readonly<{
+    readonly NONE: 0;
+    readonly LTR: 1;
+    readonly RTL: 2;
+}>;
+/** `Gtk.TextWindowType`: `WIDGET` 1, `TEXT` 2, `LEFT` 3, `RIGHT` 4, `TOP` 5, `BOTTOM` 6. */
+export declare const TextWindowType: Readonly<{
+    readonly WIDGET: 1;
+    readonly TEXT: 2;
+    readonly LEFT: 3;
+    readonly RIGHT: 4;
+    readonly TOP: 5;
+    readonly BOTTOM: 6;
+}>;

package/lib/types/namespace/gtk.d.ts

@@ -1,4 +1,5 @@
 export { GtkAdjustment as Adjustment } from '@gjsify/adwaita-core';
+export { PolicyType, TextDirection, TextWindowType } from './gtk-enums.js';
 export { GtkAboutDialog as AboutDialog } from '../elements/gtk-about-dialog.js';
 export { GtkActionBar as ActionBar } from '../elements/gtk-action-bar.js';
 export { GtkApplicationWindow as ApplicationWindow } from '../elements/gtk-application-window.js';
@@ -73,3 +74,4 @@ export { GtkWindow as Window } from '../elements/gtk-window.js';
 export { GtkWindowControls as WindowControls } from '../elements/gtk-window-controls.js';
 export { GtkViewport as Viewport } from '../elements/gtk-viewport.js';
 export { GtkWindowHandle as WindowHandle } from '../elements/gtk-window-handle.js';
+export { GtkApplication as Application } from '../application.js';

package/lib/types/namespace/gtksource.d.ts

@@ -0,0 +1,2 @@
+export { Buffer, Language, LanguageManager, StyleScheme, StyleSchemeManager, init } from '@gjsify/gtksource-core';
+export { GtkSourceView as View } from '../gtksource/gtk-source-view.js';

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

@@ -1,4 +1,4 @@
-import { type BreakpointSize } from '@gjsify/adwaita-core';
+import { type BreakpointSize, type TemplateScope } from '@gjsify/adwaita-core';
 import { type SharedTreeNode } from '@gjsify/adwaita-core/conformance';
 /** One authored placement, kept so {@link mountSharedTree} can hold the renderer to it. */
 interface PlacedChild {
@@ -30,6 +30,10 @@ interface BuildRecord {
     observeSize?: SizeSource;
     /** The object a signal handler's NAME is resolved against (ADR 0093 § 3), as `Gtk.BuilderScope` does. */
     scope?: Readonly<Record<string, unknown>>;
+    /** The root menus of the tree (ADR 0097), which a `menu-model: id` anywhere below resolves against. */
+    menus?: SharedTreeNode['menus'];
+    /** Present when the tree is the template of a registered class (ADR 0096): handlers and binds go through it. */
+    template?: TemplateScope;
 }
 /** Calls `onSize` with the host's measured size, now and on every change; returns its disposer. */
 export type SizeSource = (element: Element, onSize: (size: BreakpointSize) => void) => () => void;
@@ -93,6 +97,21 @@ export declare function buildSharedTree(node: SharedTreeNode, record?: BuildReco
  * as the attribute `"false"` and a later `true` rewrites it — `GTK_WIDGET_EXPAND` says why.
  */
 export declare function writeProp(el: HTMLElement, prop: string, value: string | number | boolean): void;
+/** A template tree built for a registered class: its children are not attached, its look is not written. */
+export interface BuiltTemplateTree {
+    readonly children: HTMLElement[];
+    /** Every object the template names with an `id`. */
+    readonly objects: Record<string, HTMLElement>;
+    /** Writes the root's own properties, classes and extensions onto the host — at its first connect. */
+    finish(): void;
+}
+/**
+ * The template of a registered class (ADR 0096 § 3), built into `host`: children created and wired
+ * to their handlers and binds through `scope`, none appended and nothing written to `host`'s
+ * attributes, because `host` is still inside its constructor. `finish` and the caller's own append
+ * belong to the first `connectedCallback`.
+ */
+export declare function buildTemplateTree(tree: SharedTreeNode, scope: TemplateScope, host: HTMLElement): BuiltTemplateTree;
 /** A tree {@link mountSharedTree} built and connected. */
 export interface MountedSharedTree {
     /** The authored root — connected, so every custom element under it has upgraded and run. */