@gjsify/adwaita-core 0.51.1 → 0.52.0

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

@@ -1,4 +1,4 @@
-import type { BottomSheetCloseOutcome, BottomSheetCloseSource, BottomSheetTeardownCallback } from '../dialog.js';
+import type { BottomSheetChrome, BottomSheetCloseOutcome, BottomSheetCloseSource, BottomSheetOpenOutcome, BottomSheetOpenSource, BottomSheetSwipeTrackerConfig, BottomSheetSwipeTrackerState, BottomSheetTeardownCallback } from '../dialog.js';
 /** One `resolveBottomSheetClose` expectation. */
 export interface BottomSheetCloseVector {
     /** Which affordance asked to close. */
@@ -90,3 +90,125 @@ export declare function runBottomSheetSteps(adapter: BottomSheetPresentationAdap
  * carrying an unchanged payload.
  */
 export declare const BOTTOM_SHEET_PRESENTATION_VECTORS: ReadonlyArray<BottomSheetPresentationVector>;
+/** One `resolveBottomSheetOpen` expectation. */
+export interface BottomSheetOpenVector {
+    /** Which affordance asked to open. */
+    source: BottomSheetOpenSource;
+    /** `AdwBottomSheet:open` at the time of the request. */
+    open: boolean;
+    /** `AdwBottomSheet:can-open` at the time of the request. */
+    canOpen: boolean;
+    /** Whether `AdwBottomSheet:bottom-bar` is set. */
+    hasBottomBar: boolean;
+    /** `AdwBottomSheet:reveal-bottom-bar`. */
+    revealBottomBar: boolean;
+    /** What the C source does with it. */
+    outcome: BottomSheetOpenOutcome;
+    rule: string;
+    derivedFrom: string;
+}
+/**
+ * Every distinguishable `(source, open, canOpen, hasBottomBar, revealBottomBar)` the open
+ * gate answers differently for — so a renderer cannot pass by wiring the bar to `open = true`
+ * and calling it done.
+ */
+export declare const BOTTOM_SHEET_OPEN_VECTORS: ReadonlyArray<BottomSheetOpenVector>;
+/** One `resolveBottomSheetSwipeTracker` expectation. */
+export interface BottomSheetSwipeTrackerVector {
+    /** The four properties `update_swipe_tracker` reads. */
+    state: BottomSheetSwipeTrackerState;
+    /** The three settings it writes. */
+    config: BottomSheetSwipeTrackerConfig;
+    rule: string;
+    derivedFrom: string;
+}
+/**
+ * `update_swipe_tracker`'s three assignments, row by row.
+ *
+ * CORE-ONLY: an `AdwSwipeTracker` has no counterpart in either port — neither renderer runs a
+ * gesture tracker, so there is no object to read these settings off. Its `enabled` line is
+ * the same fact as the `'swipe'` rows of BOTTOM_SHEET_OPEN_VECTORS and BOTTOM_SHEET_CLOSE_VECTORS,
+ * which both renderers drive against their real widgets; this table is the third assignment
+ * and the conjunction written out, not a second source of truth.
+ */
+export declare const BOTTOM_SHEET_SWIPE_TRACKER_VECTORS: ReadonlyArray<BottomSheetSwipeTrackerVector>;
+/** One step of a {@link BottomSheetBottomBarVector}, in the order it is applied. */
+export type BottomSheetBottomBarStep = 
+/** `adw_bottom_sheet_set_bottom_bar` — a widget, or NULL. */
+{
+    readonly kind: 'setBottomBar';
+    readonly present: boolean;
+}
+/** `adw_bottom_sheet_set_can_open`. */
+ | {
+    readonly kind: 'setCanOpen';
+    readonly canOpen: boolean;
+}
+/** `adw_bottom_sheet_set_reveal_bottom_bar`. */
+ | {
+    readonly kind: 'setRevealBottomBar';
+    readonly reveal: boolean;
+}
+/** `adw_bottom_sheet_set_modal`. */
+ | {
+    readonly kind: 'setModal';
+    readonly modal: boolean;
+}
+/** The programmatic path — `adw_bottom_sheet_set_open`, ignores `can-open`. */
+ | {
+    readonly kind: 'setOpen';
+    readonly open: boolean;
+}
+/** The interactive path — runs the {@link BOTTOM_SHEET_OPEN_VECTORS} gate. */
+ | {
+    readonly kind: 'requestOpen';
+    readonly source: BottomSheetOpenSource;
+};
+/**
+ * One end-to-end bottom-bar expectation.
+ *
+ * Every field is observable from a RENDERER: `chrome` is what it has to paint (which layer
+ * shows, whether the surface is on screen, whether the bar looks inert) and `notifications`
+ * is the `notify::open` stream. So the same row drives the core suite and both renderer
+ * suites against their real widgets.
+ */
+export interface BottomSheetBottomBarVector {
+    /** Applied in order, through the surface every implementation exposes. */
+    steps: readonly BottomSheetBottomBarStep[];
+    /** The outcome of each `requestOpen` step, in order. */
+    outcomes: readonly BottomSheetOpenOutcome[];
+    /** Every `notify::open` payload, in order. */
+    notifications: readonly boolean[];
+    /** `open` after the last step. */
+    open: boolean;
+    /** What the renderer must be showing after the last step. */
+    chrome: BottomSheetChrome;
+    rule: string;
+    derivedFrom: string;
+}
+/**
+ * The three-plus-two-method surface a {@link BottomSheetBottomBarVector} is replayed
+ * against. Core implements it directly; each renderer implements it by driving its REAL
+ * widget (adopting a bar child, writing an attribute, clicking the bar).
+ */
+export interface BottomSheetBottomBarAdapter {
+    /** Give the sheet a bottom bar, or take it away (`AdwBottomSheet:bottom-bar`). */
+    setBottomBar(present: boolean): void;
+    /** `AdwBottomSheet:can-open`. */
+    setCanOpen(canOpen: boolean): void;
+    /** `AdwBottomSheet:reveal-bottom-bar`. */
+    setRevealBottomBar(reveal: boolean): void;
+    /** `AdwBottomSheet:modal`. */
+    setModal(modal: boolean): void;
+    /** The programmatic path (`AdwBottomSheet:open`). */
+    setOpen(open: boolean): void;
+    /** The interactive path — returns what the gate decided. */
+    requestOpen(source: BottomSheetOpenSource): BottomSheetOpenOutcome;
+}
+/**
+ * Replay a vector's steps against `adapter`, collecting the outcome of each `requestOpen`
+ * step in order. Shared by all three suites so no side can drift in HOW it replays a row.
+ */
+export declare function runBottomSheetBottomBarSteps(adapter: BottomSheetBottomBarAdapter, steps: readonly BottomSheetBottomBarStep[]): BottomSheetOpenOutcome[];
+/** The bottom bar's life as scripts: adopting one, gating it, revealing it, clicking it. */
+export declare const BOTTOM_SHEET_BOTTOM_BAR_VECTORS: ReadonlyArray<BottomSheetBottomBarVector>;

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

@@ -12,8 +12,8 @@ export { BUTTON_STYLE_CLASS_VECTORS } from './button.js';
 export type { ButtonStyleClassVector } from './button.js';
 export { RADIO_GROUP_VECTORS } from './checks.js';
 export type { RadioGroupStep, RadioGroupVector } from './checks.js';
-export { COMBO_CHOOSER_VECTORS, COMBO_SELECTION_VECTORS } from './rows.js';
-export type { ComboChooserVector, ComboSelectionStep, ComboSelectionVector } from './rows.js';
+export { COMBO_CHOOSER_VECTORS, COMBO_SELECTION_VECTORS, TOGGLE_ACTIVE_NAME_VECTORS } from './rows.js';
+export type { ComboChooserVector, ComboSelectionStep, ComboSelectionVector, ToggleActiveNameVector } from './rows.js';
 export { VIEW_STACK_ICON_NAME_VECTORS, VIEW_STACK_PAGE_VECTORS, VIEW_STACK_VECTORS } from './view-stack.js';
 export type { ViewStackIconNameVector, ViewStackPageDescriptorVector, ViewStackVector, ViewStackVectorChange, ViewStackVectorOp, ViewStackVectorPage, } from './view-stack.js';
 export { NAVIGATION_VIEW_VECTORS, collectNavigationState, navigationEventLog, runNavigationSteps, } from './navigation-view.js';
@@ -44,8 +44,8 @@ export { CASE_FOLD_VECTORS, MAKE_COMPARABLE_VECTORS, PREFERENCES_GROUP_HEADER_VE
 export type { CaseFoldVector, MakeComparableVector, PreferencesGroupHeaderVector, PreferencesSearchExpectation, PreferencesSearchVector, RowMatchVector, SearchCorpusVector, SearchRowSubtitleVector, StripMarkupVector, StripMnemonicVector, } from './preferences.js';
 export { CLAMP_ALLOCATE_VECTORS, CLAMP_CHILD_SIZE_VECTORS, CLAMP_PROPERTY_VECTORS, CLAMP_SIZE_FROM_CHILD_VECTORS, CLAMP_THRESHOLD_VECTORS, SPINNER_GEOMETRY_VECTORS, SPINNER_SIZE_VECTORS, TOOLBAR_VIEW_ALLOCATE_VECTORS, TOOLBAR_VIEW_CLASS_VECTORS, TOOLBAR_VIEW_CONTENT_FOR_SIZE_VECTORS, TOOLBAR_VIEW_MEASURE_VECTORS, } from './chrome.js';
 export type { ClampAllocateVector, ClampChildSizeVector, ClampPropertyVector, ClampSizeFromChildVector, ClampThresholdsVector, SpinnerGeometryVector, SpinnerSizeVector, ToolbarViewAllocateVector, ToolbarViewClassVector, ToolbarViewContentForSizeVector, ToolbarViewMeasureVector, } from './chrome.js';
-export { BOTTOM_SHEET_CLOSE_VECTORS, BOTTOM_SHEET_PRESENTATION_VECTORS, runBottomSheetSteps } from './dialog.js';
-export type { BottomSheetCloseVector, BottomSheetPresentationAdapter, BottomSheetPresentationStep, BottomSheetPresentationVector, } from './dialog.js';
+export { BOTTOM_SHEET_BOTTOM_BAR_VECTORS, BOTTOM_SHEET_CLOSE_VECTORS, BOTTOM_SHEET_OPEN_VECTORS, BOTTOM_SHEET_PRESENTATION_VECTORS, BOTTOM_SHEET_SWIPE_TRACKER_VECTORS, runBottomSheetBottomBarSteps, runBottomSheetSteps, } from './dialog.js';
+export type { BottomSheetBottomBarAdapter, BottomSheetBottomBarStep, BottomSheetBottomBarVector, BottomSheetCloseVector, BottomSheetOpenVector, BottomSheetPresentationAdapter, BottomSheetPresentationStep, BottomSheetPresentationVector, BottomSheetSwipeTrackerVector, } from './dialog.js';
 export { POPOVER_KEY_VECTORS, POPOVER_SURFACE_VECTORS } from './popover.js';
 export type { PopoverKeyVector, PopoverSurfaceVariant, PopoverSurfaceVector } from './popover.js';
 export { ACCENT_COLOR_VECTORS } from './accent.js';
@@ -54,11 +54,19 @@ export { formatShortcutLabelNodes, SHORTCUT_LABEL_VECTORS } from './shortcut-lab
 export type { ShortcutLabelVector } from './shortcut-label.js';
 export { SPINNER_ARC_ENVELOPE, SPINNER_ARC_PHASE_VECTORS, SPINNER_ARC_TOLERANCE, SPINNER_CONSTANT_VECTORS, } from './spinner.js';
 export type { SpinnerArcShapeVector, SpinnerConstantVector } from './spinner.js';
+export { BOX_ORIENTATION_VECTORS, BOX_SPACING_VECTORS } from './box.js';
+export type { BoxOrientationVector, BoxSpacingVector } from './box.js';
+export { LABEL_CHAR_COUNT_VECTORS, LABEL_DISPLAY_TEXT_VECTORS, LABEL_EFFECTIVE_LINES_VECTORS, LABEL_ELLIPSIZE_OVERFLOW_VECTORS, LABEL_ELLIPSIZE_VECTORS, LABEL_JUSTIFY_VECTORS, LABEL_WIDTH_CHARS_EXTENT_VECTORS, LABEL_WRAP_MODE_VECTORS, LABEL_XALIGN_VECTORS, LABEL_YALIGN_ALIGN_ITEMS_VECTORS, LABEL_YALIGN_VECTORS, } from './label.js';
+export type { LabelCharCountVector, LabelDisplayTextVector, LabelEffectiveLinesVector, LabelEllipsizeOverflowVector, LabelEllipsizeVector, LabelJustifyVector, LabelWidthCharsExtentVector, LabelWrapModeVector, LabelXalignVector, LabelYalignAlignItemsVector, LabelYalignVector, } from './label.js';
 export { WRAP_BOX_CHILD_ORDER_VECTORS, WRAP_BOX_LENGTH_VECTORS, WRAP_BOX_LINE_VECTORS, WRAP_BOX_NATURAL_LENGTH_VECTORS, WRAP_BOX_NOTIFY_PROPERTIES, WRAP_BOX_POLICY_VECTORS, WRAP_BOX_SPACING_NOTIFY_VECTORS, WRAP_BOX_SPACING_VECTORS, } from './wrap-box.js';
 export type { WrapBoxChildOrderVector, WrapBoxLengthVector, WrapBoxLineVector, WrapBoxNaturalLengthVector, WrapBoxPolicyVector, WrapBoxSpacingNotifyVector, WrapBoxSpacingVector, } from './wrap-box.js';
 export { BREAKPOINT_PICK_VECTORS, BREAKPOINT_TRANSITION_VECTORS } from './breakpoint-bin.js';
 export type { BreakpointPickVector, BreakpointTransitionVector } from './breakpoint-bin.js';
 export { HEADER_BAR_PACK_VECTORS, HEADER_BAR_TITLE_SOURCE_VECTORS, HEADER_BAR_TITLE_WIDGET_VECTORS, } from './header-bar.js';
 export type { HeaderBarPackVector, HeaderBarTitleSourceVector, HeaderBarTitleWidgetVector } from './header-bar.js';
-export { SHARED_TREE_BLOCKS_WITHOUT_EXPECTATIONS, SHARED_TREE_TABLES, authoredNodes, authoredTags, reachedTables, sharedTreeExpectations, subjectIndexOf, } from './shared-trees.js';
-export type { SharedTreeExpectation, SharedTreeNode, SharedTreeObservable } from './shared-trees.js';
+export { ATTRIBUTE_OF_VECTORS, HOST_TAG_VECTORS, PROPERTY_OF_VECTORS } from './tags.js';
+export type { AttributeOfVector, HostTagVector, PropertyOfVector } from './tags.js';
+export { VALUE_LIST_VECTORS } from './value-lists.js';
+export type { ValueListResponse, ValueListVector } from './value-lists.js';
+export { SHARED_TREE_BLOCKS_WITHOUT_EXPECTATIONS, SHARED_TREE_TABLES, authoredNodes, authoredTags, reachedTables, sharedTreeExpectations, sharedTreePlacements, subjectIndexOf, withoutPlacements, } from './shared-trees.js';
+export type { SharedTreeExpectation, SharedTreeNode, SharedTreeObservable, SharedTreePlacement, } from './shared-trees.js';

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

@@ -0,0 +1,115 @@
+/** One `label` + flags and the text shown. */
+export interface LabelDisplayTextVector {
+    label: string;
+    useMarkup: boolean;
+    useUnderline: boolean;
+    text: string;
+    rule: string;
+}
+export declare const LABEL_DISPLAY_TEXT_VECTORS: ReadonlyArray<LabelDisplayTextVector>;
+/** One authored `xalign` and the value the label holds. */
+export interface LabelXalignVector {
+    value: number | string | null;
+    xalign: number;
+    rule: string;
+}
+/** `gtk_label_set_xalign` CLAMPs to 0…1 itself; the pspec default is 0.5. */
+export declare const LABEL_XALIGN_VECTORS: ReadonlyArray<LabelXalignVector>;
+/** One authored `justify` and the `Gtk.Justification` nick the label holds. */
+export interface LabelJustifyVector {
+    value: string | null;
+    justify: 'left' | 'right' | 'center' | 'fill';
+    rule: string;
+}
+export declare const LABEL_JUSTIFY_VECTORS: ReadonlyArray<LabelJustifyVector>;
+/** One authored `yalign` and the value the label holds. Same shape as `xalign`. */
+export interface LabelYalignVector {
+    value: number | string | null;
+    yalign: number;
+    rule: string;
+}
+/** `gtk_label_set_yalign` CLAMPs to 0…1 itself; the pspec default is 0.5. */
+export declare const LABEL_YALIGN_VECTORS: ReadonlyArray<LabelYalignVector>;
+/** One `yalign` and the `align-items` zone it is nearest to. */
+export interface LabelYalignAlignItemsVector {
+    yalign: number;
+    alignItems: 'flex-start' | 'center' | 'flex-end';
+    rule: string;
+}
+/**
+ * TRUE nearest-of-three, not a strict half-split: the boundary between "nearest 0" and
+ * "nearest 0.5" is their midpoint, `0.25`, and symmetrically `0.75` on the other side —
+ * a `yalign` short of a full CSS continuum still lands on the CLOSER zone rather than
+ * whichever half of `[0, 1]` it falls in. Exact at the three values GTK's own default and
+ * both edges take (0, 0.5, 1); the four intermediate rows (`0.2`/`0.3`/`0.7`/`0.8`) are the
+ * ones a strict `< 0.5`/`> 0.5` split gets wrong — `0.3` is closer to `0.5` than to `0`,
+ * so it belongs in `center`, not `flex-start`.
+ */
+export declare const LABEL_YALIGN_ALIGN_ITEMS_VECTORS: ReadonlyArray<LabelYalignAlignItemsVector>;
+/** One authored `ellipsize` and the `Pango.EllipsizeMode` nick the label holds. */
+export interface LabelEllipsizeVector {
+    value: string | null;
+    ellipsize: 'none' | 'start' | 'middle' | 'end';
+    rule: string;
+}
+/** `Pango-1.0.gir`'s four `EllipsizeMode` nicks, read via `gi://Pango` under gjs 1.88.1. */
+export declare const LABEL_ELLIPSIZE_VECTORS: ReadonlyArray<LabelEllipsizeVector>;
+/** One `Pango.EllipsizeMode` nick and the ONE truncating value both renderers can draw. */
+export interface LabelEllipsizeOverflowVector {
+    ellipsize: 'none' | 'start' | 'middle' | 'end';
+    overflow: 'clip' | 'ellipsis';
+    rule: string;
+}
+/**
+ * Neither CSS `text-overflow` nor NativeScript's `textOverflow` has a start- or
+ * middle-truncating mode — see `labelEllipsizeOverflowValue`'s own comment for why every
+ * non-`none` mode draws an end-ellipsis rather than a silent `clip`. `start` and `middle`
+ * are the DECLARED divergence these two rows pin.
+ */
+export declare const LABEL_ELLIPSIZE_OVERFLOW_VECTORS: ReadonlyArray<LabelEllipsizeOverflowVector>;
+/** One authored `wrap-mode` and the `Pango.WrapMode` nick the label holds. */
+export interface LabelWrapModeVector {
+    value: string | null;
+    wrapMode: 'word' | 'char' | 'word-char';
+    rule: string;
+}
+/** `Pango-1.0.gir`'s three `WrapMode` nicks, read via `gi://Pango` under gjs 1.88.1. */
+export declare const LABEL_WRAP_MODE_VECTORS: ReadonlyArray<LabelWrapModeVector>;
+/** One authored value and the int `width-chars` / `max-width-chars` / `lines` all hold. */
+export interface LabelCharCountVector {
+    value: number | string | null;
+    count: number;
+    rule: string;
+}
+/**
+ * `width-chars`, `max-width-chars` and `lines` share one pspec shape — floor `-1`, default
+ * `-1` — so one table drives all three normalizers in `label.spec.ts`. Measured through
+ * `label.set_property()`, the door an attribute-driven tree uses (`label.ts`'s header).
+ */
+export declare const LABEL_CHAR_COUNT_VECTORS: ReadonlyArray<LabelCharCountVector>;
+/** One `lines` / `ellipsize` combination and the line count a renderer applies. */
+export interface LabelEffectiveLinesVector {
+    lines: number;
+    ellipsize: 'none' | 'start' | 'middle' | 'end';
+    effective: number | null;
+    rule: string;
+}
+/**
+ * MEASURED (a real `Gtk.Label`, allocated, gjs 1.88.1 / gtk 4.22.5) — `wrap` is
+ * deliberately not a column here, because it changes NONE of these outcomes.
+ * `wrap=TRUE, ellipsize=NONE, lines=2` laid out 15 lines (the cap ignored);
+ * `wrap=FALSE, ellipsize=END, lines=2` laid out exactly 2, ellipsized. `label.ts`'s header
+ * carries the fuller measurement, including the two prior, WRONG readings of the pspec's
+ * "has no effect if the label is not wrapping or ellipsized" this table replaced.
+ */
+export declare const LABEL_EFFECTIVE_LINES_VECTORS: ReadonlyArray<LabelEffectiveLinesVector>;
+/** One `width-chars` + `max-width-chars` pair and the `ch`-unit extent it derives. */
+export interface LabelWidthCharsExtentVector {
+    widthChars: number;
+    maxWidthChars: number;
+    minCh: number | null;
+    maxCh: number | null;
+    rule: string;
+}
+/** `get_default_widths` (gtklabel.c): minimum is `width-chars`, natural is their MAX. */
+export declare const LABEL_WIDTH_CHARS_EXTENT_VECTORS: ReadonlyArray<LabelWidthCharsExtentVector>;

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

@@ -65,3 +65,32 @@ export interface ComboChooserVector {
  * which is why this lives on the combo ROW rather than in the shared chooser.
  */
 export declare const COMBO_CHOOSER_VECTORS: ReadonlyArray<ComboChooserVector>;
+/** One authored `active-name`, over toggles carrying these names. */
+export interface ToggleActiveNameVector {
+    /** Each authored toggle's `name`, in document order; `null` is unnamed. */
+    names: readonly (string | null)[];
+    /** The authored `Adw.ToggleGroup:active-name`. */
+    activeName: string;
+    /** How many toggles the group keeps — `keptToggles`, the buttons a built group draws. */
+    kept: number;
+    /** What `toggleIndexOfName` answers over the kept names — `-1` for none. */
+    index: number;
+    /** The button a BUILT group shows active afterwards. */
+    active: number;
+    rule: string;
+}
+/**
+ * `adw_toggle_group_set_active_name` (adw-toggle-group.c:1989) resolves the name through
+ * the table `add_toggle` fills (:898), and a `.blp` writes it BEFORE the toggles exist —
+ * GtkBuilder sets properties first and children after, which is why the C holds the name
+ * back in `delayed_active_name` until `parser_finished` (:1247). `active` is therefore a
+ * row about the built tree, not about the lookup: a renderer that resolves the name the
+ * moment it is written finds no toggles and drops it.
+ *
+ * The first toggle is active before the name is applied, because `add_toggle` activates
+ * the first toggle it is given (:903). Every row was measured against libadwaita 1.9.3
+ * through `Gtk.Builder`, and the shared-name row is the one the source reading got wrong
+ * first: the table insert at :898 looks like "last one wins", but :849 refuses the second
+ * toggle before it is ever reached.
+ */
+export declare const TOGGLE_ACTIVE_NAME_VECTORS: ReadonlyArray<ToggleActiveNameVector>;

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

@@ -1,9 +1,124 @@
-/** One node of an authored tree — the shape `ADWAITA_GALLERY_SHARED_TREES` is written in. */
+/**
+ * One node of an authored tree — the shape `ADWAITA_GALLERY_SHARED_TREES` is written in.
+ *
+ * THIS DECLARATION IS THE ORIGINAL. Every other spelling of the shape in this repository
+ * restates it — `scripts/adwaita-gallery-shared-trees.d.mts` for the plain-Node generators,
+ * `packages/infra/blueprint/src/shared-node.d.mts` for the projection, and more besides —
+ * each because it cannot import from here, each saying why in its own header.
+ * `scripts/check-shared-tree-shape.mjs` carries the list, holds every entry to this
+ * declaration field by field, and fails on a spelling that declares itself nowhere. So a
+ * field added here is added there too, or the gate says which field and where.
+ */
 export interface SharedTreeNode {
     /** A GIR class name, e.g. `AdwPreferencesGroup`. */
     tag: string;
+    /**
+     * The name this node is addressed by from OUTSIDE the tree.
+     *
+     * Renderer-neutral because every surface already has one — a GtkBuilder object id, a DOM
+     * `id`, a NativeScript `id` — and worth carrying although `bind` stays a refusal: measured
+     * in ADR 0066, EVERY id in this repository's shipped `.blp` is named by the sibling
+     * TypeScript through `InternalChildren` and NONE by a `bind` inside the file. A name read
+     * from outside is the component's addressing surface, not an input to a binding language.
+     */
+    id?: string;
+    /**
+     * On the ROOT node: the composite class this tree DEFINES, where `tag` is the type it
+     * extends.
+     *
+     * `template $GalleryHeaderBar : Adw.Bin` is `{ tag: 'AdwBin', template: 'GalleryHeaderBar' }`
+     * — two facts that a single tag cannot carry, which is why the root of every shipped `.blp`
+     * projected to its PARENT type and said nothing about the class the file is about. The value
+     * is what GtkBuilder writes as `<template class="…">`, so `emitGtkBuilderXml` and the
+     * projection can be held against each other on it — and are, by stage D's addressing arm.
+     */
+    template?: string;
+    /**
+     * Where in the parent this child goes — the placement, spelled as the GTK side spells it.
+     *
+     * ONE FIELD FOR TWO GtkBuilder CONSTRUCTS, and the conflation is the projection's, not a
+     * choice made here: `[start]` is `<child type="start">` and `content: …` is a
+     * property-valued child, and both land on this field, so it cannot be inverted (the
+     * Blueprint corpus's `expectations.mjs` states it as finding 1). A renderer therefore has
+     * to answer to both spellings of a placement it has — `gtk-host` derives the property name
+     * from its own `set_`-prefixed slot method, `<adw-header-bar>` names `title-widget` beside
+     * its own `center`.
+     *
+     * A SHARED TREE MAY CARRY ONE ONLY WHERE EVERY RENDERER SPELLS IT THE SAME. That is the
+     * corpus's no-alias admission rule applied to a placement, and it is narrow: a row's
+     * `prefix`/`suffix` qualify, a header bar's `start`/`title`/`end` do not
+     * (`startBox`/`titleWidget`/`endBox` on the NativeScript port), which is why those blocks
+     * are ledgered as `vocabulary` divergences. A renderer handed a name it has no destination
+     * for REFUSES and says which — the alternative was measured on a shipped `.blp`, where a
+     * `[top]` header bar landed in the content and the window title was then discarded by the
+     * bar's own construction, at exit 0.
+     */
     slot?: string;
     props?: Readonly<Record<string, string | number | boolean>>;
+    /**
+     * Which of this node's `props` are marked for translation, keyed by the prop name.
+     *
+     * A present key means marked; `context` carries the message context `C_("noun", …)` gives
+     * one. BESIDE `props` and not inside it, because that is what the marking is wherever a
+     * surface has one: GtkBuilder writes `translatable="yes" context="noun"` as attributes NEXT
+     * to the value, and a marked value is still the same value. Widening `props` to a union
+     * would make every reader of a value narrow past something that is not one.
+     *
+     * Worth carrying although no renderer here translates: a caption whose marking was dropped
+     * looks finished and is unreachable by `xgettext`, which is the exact defect ADR 0033 gives
+     * as its reason for preferring a declarative template. ADR 0067 measures it and says why
+     * the file-level `translation-domain` is not a node fact and stays a loss.
+     */
+    translatable?: Readonly<Record<string, {
+        readonly context?: string;
+    }>>;
+    /**
+     * The style classes this node carries, as a list, in the order the source wrote them.
+     *
+     * ONE FIELD FOR TWO SPELLINGS, because they are one GTK property. Blueprint writes
+     * `styles ["flat", "circular"]` as a block and `css-classes: ["flat", "narrow"]` as a
+     * property value, and both set `GtkWidget:css-classes` — measured against the reference
+     * compiler, which writes the first as `<style><class name="flat"/></style>` and the second
+     * as a `<property>` whose text is NEWLINE-joined. A joined string in `props` would have to
+     * pick one of those two joins and could then not be held against the other golden, which is
+     * why the list is the field and not a string (ADR 0068 § 2).
+     *
+     * `styleClasses` and not `cssClasses`: ADR 0049 § 1 measured that name fatal on
+     * NativeScript, where `ViewBase` owns it as a live `Set` its CSS engine reads. So the field
+     * carries the name the three surfaces CAN share, and each driver maps it to its own door —
+     * the same arrangement `slot` already has, where GTK writes `<child type="start">` and the
+     * web writes `slot="start"`.
+     */
+    styleClasses?: readonly string[];
+    /**
+     * Blueprint's value-carrying extension blocks, one key per kind (ADR 0072).
+     *
+     * `strings` is `Gtk.StringList { strings [ … ] }`: GtkBuilder writes it as `<items>` and
+     * fills it through `gtk_string_list_append`. `responses` is `Adw.AlertDialog { responses
+     * [ … ] }`: filled through `adw_alert_dialog_add_response`, with `destructive`/`suggested`
+     * as the `appearance` and `disabled` as `enabled: false`. A string keeps its `_()` marking
+     * beside it, in the same `{ context? }` that `translatable` holds for a prop.
+     *
+     * A CLOSED SET. Every other extension (`menu`, `layout`, `marks`, `items`, …) stays a named
+     * loss of the projection, so no renderer meets a kind it has no door for.
+     */
+    extensions?: Readonly<{
+        strings?: readonly {
+            readonly value: string;
+            readonly translatable?: {
+                readonly context?: string;
+            };
+        }[];
+        responses?: readonly {
+            readonly id: string;
+            readonly label: string;
+            readonly translatable?: {
+                readonly context?: string;
+            };
+            readonly appearance?: 'suggested' | 'destructive';
+            readonly enabled?: boolean;
+        }[];
+    }>;
     children?: readonly SharedTreeNode[];
 }
 /**
@@ -64,12 +179,47 @@ export declare function authoredNodes(root: SharedTreeNode): {
 /**
  * The authored classes a realised tree must carry, in authored order.
  *
- * `tagOf` is the renderer's own spelling of a GIR class name — `hostTagOf` on the web, the
- * GIR name itself in GTK. Both drivers filter their real tree down to this list and compare
- * against it, so it lives here rather than in each of them: a driver deriving it privately
- * is a second walk, free to disagree with the one {@link subjectIndexOf} addresses into.
+ * `tagOf` is the renderer's own spelling of a GIR class name — `hostTagOf` from the sibling
+ * `@gjsify/adwaita-core/tags` on the web, the GIR name itself in GTK. Both drivers filter
+ * their real tree down to this list and compare against it, so it lives here rather than in
+ * each of them: a driver deriving it privately is a second walk, free to disagree with the
+ * one {@link subjectIndexOf} addresses into.
  */
 export declare function authoredTags(root: SharedTreeNode, tagOf?: (gtype: string) => string): string[];
+/** One authored placement: the node's address, and the slot it named. */
+export interface SharedTreePlacement {
+    /** The pre-order address {@link subjectIndexOf} reads, so a failure names a node. */
+    path: string;
+    /** The slot the tree authored, spelled the way every renderer admitting the block spells it. */
+    slot: string;
+}
+/**
+ * Every node of `root` that names a placement.
+ *
+ * WHAT THIS IS FOR. A driver comparing only the authored classes IN ORDER cannot see a
+ * slot at all: a child placed in the wrong slot of the right parent keeps every authored
+ * node in every authored position. ADR 0051 § Amendment 3 measured exactly that on the
+ * NativeScript port — two deliberate mis-placements, both GREEN — and the corpus authored
+ * no slot to catch it with until one did. This is the renderer-free half of the answer;
+ * what a driver DOES with it is its own, because "the child ended up in slot X" has no
+ * shared observable.
+ */
+export declare function sharedTreePlacements(root: SharedTreeNode): SharedTreePlacement[];
+/**
+ * The same tree with every placement dropped — what a renderer that never read `slot`
+ * builds.
+ *
+ * THE CONTROL, and it is why a placement assertion can be made without a per-widget table
+ * of where each slot lands. A driver builds the tree twice and asserts the two REALISED
+ * trees differ: with the slots honoured a suffix sits in its row's header, without them it
+ * sits wherever that parent's default placement puts it. Every builder here read only
+ * `tag`, `props` and `children`, so the two builds were byte-identical — which is the
+ * regression this control turns red.
+ *
+ * Fresh nodes all the way down, never the authored ones: a driver handed the corpus's own
+ * objects could edit what the next block builds.
+ */
+export declare function withoutPlacements(root: SharedTreeNode): SharedTreeNode;
 /**
  * Where the node an expectation is about sits in that filtered walk.
  *

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

@@ -0,0 +1,46 @@
+/** One `hostTagOf` expectation — a class that resolves, or a name it must refuse. */
+export interface HostTagVector {
+    /** A GIR class name, or a string that is deliberately not one. */
+    gtype: string;
+    /** The kebab tag `hostTagOf` must return. Absent for a row that must throw instead. */
+    expected?: string;
+    /** The exact `Error#message` `hostTagOf` must throw. Absent for a row that must resolve. */
+    error?: string;
+    rule: string;
+}
+/**
+ * `hostTagOf` — GIR class name to kebab tag, and the refusal boundary.
+ *
+ * `AdwPreferencesGroup`/`AdwSwitchRow`/`GtkBox` pin the floor: one dash per word boundary,
+ * no acronym involved. `GtkGLArea`/`GtkATContext`/`GtkIMMulticontext` pin THE rule the floor
+ * cannot show — a run of two or more capitals closes at its LAST one, so `GL` stays one word
+ * and `Area` opens a new one, rather than `g-l-area`. `GtkPad2Btn` pins what a digit does:
+ * it is not an uppercase letter, so it ends a lower run exactly like a lowercase letter
+ * would, and the capital after it still opens a new word.
+ */
+export declare const HOST_TAG_VECTORS: ReadonlyArray<HostTagVector>;
+/** One `attributeOf` expectation. */
+export interface AttributeOfVector {
+    /** The authored property name, as an `AdwXyz`/`GtkXyz` prop is spelled in a `SharedTreeNode`. */
+    prop: string;
+    /** The attribute `attributeOf` must return. */
+    expected: string;
+    rule: string;
+}
+/**
+ * `attributeOf` — camelCase property name to kebab DOM attribute.
+ *
+ * Every capital gets its own dash, with no acronym awareness — see the header for why that
+ * boundary is out of scope for this table.
+ */
+export declare const ATTRIBUTE_OF_VECTORS: ReadonlyArray<AttributeOfVector>;
+/** One `propertyOf` expectation. */
+export interface PropertyOfVector {
+    /** A property name as a projected `.blp` spells it, or as a hand-authored tree does. */
+    name: string;
+    /** The member `propertyOf` must return. */
+    expected: string;
+    rule: string;
+}
+/** `propertyOf` — a GIR property name to the camel-case member a NativeScript widget declares. */
+export declare const PROPERTY_OF_VECTORS: ReadonlyArray<PropertyOfVector>;

package/lib/types/conformance/value-lists.d.ts

@@ -0,0 +1,19 @@
+import type { AdwResponseAppearance } from '../dialog.js';
+/** One registered response, as the built dialog reports it. */
+export interface ValueListResponse {
+    readonly id: string;
+    readonly label: string;
+    readonly appearance: AdwResponseAppearance;
+    readonly enabled: boolean;
+}
+/** One Blueprint source and what the widget it builds hands back. */
+export interface ValueListVector {
+    readonly rule: string;
+    /** The object, written after `using Gtk 4.0; using Adw 1;`. */
+    readonly blueprint: string;
+    /** The labels of the root's list model, in order — a combo row or a drop-down. */
+    readonly strings?: readonly string[];
+    /** The root dialog's responses, in the order they were added. */
+    readonly responses?: readonly ValueListResponse[];
+}
+export declare const VALUE_LIST_VECTORS: readonly ValueListVector[];