@gjsify/adwaita-nativescript 0.47.0 → 0.49.0

package/lib/types/widgets/adw-toolbar-view.d.ts

@@ -1,7 +1,19 @@
 import type { View } from '@nativescript/core';
 import { GridLayout, StackLayout } from '@nativescript/core';
 import { type AdwToolbarStyle } from './chrome.js';
-export declare class AdwToolbarView extends GridLayout {
+import { type ConstructProps } from './construct-props.js';
+declare const AdwToolbarView_base: (abstract new (...args: any[]) => {
+    connect(eventName: string, callback: (self: /*elided*/ any, data: import("@nativescript/core").EventData) => void): number;
+    disconnect(handlerId: number): void;
+    _emit(eventName: string): void;
+    addEventListener(eventName: string, callback: (data: import("@nativescript/core").EventData) => void, thisArg?: unknown, once?: boolean): void;
+    removeEventListener(eventName: string, callback?: (data: import("@nativescript/core").EventData) => void, thisArg?: unknown): void;
+    notify<T extends import("@nativescript/core").EventData>(data: T): void;
+    notifyPropertyChange(name: string, value: unknown, oldValue?: unknown): void;
+    set(name: string, value: unknown): void;
+    get(name: string): unknown;
+}) & typeof GridLayout;
+export declare class AdwToolbarView extends AdwToolbarView_base {
     /** The top-bar slot (row 0) — stack of header bars / toolbars. */
     protected readonly _topBox: StackLayout;
     /** The bottom-bar slot (row 2) — stack of bottom toolbars. */
@@ -14,13 +26,13 @@ export declare class AdwToolbarView extends GridLayout {
     private _topBarCount;
     private _bottomBarCount;
     private _detachInsets;
-    constructor();
-    /** Append a widget (e.g. an {@link AdwHeaderBar}) to the top-bar slot. */
-    addTopBar(view: View): void;
-    /** Append a widget to the bottom-bar slot. */
-    addBottomBar(view: View): void;
-    /** Set (or replace) the main content view. Pass `null` to clear it. */
-    setContent(view: View | null): void;
+    constructor(props?: ConstructProps<AdwToolbarView>);
+    /** Append a widget (e.g. an {@link AdwHeaderBar}) to the top-bar slot — `adw_toolbar_view_add_top_bar`. */
+    add_top_bar(view: View): void;
+    /** Append a widget to the bottom-bar slot — `adw_toolbar_view_add_bottom_bar`. */
+    add_bottom_bar(view: View): void;
+    /** Set (or replace) the main content view — `adw_toolbar_view_set_content`. `null` clears it. */
+    set_content(view: View | null): void;
     /**
      * XML inflation — route a template's child through the slot API.
      *
@@ -92,3 +104,4 @@ export declare class AdwToolbarView extends GridLayout {
      */
     private _syncClasses;
 }
+export {};

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

@@ -1,6 +1,7 @@
 import type { View } from '@nativescript/core';
 import { GridLayout, type EventData } from '@nativescript/core';
 import { type AdwViewStackPage, type ViewStackNotifyPayload } from './view-stack-state.js';
+import { type ConstructProps } from './construct-props.js';
 export type { AdwViewStackPage };
 /** Event name emitted when the visible child changes. Mirrors GObject `notify::visible-child`. */
 export declare const NOTIFY_VISIBLE_CHILD = "notify::visible-child";
@@ -11,9 +12,20 @@ export declare const NOTIFY_VISIBLE_CHILD = "notify::visible-child";
  */
 export interface NotifyVisibleChildEventData extends EventData, ViewStackNotifyPayload {
 }
-export declare class AdwViewStack extends GridLayout {
+declare const AdwViewStack_base: (abstract new (...args: any[]) => {
+    connect(eventName: string, callback: (self: /*elided*/ any, data: EventData) => void): number;
+    disconnect(handlerId: number): void;
+    _emit(eventName: string): void;
+    addEventListener(eventName: string, callback: (data: EventData) => void, thisArg?: unknown, once?: boolean): void;
+    removeEventListener(eventName: string, callback?: (data: EventData) => void, thisArg?: unknown): void;
+    notify<T extends EventData>(data: T): void;
+    notifyPropertyChange(name: string, value: unknown, oldValue?: unknown): void;
+    set(name: string, value: unknown): void;
+    get(name: string): unknown;
+}) & typeof GridLayout;
+export declare class AdwViewStack extends AdwViewStack_base {
     private readonly _state;
-    constructor();
+    constructor(props?: ConstructProps<AdwViewStack>);
     /**
      * Register a page. It becomes visible when nothing is selected yet — and,
      * unlike before, that auto-pick NOTIFIES, so a bound switcher highlights the
@@ -22,7 +34,7 @@ export declare class AdwViewStack extends GridLayout {
      */
     add(content: View, name: string, title?: string, icon?: string): AdwViewStackPage;
     /** Convenience alias matching `Adw.ViewStack.add_titled`. */
-    addTitled(content: View, name: string, title: string): AdwViewStackPage;
+    add_titled(content: View, name: string, title: string): AdwViewStackPage;
     /**
      * Remove the first page named `name` and detach its content view. Returns
      * whether anything was removed. When the removed page was the visible one the
@@ -39,9 +51,30 @@ export declare class AdwViewStack extends GridLayout {
     setPageVisible(name: string, visible: boolean): boolean;
     /** All registered pages, in add order (a bound switcher reads this). */
     get pages(): readonly AdwViewStackPage[];
-    /** The visible page index, `-1` when nothing is selected. Swaps the visible page + emits. */
+    /**
+     * The visible page's position, `-1` when nothing is selected.
+     *
+     * A REPORT, NOT A DOOR (ADR 0048). `Adw.ViewStack` selects by NAME, and an ordinal
+     * is derived: an insertion before the visible page increments it, a reorder rewrites
+     * it and a removal decrements it — the three cases `ViewStackState` carries code for.
+     * So it is safe to read at a moment and unsafe to hold, and selecting is
+     * {@link visibleChildName}.
+     */
     get visibleChildIndex(): number;
-    set visibleChildIndex(raw: number | string);
+    /**
+     * Show the page at position `n`. Returns whether the selection moved.
+     *
+     * THE ORDINAL IS A CALL, NOT A PROPERTY (ADR 0048). It resolves against the page list
+     * as it is at THIS moment and keeps nothing, which is the whole difference from the
+     * setter it replaces: a held index silently comes to mean another page after an
+     * insert, a reorder or a removal. Port-owned — measured, `refs/libadwaita` gives
+     * `AdwViewStack` no ordinal API at all — and named for the `selectNthPage` the tab
+     * view already has, so the two widgets ask the same question the same way.
+     *
+     * A non-integer or out-of-range `n` selects nothing; the guard is the core's
+     * ({@link ViewStackState.setVisibleIndex}) and is pinned by the shared vectors.
+     */
+    selectNthPage(n: number): boolean;
     /** The visible page name (`Adw.ViewStack.visible-child-name`), `''` for none. */
     get visibleChildName(): string;
     set visibleChildName(name: string | null | undefined);

package/lib/types/widgets/adw-view-switcher-bar.d.ts

@@ -1,15 +1,27 @@
 import { GridLayout } from '@nativescript/core';
 import type { AdwViewStack } from './adw-view-stack.js';
-export declare class AdwViewSwitcherBar extends GridLayout {
+import { type ConstructProps } from './construct-props.js';
+declare const AdwViewSwitcherBar_base: (abstract new (...args: any[]) => {
+    connect(eventName: string, callback: (self: /*elided*/ any, data: import("@nativescript/core").EventData) => void): number;
+    disconnect(handlerId: number): void;
+    _emit(eventName: string): void;
+    addEventListener(eventName: string, callback: (data: import("@nativescript/core").EventData) => void, thisArg?: unknown, once?: boolean): void;
+    removeEventListener(eventName: string, callback?: (data: import("@nativescript/core").EventData) => void, thisArg?: unknown): void;
+    notify<T extends import("@nativescript/core").EventData>(data: T): void;
+    notifyPropertyChange(name: string, value: unknown, oldValue?: unknown): void;
+    set(name: string, value: unknown): void;
+    get(name: string): unknown;
+}) & typeof GridLayout;
+export declare class AdwViewSwitcherBar extends AdwViewSwitcherBar_base {
     /** The horizontal (homogeneous) row of buttons. */
     private readonly _bar;
     private _nodes;
     private _stack;
     private _stackListener;
     private readonly _barState;
-    constructor();
+    constructor(props?: ConstructProps<AdwViewSwitcherBar>);
     /** Bind to an {@link AdwViewStack}: build buttons from its pages + two-way sync. */
-    setStack(stack: AdwViewStack | null): void;
+    set_stack(stack: AdwViewStack | null): void;
     /** The bound stack (`Adw.ViewSwitcherBar.stack`). */
     get stack(): AdwViewStack | null;
     set stack(value: AdwViewStack | null);
@@ -39,3 +51,4 @@ export declare class AdwViewSwitcherBar extends GridLayout {
     private _buildButton;
     private _applyRevealed;
 }
+export {};

package/lib/types/widgets/adw-view-switcher.d.ts

@@ -1,6 +1,7 @@
 import { AdwViewSwitcherBase } from './view-switcher-base.js';
+import { type ConstructProps } from './construct-props.js';
 export declare class AdwViewSwitcher extends AdwViewSwitcherBase {
-    constructor();
+    constructor(props?: ConstructProps<AdwViewSwitcher>);
     protected get barClass(): string;
     protected get buttonClass(): string;
 }

package/lib/types/widgets/adw-window-title.d.ts

@@ -1,16 +1,28 @@
-import { Label, StackLayout } from '@nativescript/core';
+import { Label, StackLayout, type EventData } from '@nativescript/core';
+import { type ConstructProps } from './construct-props.js';
 /** Event name emitted when {@link AdwWindowTitle.title} changes. */
 export declare const NOTIFY_TITLE = "notify::title";
 /** Event name emitted when {@link AdwWindowTitle.subtitle} changes. */
 export declare const NOTIFY_SUBTITLE = "notify::subtitle";
-export declare class AdwWindowTitle extends StackLayout {
+declare const AdwWindowTitle_base: (abstract new (...args: any[]) => {
+    connect(eventName: string, callback: (self: /*elided*/ any, data: EventData) => void): number;
+    disconnect(handlerId: number): void;
+    _emit(eventName: string): void;
+    addEventListener(eventName: string, callback: (data: EventData) => void, thisArg?: unknown, once?: boolean): void;
+    removeEventListener(eventName: string, callback?: (data: EventData) => void, thisArg?: unknown): void;
+    notify<T extends EventData>(data: T): void;
+    notifyPropertyChange(name: string, value: unknown, oldValue?: unknown): void;
+    set(name: string, value: unknown): void;
+    get(name: string): unknown;
+}) & typeof StackLayout;
+export declare class AdwWindowTitle extends AdwWindowTitle_base {
     /** The bold title label. */
     protected readonly _titleLabel: Label;
     /** The dim subtitle label. */
     protected readonly _subtitleLabel: Label;
     /** The headless title/subtitle pair + change detection (ADR 0004). */
     private readonly _state;
-    constructor();
+    constructor(props?: ConstructProps<AdwWindowTitle>);
     /** The window title (bold, top line). Empty collapses its label. */
     get title(): string;
     set title(value: string);
@@ -21,3 +33,4 @@ export declare class AdwWindowTitle extends StackLayout {
     private _apply;
     private _notify;
 }
+export {};

package/lib/types/widgets/adw-wrap-box.d.ts

@@ -1,8 +1,20 @@
 import { FlexboxLayout, type View } from '@nativescript/core';
 import { type AdwLengthUnit, type AdwWrapBoxJustify, type AdwWrapBoxOrientation, type AdwWrapBoxPackDirection, type AdwWrapPolicy } from '@gjsify/adwaita-core';
+import { type ConstructProps } from './construct-props.js';
 /** Every `notify::` an `Adw.WrapBox` emits (adw-wrap-box.c:284-497). */
 export type AdwWrapBoxProperty = 'child-spacing' | 'child-spacing-unit' | 'pack-direction' | 'align' | 'justify' | 'justify-last-line' | 'line-spacing' | 'line-spacing-unit' | 'line-homogeneous' | 'natural-line-length' | 'natural-line-length-unit' | 'wrap-reverse' | 'wrap-policy' | 'orientation';
-export declare class AdwWrapBox extends FlexboxLayout {
+declare const AdwWrapBox_base: (abstract new (...args: any[]) => {
+    connect(eventName: string, callback: (self: /*elided*/ any, data: import("@nativescript/core").EventData) => void): number;
+    disconnect(handlerId: number): void;
+    _emit(eventName: string): void;
+    addEventListener(eventName: string, callback: (data: import("@nativescript/core").EventData) => void, thisArg?: unknown, once?: boolean): void;
+    removeEventListener(eventName: string, callback?: (data: import("@nativescript/core").EventData) => void, thisArg?: unknown): void;
+    notify<T extends import("@nativescript/core").EventData>(data: T): void;
+    notifyPropertyChange(name: string, value: unknown, oldValue?: unknown): void;
+    set(name: string, value: unknown): void;
+    get(name: string): unknown;
+}) & typeof FlexboxLayout;
+export declare class AdwWrapBox extends AdwWrapBox_base {
     private _childSpacing;
     private _lineSpacing;
     private _childSpacingUnit;
@@ -17,17 +29,17 @@ export declare class AdwWrapBox extends FlexboxLayout {
     private _orientation;
     private _naturalLineLength;
     private _naturalLineLengthUnit;
-    constructor();
+    constructor(props?: ConstructProps<AdwWrapBox>);
     /** Append a child — `adw_wrap_box_append` (adw-wrap-box.c:1344-1352). */
-    add(view: View): void;
+    append(view: View): void;
     /** Remove a previously-added child — `adw_wrap_box_remove` (:1387-1395). */
     remove(view: View): void;
     /** `adw_wrap_box_remove_all` (:1406-1414). */
-    removeAll(): void;
+    remove_all(): void;
     /**
-     * Every path a child can enter by — `add()`, a direct `addChild()`, and XML
+     * Every path a child can enter by — `append()`, a direct `addChild()`, and XML
      * inflation via `_addChildFromBuilder` — ends here, which is why the spacing
-     * is applied here and not in `add()`. It used to be applied in `add()` only,
+     * is applied here and not in `append()`. It used to be applied in `append()` only,
      * so a child declared in markup got no spacing at all; C routes GtkBuildable's
      * `add_child` through the same append for the same reason.
      */
@@ -40,9 +52,9 @@ export declare class AdwWrapBox extends FlexboxLayout {
      * `WRAP_BOX_CHILD_ORDER_VECTORS`. Returns whether the insert happened; a
      * refusal is where C would have hit a `g_return_if_fail`.
      */
-    insertChildAfter(view: View, sibling?: View | null): boolean;
+    insert_child_after(view: View, sibling?: View | null): boolean;
     /** `adw_wrap_box_reorder_child_after` (:1315-1332). Same NULL rule. */
-    reorderChildAfter(view: View, sibling?: View | null): boolean;
+    reorder_child_after(view: View, sibling?: View | null): boolean;
     private _childViews;
     private _applyOrder;
     /** Gap between items in a line, in {@link childSpacingUnit}. Defaults to 0, as in C. */
@@ -101,3 +113,4 @@ export declare class AdwWrapBox extends FlexboxLayout {
     private _applyLayout;
     private _applyChildren;
 }
+export {};

package/lib/types/widgets/avatar-view.d.ts

@@ -0,0 +1,57 @@
+import { type AdwAvatarMode } from '@gjsify/adwaita-core';
+import { type NsVisibility } from './row-state.js';
+export type { AdwAvatarMode };
+/** The fallback icon NAME, exported because it is a SUBSTITUTION a caller can see. */
+export declare const AVATAR_DEFAULT_ICON = "avatar-default-symbolic";
+/**
+ * `update_icon`: the caller's icon, or the default when none was set.
+ *
+ * The emptiness test is the port's, not the C's — C keys on `icon_name != NULL`, and a
+ * NativeScript setter has no null to tell from `''`. Same reading `AdwStatusPage` takes.
+ */
+export declare function avatarIcon(iconName: string | null | undefined): string;
+/** Which of the avatar's two NativeScript children is in the layout. */
+export interface AvatarVisibilities {
+    /** The initials label. */
+    label: NsVisibility;
+    /** The fallback symbolic icon. */
+    icon: NsVisibility;
+}
+/**
+ * The two `visibility` values for a mode, straight off `update_visibility`'s three
+ * `gtk_widget_set_visible` calls (refs/libadwaita/src/adw-avatar.c:122-123#has_custom_image).
+ *
+ * `'image'` is REACHABLE and shows NEITHER child, rather than being folded into `'icon'`:
+ * a function that cannot express the third mode is how the web element shipped a
+ * `hasCustomImage: false` no vector could falsify.
+ */
+export declare function avatarVisibilities(mode: AdwAvatarMode): AvatarVisibilities;
+/** What `AdwAvatar` sets on its two children for a given property state. */
+export interface AvatarViewState extends AvatarVisibilities {
+    /** The mode `update_visibility` picked. */
+    mode: AdwAvatarMode;
+    /**
+     * The icon the icon child renders — the default when the caller set none.
+     *
+     * NOT `icon`: {@link AvatarVisibilities} already owns that key for the child's
+     * `visibility`, and one interface cannot hold both.
+     */
+    iconName: string;
+}
+/**
+ * The WHOLE decision `AdwAvatar` makes, so that a spec can drive it.
+ *
+ * It lives here for a reason a mutation showed: `extends GridLayout` puts the class out of
+ * reach of every unit test in this package, so anything decided inside it is
+ * unfalsifiable — the fallback was reverted to "always initials" in the widget body and
+ * the whole suite, plus every gate that reads this tree, stayed green. What is left
+ * unreachable is three assignments; no test here closes that.
+ *
+ * `hasCustomImage` is hard `false` because the port has no `custom-image` counterpart
+ * (status/open-todos.md); when it lands, only this argument changes.
+ */
+export declare function avatarViewState(input: {
+    showInitials: boolean;
+    text: string;
+    iconName: string;
+}): AvatarViewState;

package/lib/types/widgets/bottom-sheet-state.d.ts

@@ -63,7 +63,7 @@ export declare function requestBottomSheetClose(state: BottomSheetPresentation,
  * libadwaita never writes to the child's own style classes — the marker lives on
  * the internal bin (`adw_bottom_sheet_set_content`, adw-bottom-sheet.c:1497-1510).
  * This port does write it, and used to do so with a bare string concat, so
- * `setContent(v)` twice left `'adw-bottom-sheet-content adw-bottom-sheet-content'`.
+ * `set_content(v)` twice left `'adw-bottom-sheet-content adw-bottom-sheet-content'`.
  */
 export declare function addMarkerClass(className: string | null | undefined, marker: string): string;
 /**

package/lib/types/widgets/box-layout.d.ts

@@ -0,0 +1,39 @@
+import { resolveWrapBoxChildOrder } from '@gjsify/adwaita-core';
+/**
+ * `Gtk.Box:spacing`'s default, in DIPs. `0` in C (`gtkbox.c`, the property's default
+ * value), which is also what makes the margin write invisible until a caller asks.
+ */
+export declare const DEFAULT_BOX_SPACING = 0;
+/** Which axis a box stacks along — NativeScript's two words, and `Gtk.Orientation`'s nicks. */
+export type BoxOrientation = 'horizontal' | 'vertical';
+/**
+ * A spacing value as the box will hold it: a finite, non-negative number of DIPs.
+ *
+ * `gtk_box_set_spacing` takes an `int` and the property's minimum is 0, so a negative
+ * value is clamped rather than refused — the same clamp `normalizeWrapBoxSpacing` applies
+ * one widget over, restated here because that one carries the wrap box's UNIT machinery
+ * (`Adw.LengthUnit`) and a `Gtk.Box` has no unit to convert from.
+ */
+export declare function normalizeBoxSpacing(value: unknown): number;
+/** Whether writing `next` over `current` is a change the box must push to its children. */
+export declare function boxSpacingChanges(current: number, next: unknown): boolean;
+/**
+ * The margin shorthand that gives child `index` its share of the box's gap.
+ *
+ * `top right bottom left`, NativeScript's own order. The first child gets none: with N
+ * children there are N−1 gaps, and putting the gap on the LEADING edge of every child but
+ * the first is the only distribution that leaves the box's own bounds untouched.
+ */
+export declare function boxChildMargin(index: number, spacing: unknown, orientation: BoxOrientation): string;
+/**
+ * Where the child list ends up after an `insert_child_after` / `reorder_child_after`, or
+ * `null` where C would have hit a `g_return_if_fail`.
+ *
+ * SHARED WITH THE WRAP BOX RATHER THAN COPIED, and the name is the wrap box's only
+ * because that widget needed it first: the rule is `gtk_widget_insert_after`'s — a NULL
+ * sibling means the FIRST position, not the last — and `gtk_box_insert_child_after`
+ * documents itself by pointing at it. `resolveWrapBoxChildOrder` is generic over the
+ * child type and pure, so the alternative was a second copy of one paragraph of GTK
+ * semantics that could drift from the vectors already pinning it.
+ */
+export { resolveWrapBoxChildOrder as resolveBoxChildOrder };

package/lib/types/widgets/button-content.d.ts

@@ -5,17 +5,17 @@ export type { ButtonContentEllipsize };
 /** The class the content carries while `can-shrink` is set, for the theme to key off. */
 export declare const BUTTON_CONTENT_CAN_SHRINK_CLASS = "can-shrink";
 /**
- * The SVG the icon view is given: the app's, or the `image-missing` asset for an
- * empty slot — the fallback `init` applies too, while `icon_name` is still `""`.
+ * The icon the icon view is given: the app's, or the `image-missing` NAME for an empty
+ * slot — the fallback `init` applies too, while `icon_name` is still `""`.
  *
  * The C NEVER hides the image, only the label, so this port keeps the icon view
  * parented at all times and swaps its source. Upstream's own doc comments claim the
  * icon is hidden instead; the code disagrees with them and this follows the code
  * (see the conformance vector's `rule`).
  */
-export declare function buttonContentIconSvg(svg: string): string;
+export declare function buttonContentIcon(icon: string): string;
 /** Whether the icon shown is the empty-slot fallback rather than an app asset. */
-export declare function buttonContentIconIsFallback(svg: string): boolean;
+export declare function buttonContentIconIsFallback(icon: string): boolean;
 /**
  * The parent button's `className` with `image-text-button` added — the root-time half
  * of `adw_button_content_root`. Adds rather than rewrites, so a caller's composed

package/lib/types/widgets/button-slot.d.ts

@@ -0,0 +1,16 @@
+/** The slot a `Gtk.Button` currently shows. `empty` is a button with no child at all. */
+export type ButtonSlot = 'label' | 'icon' | 'child' | 'empty';
+/** Which property was written. */
+export type ButtonSlotWrite = 'label' | 'icon' | 'child';
+/**
+ * The slot a button shows after `wrote` was assigned `value`.
+ *
+ * AN EMPTY LABEL IS STILL THE LABEL SLOT, and an empty icon name is still the icon slot:
+ * `gtk_button_set_label("")` leaves a `GtkLabel` in the child, showing nothing — the
+ * button is not childless, it has an empty label. Only `set_child(NULL)` empties it, which
+ * is the one write that can return `empty`. Reading `''` as "clear the button" would make
+ * a caller who blanks a label lose the padding the child was holding.
+ */
+export declare function buttonSlotAfterWrite(wrote: ButtonSlotWrite, value: unknown): ButtonSlot;
+/** Whether moving from `from` to `to` has to detach the view `from` had parented. */
+export declare function buttonSlotDetaches(from: ButtonSlot, to: ButtonSlot): boolean;

package/lib/types/widgets/construct-props.d.ts

@@ -0,0 +1,82 @@
+/**
+ * The keys a widget's construct-props bag accepts, derived from the widget itself.
+ *
+ * Methods are dropped; everything else a caller could assign stays, its type read off the
+ * GETTER (so `size?: number` even though `set size(value: number | string)` also takes the
+ * string XML hands over — the bag is the TypeScript door, the attribute is the string one).
+ *
+ * A read-only accessor survives this type and is refused at RUNTIME instead. The
+ * `readonly`-detecting mapped type that would have caught `parent` at compile time was
+ * measured to drop `size` as well — a getter/setter pair with different types does not
+ * compare equal under it — and a type that silently loses real properties is worse than
+ * one that admits two impossible ones and says so when they arrive.
+ */
+export type ConstructProps<T> = Partial<{
+    [K in keyof T as T[K] extends (...args: never[]) => unknown ? never : K]: K extends AlignmentProp ? T[K] | number : T[K];
+}>;
+/**
+ * The NativeScript properties whose value this package reads as a `Gtk.Align`.
+ *
+ * `horizontalAlignment` and `verticalAlignment` are NativeScript's own — declared by
+ * `View`, never re-declared by a widget here — so this is a WIDENING of what they accept
+ * and not a second vocabulary: every NativeScript spelling passes through untouched, and
+ * only the GTK-side ones are translated.
+ *
+ * WHERE THIS DOOR AND THE ATTRIBUTE DOOR DISAGREE, exactly. NativeScript's `verticalAlignment`
+ * is `'top' | 'middle' | 'bottom' | 'stretch'`, and its layout pass sends anything else to the
+ * `default:` arm, which is `stretch`
+ * (`ui/core/view/view-helper/view-helper-common.ts`, both platforms). So the three GTK
+ * spellings this table TRANSLATES on that axis — `center`, `start`, `end` — reach the widget
+ * as `middle`/`top`/`bottom` through the bag and as themselves through
+ * `<adw:Avatar verticalAlignment="center">`, where they silently stretch. The horizontal axis
+ * has no such gap: `start`, `end` and `center` are NativeScript's own words, and `fill` maps
+ * to `stretch`, which is also what the `default:` arm does with it. Nothing here closes the
+ * vertical three — the attribute door has no coercer to hang this on and a per-widget
+ * `set verticalAlignment` would shadow `View`'s, which is the hazard arm 2 of
+ * `check-nativescript-xml-doors.mjs` exists for — so it is a declared divergence and the same
+ * § 1 convergence question ADR 0034 § Amendment 12 leaves open for `halign` / `valign`.
+ */
+declare const ALIGNMENT_AXES: {
+    readonly horizontalAlignment: "horizontal";
+    readonly verticalAlignment: "vertical";
+};
+/**
+ * The keys the bag reads as a `Gtk.Align` — the runtime table's OWN key set, so the type
+ * cannot admit one the applier does not translate or refuse one it does.
+ *
+ * {@link ConstructProps} widens exactly these to `| number`. Without it the constant spelling
+ * was reachable at runtime and refused by the compiler: `new AdwAvatar({ horizontalAlignment:
+ * Gtk.Align.CENTER })` was `TS2322: Type 'number' is not assignable to type 'string'`, which
+ * is the one caller the second spelling exists for.
+ */
+export type AlignmentProp = keyof typeof ALIGNMENT_AXES;
+/**
+ * A `Gtk.Align` value — the nick, or the constant a GJS caller's `Gtk.Align.CENTER` is —
+ * as the NativeScript alignment for `axis`. Any other value is NativeScript's own and is
+ * returned unchanged.
+ *
+ * The number spelling is resolved through {@link GTK_ALIGN} rather than assumed, because
+ * the constants are NOT the positions in the nick list: `GTK_ALIGN_BASELINE` was
+ * deprecated in GTK 4.12 and made an ALIAS of `GTK_ALIGN_BASELINE_FILL`, so both are 4 and
+ * `GTK_ALIGN_BASELINE_CENTER` is 5 where its position says 6.
+ */
+export declare function nsAlignment(value: unknown, axis: 'horizontal' | 'vertical'): unknown;
+/**
+ * Apply a construct-props bag through the target's declared setters.
+ *
+ * Called as the LAST statement of a widget's own constructor, so the bag wins over whatever
+ * that constructor set up — which is the point of a construct property.
+ *
+ * An `undefined` VALUE is skipped rather than assigned: every key of a `Partial` is
+ * optional, so `{ title: maybeTitle }` is the ordinary spelling of "set it if I have one",
+ * and assigning `undefined` there would clear a default the constructor had just chosen. An
+ * unknown KEY still throws — the key is what the caller got wrong.
+ *
+ * The parameter is a bare record rather than `ConstructProps<T>` because inside a
+ * constructor `this` has the POLYMORPHIC this-type: a generic `<T extends object>(target: T,
+ * props?: ConstructProps<T>)` infers `T` as `this`, and `ConstructProps<AdwAvatar>` is not
+ * assignable to `ConstructProps<this>` — 46 of 46 call sites failed to compile that way. The
+ * typed door is the widget's own constructor signature; this is what it hands over.
+ */
+export declare function applyConstructProps(target: object, props?: Readonly<Record<string, unknown>>): void;
+export {};

package/lib/types/widgets/entry-row-view.d.ts

@@ -37,7 +37,7 @@ export interface PasswordEntryRowViews {
     field: {
         secure: boolean;
     };
-    /** The peek toggle, whose `icon` takes an Adwaita symbolic SVG string. */
+    /** The peek toggle, whose `iconName` takes an Adwaita icon name or SVG source. */
     peekButton: {
         iconName: string;
     };
@@ -47,7 +47,7 @@ export declare const NS_ENTRY_ROW_CLASS = "adw-row adw-action-row adw-entry-row"
 /** Base class list of a password entry row. */
 export declare const NS_PASSWORD_ENTRY_ROW_CLASS = "adw-row adw-action-row adw-entry-row adw-password-entry-row";
 /** Class list of the trailing pencil. */
-export declare const NS_EDIT_ICON_CLASS = "adw-icon adw-entry-edit";
+export declare const NS_EDIT_ICON_CLASS = "gtk-image adw-entry-edit";
 /**
  * Marker class for a desensitized part. NS has no insensitive state, so the
  * class is only a styling hook — {@link NS_INSENSITIVE_OPACITY} is what the user
@@ -85,12 +85,13 @@ export declare function entryRowClassName(base: string, state: EntryRowRenderSta
  */
 export declare function applyEntryRowState(views: EntryRowViews, state: EntryRowRenderState, base: string): void;
 /**
- * The Adwaita symbolic SVG for a canonical peek icon name.
+ * Paint one password-entry-row render snapshot — `notify_visibility_cb` (C:62-81).
  *
- * The core names the icon the way the C does (`view-reveal-symbolic` /
- * `view-conceal-symbolic`, adw-password-entry-row.c:68,73); this is the one
- * place that maps a name onto the asset `@gjsify/adwaita-icons` ships.
+ * The peek icon goes through UNTRANSLATED. The core names it the way the C does
+ * (`view-reveal-symbolic` / `view-conceal-symbolic`, adw-password-entry-row.c:68,73),
+ * and since `icon-theme.ts` this port resolves that name at the widget — so the
+ * `peekIconSvg` that used to sit here, mapping the two names onto two imported
+ * documents, was one of four hand-rolled registries and is gone. Its whole body was
+ * the substitution the registry now performs for every name at once.
  */
-export declare function peekIconSvg(iconName: PasswordEntryRowRenderState['peekIconName']): string;
-/** Paint one password-entry-row render snapshot — `notify_visibility_cb` (C:62-81). */
 export declare function applyPasswordEntryRowState(views: PasswordEntryRowViews, state: PasswordEntryRowRenderState): void;

package/lib/types/widgets/gtk-align.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Every `Gtk.Align` member, in GIR declaration order.
+ *
+ * Held against `GtkAlignNick` in `packages/framework/gtk-host/src/generated/props.ts` —
+ * in-repo, GIR-derived, emitted by a generator that has never heard of this port — so this
+ * array is a copy that cannot drift rather than a second source.
+ */
+export declare const GTK_ALIGN_NICKS: readonly ["fill", "start", "end", "center", "baseline-fill", "baseline", "baseline-center"];
+/**
+ * The members that are a SECOND NAME for another member rather than a value of their own,
+ * as alias to the member it stands for.
+ *
+ * The single authored GIR fact in this file. An alias takes its target's number and does
+ * not consume one, which is what shifts every later member below its position.
+ *
+ * `baseline` is here because GTK 4.12 deprecated `GTK_ALIGN_BASELINE` in favour of
+ * `GTK_ALIGN_BASELINE_FILL` and gave the new name the SAME value — "a different name for
+ * `GTK_ALIGN_BASELINE`", as the GIR doc on `baseline-fill` puts it — rather than adding a
+ * member. That is the whole of the off-by-one below it.
+ */
+export declare const GTK_ALIGN_ALIASES: Readonly<Record<string, string>>;
+/**
+ * Every `Gtk.Align` member, nick to constant.
+ *
+ * Six distinct values across seven nicks: `baseline` and `baseline-fill` are the same
+ * member under two names.
+ */
+export declare const GTK_ALIGN: Readonly<Record<string, number>>;
+/**
+ * `Gtk.Align` to `View.horizontalAlignment`.
+ *
+ * FOUR OF THE SEVEN MEMBERS MAP, not two. ADR 0034 § Context measured NativeScript's
+ * horizontal vocabulary as `'left' | 'center' | 'right' | 'stretch'` and concluded that
+ * `start` and `end` have no counterpart; `@nativescript/core` 9.0.21-next.15 declares
+ * `'start' | 'left' | 'center' | 'right' | 'end' | 'stretch'` (`core-types/index.ts:127`),
+ * and its shared layout pass resolves `start`/`end` against the view's own `direction`
+ * (`ui/core/view/view-helper/view-helper-common.ts:98-111`) — the same direction-relative
+ * meaning GTK gives them. The remainder is the three baselines and nothing else.
+ */
+export declare const NS_HORIZONTAL_ALIGNMENT: Readonly<Record<string, string>>;
+/**
+ * `Gtk.Align` to `View.verticalAlignment`.
+ *
+ * NativeScript's vertical vocabulary is `'top' | 'middle' | 'bottom' | 'stretch'` — no
+ * `center` and no `start`/`end`, so all four mapped members are genuinely translated here
+ * rather than passed through. GTK's vertical `start`/`end` are not direction-relative
+ * (`gtkenums.h` scopes that to the horizontal context), which is why they can be top and
+ * bottom without asking the view which way its text runs.
+ */
+export declare const NS_VERTICAL_ALIGNMENT: Readonly<Record<string, string>>;
+/**
+ * Why a `Gtk.Align` member has no NativeScript counterpart on either axis.
+ *
+ * ADR 0034 § 1's declared remainder: a member that is absent from both maps and absent from
+ * here is a silent omission, and the gate fails on it.
+ */
+export declare const GTK_ALIGN_REFUSALS: Readonly<Record<string, string>>;
+/** The refusal reason for `nick`, for an error message that says why and not only no. */
+export declare function gtkAlignRefusal(nick: string): string;