@gjsify/adwaita-web 0.51.1 → 0.52.0

package/lib/types/blueprint-layout.spec.d.ts

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

package/lib/types/blueprint-markup.spec.d.ts

@@ -0,0 +1,4 @@
+import type { SharedTreeNode } from '@gjsify/adwaita-core/conformance';
+/** Every one-Blueprint `.blp` of the gallery, by its path under `website/src/blueprints/`. */
+export declare const GALLERY_BLUEPRINTS: Readonly<Record<string, SharedTreeNode>>;
+export declare const AdwBlueprintMarkupTest: () => Promise<void>;

package/lib/types/blueprint-tree.spec.d.ts

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

package/lib/types/elements/adw-bottom-sheet.d.ts

@@ -1,16 +1,23 @@
-import type { BottomSheetCloseOutcome, BottomSheetCloseSource } from '@gjsify/adwaita-core';
+import type { BottomSheetCloseOutcome, BottomSheetCloseSource, BottomSheetOpenOutcome, BottomSheetOpenSource } from '@gjsify/adwaita-core';
 /** The persistent content. Child of <adw-bottom-sheet>; consumed at connect time. */
 export declare class AdwBottomSheetContent extends HTMLElement {
 }
 /** The slide-up sheet. Child of <adw-bottom-sheet>; consumed at connect time. */
 export declare class AdwBottomSheetSheet extends HTMLElement {
 }
+/** The collapsed bar the sheet morphs out of. Child of <adw-bottom-sheet>. */
+export declare class AdwBottomSheetBottomBar extends HTMLElement {
+}
 export declare class AdwBottomSheet extends HTMLElement {
     private _initialized;
     private _contentEl;
     private _dimmingEl;
     private _sheetEl;
+    private _sheetBodyEl;
+    private _bottomBarEl;
     private _dragHandleEl;
+    /** A bar set through {@link setBottomBar} before the element upgraded. */
+    private _pendingBottomBar;
     /** The shared open/can-close model — the single source of truth for both. */
     private readonly _state;
     /** Set while the element writes `open` back, so the write does not re-enter. */
@@ -18,13 +25,36 @@ export declare class AdwBottomSheet extends HTMLElement {
     static get observedAttributes(): string[];
     get open(): boolean;
     set open(value: boolean);
+    /** Whether the content is dimmed and blocked while the sheet is open (`AdwBottomSheet:modal`). */
     get modal(): boolean;
     set modal(value: boolean);
     /** Whether the user can dismiss the sheet (dimming / Escape / sheet.close). */
     get canClose(): boolean;
     set canClose(value: boolean);
+    /** Whether the user can open the sheet from its bottom bar (`Adw.BottomSheet:can-open`). */
+    get canOpen(): boolean;
+    set canOpen(value: boolean);
+    /** Whether the bottom bar is shown while the sheet is closed. */
+    get revealBottomBar(): boolean;
+    set revealBottomBar(value: boolean);
     get showDragHandle(): boolean;
     set showDragHandle(value: boolean);
+    /** The bar's content, or `null` when the sheet has none — the read-back for {@link setBottomBar}. */
+    get bottomBar(): Node | null;
+    /**
+     * Give the sheet a bottom bar, or take it away — `adw_bottom_sheet_set_bottom_bar`.
+     *
+     * Presence is an INPUT to the open gate, not decoration: removing the bar removes every
+     * way a user has of opening this sheet, which is why the state hears about it rather
+     * than only the DOM.
+     */
+    setBottomBar(child: Node | null): void;
+    /**
+     * Route an open affordance through the shared gate. `'ignored'` is silent by design:
+     * libadwaita has no `open-attempt` counterpart to `close-attempt`, so a refused open
+     * emits nothing at all.
+     */
+    requestOpen(source: BottomSheetOpenSource): BottomSheetOpenOutcome;
     /**
      * Route a dismissal affordance through the shared gate and act on the verdict: close,
      * raise `close-attempt`, forward `sheet.close` to an ancestor, or do nothing. Called
@@ -44,16 +74,4 @@ export declare class AdwBottomSheet extends HTMLElement {
     /** Read a boolean attribute: absent → `fallback`, explicit `="false"` → off. */
     private _boolAttr;
     private _setBoolAttr;
-    /**
-     * Collect the nodes declared for one slot, in DOCUMENT order, marking every
-     * consumed child in `claimed`.
-     *
-     * The `<adw-bottom-sheet-sheet>` / `<adw-bottom-sheet-content>` wrappers are
-     * markup, not widgets — GtkBuilder's `<child type="sheet">` leaves nothing in
-     * the tree — so the wrapper itself is claimed
-     * too. It used to fall through to `unslotted` and be appended to the content
-     * layer, leaving an empty custom element behind after its children were
-     * pulled out.
-     */
-    private _collectSlot;
 }

package/lib/types/elements/adw-carousel.d.ts

@@ -183,6 +183,11 @@ declare abstract class AdwCarouselIndicator extends HTMLElement {
     connectedCallback(): void;
     disconnectedCallback(): void;
     attributeChangedCallback(name: string): void;
+    /**
+     * The carousel named by id. `carousel` is the GTK property's own name, and what a
+     * projected `.blp` writes for `carousel: carousel`; `for` is the markup spelling this
+     * element had first, kept as the fallback.
+     */
     private _resolveForAttr;
     private _attach;
     private _detach;

package/lib/types/elements/adw-header-bar.d.ts

@@ -12,6 +12,13 @@ export declare class AdwHeaderBar extends HTMLElement {
      * see the divergence at the top of this file.
      */
     private _titleEl;
+    /**
+     * The `<adw-navigation-page>` this bar sits in, and the observer that follows its
+     * title. `update_title` (adw-header-bar.c:488) asks that page FIRST, which is how a
+     * bare `Adw.HeaderBar {}` in a `.blp` page shows "Mailboxes" with no title of its own.
+     */
+    private _page;
+    private _pageObserver;
     static get observedAttributes(): string[];
     /** The start (left) section container — append buttons/widgets here. */
     get startSection(): HTMLDivElement | null;
@@ -21,6 +28,14 @@ export declare class AdwHeaderBar extends HTMLElement {
     /** The end (right) section container — append buttons/widgets here. */
     get endSection(): HTMLDivElement | null;
     connectedCallback(): void;
+    disconnectedCallback(): void;
+    /**
+     * Find the enclosing navigation page and re-render when its title moves, as GTK does:
+     * `root` looks the ancestor up (adw-header-bar.c:586) and a `notify::title` on it re-runs
+     * `update_title`. Looked up on every connect, since a bar moved into another page has a
+     * new ancestor, which is why C does it in `root` and drops it in `unroot`.
+     */
+    private _followPage;
     /**
      * `title` used to be read ONCE, in `connectedCallback`, so every later write
      * was a silent no-op — a header bar whose title tracked the open document

package/lib/types/elements/adw-inline-view-switcher.d.ts

@@ -3,6 +3,7 @@ import type { AdwInlineViewSwitcherDisplayMode, AdwViewSwitcherPage } from '@gjs
 /** A single page. Children of <adw-inline-view-switcher>; consumed at connect time. */
 export declare class AdwViewStackPage extends HTMLElement {
     static get observedAttributes(): string[];
+    connectedCallback(): void;
 }
 export declare class AdwInlineViewSwitcher extends HTMLElement {
     /**

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

@@ -3,6 +3,7 @@ export declare class AdwNavigationPage extends HTMLElement {
     /** Set while the owning view writes an attribute back, so the sync cannot recurse. */
     private _syncing;
     static get observedAttributes(): string[];
+    connectedCallback(): void;
     get title(): string;
     set title(value: string);
     get tag(): string | null;

package/lib/types/elements/adw-sidebar.d.ts

@@ -2,6 +2,16 @@ import { type AdwSidebarItemSpec, type AdwSidebarSectionSpec, type SidebarItemFi
 /** A single sidebar item. Child of <adw-sidebar-section>; consumed at connect time. */
 export declare class AdwSidebarItem extends HTMLElement {
     static get observedAttributes(): string[];
+    /**
+     * `AdwSidebarItem:enabled`, under the GIR name — the `disabled` attribute inverted. The
+     * property is what lets an authored `enabled: false` reach this item through the
+     * shared-tree builder, which writes a `false` through the element's own property.
+     */
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    /** `AdwSidebarItem:visible` — the `hidden` attribute inverted, for the same reason. */
+    get visible(): boolean;
+    set visible(value: boolean);
     attributeChangedCallback(name: string, _oldValue: string | null, newValue: string | null): void;
 }
 /** A titled group of items. Child of <adw-sidebar>; consumed at connect time. */

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

@@ -9,6 +9,7 @@ export type AdwTabViewPageSpec = AdwTabPageSpec<HTMLElement>;
  */
 export declare class AdwTabPage extends HTMLElement {
     static get observedAttributes(): string[];
+    connectedCallback(): void;
     attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
 }
 export declare class AdwTabView extends HTMLElement {

package/lib/types/elements/adw-toggle-group.d.ts

@@ -10,12 +10,23 @@ export declare class AdwToggleGroup extends HTMLElement {
     private _initialized;
     /** `aria-checked` under `radio`, `aria-selected` under `tab` — decided at connect. */
     private _stateAttr;
+    /** Each toggle's `name`, in order — what `active-name` resolves against. */
+    private _names;
     static get observedAttributes(): string[];
     /** Zero-based index of the active toggle. */
     get active(): number;
     set active(value: number);
+    /** `Adw.ToggleGroup:active-name` — the `name` of the active toggle, or `null`. */
+    get activeName(): string | null;
+    set activeName(value: string | null);
     connectedCallback(): void;
     attributeChangedCallback(name: string): void;
+    /**
+     * `adw_toggle_group_set_active_name`: the toggle carrying the name becomes active, and
+     * a name nothing carries leaves the selection where it was — the C's `g_critical` and
+     * return (:2001). Which toggle a name means is the core's answer, not this element's.
+     */
+    private _applyActiveName;
     private _readActiveAttr;
     private _selectIndex;
     private _render;

package/lib/types/elements/gtk-action-bar.d.ts

@@ -0,0 +1,19 @@
+export declare class GtkActionBar extends HTMLElement {
+    private _initialized;
+    private _startEl;
+    private _centerEl;
+    private _endEl;
+    static get observedAttributes(): string[];
+    /** `GtkActionBar:revealed` — whether the bar shows its contents. */
+    get revealed(): boolean;
+    set revealed(value: boolean);
+    /** The start box — what `pack_start` appends to. */
+    get startSection(): HTMLDivElement | null;
+    /** The centre — what `gtk_action_bar_set_center_widget` sets. */
+    get centerSection(): HTMLDivElement | null;
+    /** The end box — what `pack_end` prepends to. */
+    get endSection(): HTMLDivElement | null;
+    connectedCallback(): void;
+    attributeChangedCallback(): void;
+    private _renderRevealed;
+}

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

@@ -0,0 +1,17 @@
+import { type BoxOrientation } from '@gjsify/adwaita-core';
+export declare class GtkBox extends HTMLElement {
+    static get observedAttributes(): ("spacing" | "orientation" | "homogeneous")[];
+    /** `GtkOrientable:orientation` — `horizontal` (the default) or `vertical`. */
+    get orientation(): BoxOrientation;
+    set orientation(value: BoxOrientation);
+    /** `Gtk.Box:spacing` — the gap between children, in px. Defaults to 0. */
+    get spacing(): number;
+    set spacing(value: number);
+    /** `Gtk.Box:homogeneous` — whether every child gets the same size along the axis. */
+    get homogeneous(): boolean;
+    set homogeneous(value: boolean);
+    connectedCallback(): void;
+    attributeChangedCallback(name: string, old: string | null, value: string | null): void;
+    private _normalized;
+    private _sync;
+}

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

@@ -2,6 +2,8 @@ export declare class GtkButton extends HTMLElement {
     private _button;
     private _label;
     private _initialized;
+    /** `Gtk.Button:child`, or `null` while the icon and the label fill the button. */
+    private _child;
     static get observedAttributes(): string[];
     /** The inner native button (for focus/imperative access). */
     get button(): HTMLButtonElement;

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

@@ -0,0 +1,122 @@
+import { type LabelEllipsizeMode, type LabelJustification, type LabelWrapMode } from '@gjsify/adwaita-core';
+export declare class GtkLabel extends HTMLElement {
+    /**
+     * The rendered text's own box — present while {@link wrap} is set (so it can be pinned
+     * to its measured wrap width, see `_remeasure`) OR while {@link ellipsize} is not
+     * `none` (so `overflow`/`text-overflow` have a box of their own to clip, rather than
+     * the label's flex container, which also holds the `xalign` spacer pseudo-elements).
+     * `null` the rest of the time so a single-line, non-ellipsized label keeps the plain
+     * text node `childElementCount` asserts on (`gtk-label.spec.ts`'s XSS note: "the DOM
+     * gets one text node").
+     */
+    private _wrapSpan;
+    private _resizes;
+    static get observedAttributes(): ("label" | "use-markup" | "use-underline" | "justify" | "wrap" | "xalign" | "yalign" | "wrap-mode" | "ellipsize" | "lines" | "width-chars" | "max-width-chars" | "selectable")[];
+    /** `Gtk.Label:label` — the text as written, before markup and the mnemonic come out. */
+    get label(): string;
+    set label(value: string);
+    /** `Gtk.Label:use-markup` — whether {@link label} is Pango markup (shown as its text). */
+    get useMarkup(): boolean;
+    set useMarkup(value: boolean);
+    /** `Gtk.Label:use-underline` — whether an `_` marks a mnemonic (stripped, not bound). */
+    get useUnderline(): boolean;
+    set useUnderline(value: boolean);
+    /** `Gtk.Label:justify` — how the lines align with each other. Defaults to `left`. */
+    get justify(): LabelJustification;
+    set justify(value: LabelJustification);
+    /** `Gtk.Label:xalign` — where the text sits in the label's box, 0…1. Defaults to 0.5. */
+    get xalign(): number;
+    set xalign(value: number);
+    /**
+     * `Gtk.Label:yalign` — where the text sits vertically in the label's box, 0…1.
+     * Defaults to 0.5. Exact at 0, 0.5 and 1; a DECLARED divergence between them — see
+     * `_labels.scss`'s header for why `align-items` has no continuum the way `xalign`'s
+     * flex-grow ratio does.
+     */
+    get yalign(): number;
+    set yalign(value: number);
+    /** `Gtk.Label:wrap` — whether the text breaks into lines rather than overflowing. */
+    get wrap(): boolean;
+    set wrap(value: boolean);
+    /**
+     * `Gtk.Label:wrap-mode` — where a wrapping line may break. Defaults to `word`. Only
+     * affects the formatting while the layout can actually span more than one line —
+     * {@link wrap}, or {@link ellipsize} being active (`ellipsize`, not just `wrap`, is
+     * what gives GTK's own Pango layout a width to break within: `label.ts`'s header in
+     * `@gjsify/adwaita-core`).
+     */
+    get wrapMode(): LabelWrapMode;
+    set wrapMode(value: LabelWrapMode);
+    /**
+     * `Gtk.Label:ellipsize` — where the string is trimmed when it does not fit. Defaults
+     * to `none`. `start` and `middle` are HELD faithfully — read `ellipsize` back and it
+     * is exactly what was set — but DRAWN as an end-ellipsis: `labelEllipsizeOverflowValue`
+     * (`@gjsify/adwaita-core`) says why.
+     */
+    get ellipsize(): LabelEllipsizeMode;
+    set ellipsize(value: LabelEllipsizeMode);
+    /**
+     * `Gtk.Label:lines` — the line count an ellipsized label is held to. Defaults to -1
+     * ("unset"), which still caps at ONE line the moment {@link ellipsize} is active —
+     * Pango's own default, not "unlimited". Has no effect at all while ellipsize is
+     * `none`, `wrap` or not — `labelEffectiveLines` (`@gjsify/adwaita-core`) is that
+     * MEASURED guard, and its own doc comment carries the numbers.
+     */
+    get lines(): number;
+    set lines(value: number);
+    /**
+     * `Gtk.Label:width-chars` — the label's minimum width, in characters. Defaults to -1
+     * (calculated automatically, i.e. unset here).
+     */
+    get widthChars(): number;
+    set widthChars(value: number);
+    /**
+     * `Gtk.Label:max-width-chars` — the label's natural (maximum) width, in characters.
+     * Defaults to -1 (calculated automatically, i.e. unset here).
+     */
+    get maxWidthChars(): number;
+    set maxWidthChars(value: number);
+    /** `Gtk.Label:selectable` — whether the text can be selected. GTK's default is not. */
+    get selectable(): boolean;
+    set selectable(value: boolean);
+    /** `gtk_label_get_text` — the text as SHOWN, markup reduced and the marker removed. */
+    getText(): string;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private _remeasure;
+    attributeChangedCallback(name: string, old: string | null, value: string | null): void;
+    private _normalized;
+    private _render;
+    private _renderSingleLine;
+    /**
+     * A WRAPPED OR ELLIPSIZED label centres its BLOCK by `xalign` (`gtklabel.c`,
+     * `gtk_label_get_layout_location`), not just each line — `_labels.scss`'s two spacer
+     * pseudo-elements split the label's FREE space by `xalign`, and a flex item only has
+     * free space to give them once it FITS. `flex-basis: auto` sizes the plain text node to
+     * its max-content (single-line) width; once that overflows, `flex-shrink` collapses the
+     * zero-basis spacers to nothing and stretches the text item to the full container width
+     * instead — which is where the offset was lost (the defect this method fixes).
+     *
+     * NO PURE-CSS FIX EXISTS: `width: fit-content` clamps to that SAME full-container width
+     * the moment its content no longer fits one line — CSS shrink-to-fit is
+     * `min(max(min-content, available), max-content)`, and `available` IS the container
+     * here, not the narrower width GTK's Pango layout actually wrapped to. So this measures
+     * instead, in two passes: first let {@link _wrapSpan} wrap at the FULL container width
+     * (`width: ''`, the same collapse above, which is exactly the width GTK's own
+     * allocation wraps against), then pin the span to its widest resulting line via
+     * `Range.getClientRects()`, which gives the pseudo spacers real free space to split.
+     * Approximate on purpose, and cheap: one synchronous reflow per render. The pinned
+     * width goes stale whenever the available width or the font changes, and a page does
+     * both (a rotated phone, an opened sidebar, a web font arriving late), so
+     * {@link connectedCallback} re-measures on each resize and once the fonts have loaded.
+     *
+     * AN ELLIPSIZED SPAN NEEDS THIS TOO, MEASURED THE HARD WAY: an earlier version of this
+     * method skipped it for `ellipsize` without `wrap`, reasoning that `white-space: nowrap`
+     * text has one width whichever way it is measured. That reasoning stopped applying the
+     * moment `ellipsize` alone started wrapping onto MULTIPLE lines to match GTK
+     * (`label.ts`'s header) — `white-space: normal` multi-word text has a real
+     * min-content/max-content gap, the exact shrink-to-fit collapse the wrapped case above
+     * was already written for. One code path now, for both.
+     */
+    private _renderSpan;
+}

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

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

package/lib/types/gtk-box.spec.d.ts

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

package/lib/types/gtk-label.spec.d.ts

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

package/lib/types/gtk-value-doors.spec.d.ts

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

package/lib/types/index.d.ts

@@ -3,9 +3,12 @@ export { ACCENT_BG_PROPERTY, ACCENT_PROPERTY, applyAdwaitaAccent, clearAdwaitaAc
 export type { ApplyAccentOptions } from './accent.js';
 export { AdwScrollShading } from './scroll-shading.js';
 export type { AdwUndershootEdges } from './scroll-shading.js';
+export { buildSharedTree, mountSharedTree } from './shared-tree-builder.js';
+export type { MountedSharedTree } from './shared-tree-builder.js';
 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 { 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';
@@ -15,7 +18,7 @@ export { AdwTabPage } from './elements/adw-tab-view.js';
 export { AdwViewSwitcherPage } from './elements/adw-view-switcher.js';
 export { AdwViewStackPage } from './elements/adw-inline-view-switcher.js';
 export { AdwSidebarItem, AdwSidebarSection } from './elements/adw-sidebar.js';
-export { AdwBottomSheetContent, AdwBottomSheetSheet } from './elements/adw-bottom-sheet.js';
+export { AdwBottomSheetBottomBar, AdwBottomSheetContent, AdwBottomSheetSheet } from './elements/adw-bottom-sheet.js';
 export { AdwAlertResponse } from './elements/adw-alert-dialog.js';
 export type { GtkPopoverAlign, GtkPopoverPosition, GtkPopoverRole } from './elements/gtk-popover.js';
 export type { AdwViewStackPageInfo } from './elements/adw-view-stack.js';

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

@@ -0,0 +1 @@
+export { GioMenu as Menu, GioMenuItem as MenuItem } from '@gjsify/adwaita-core';

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

@@ -1,9 +1,14 @@
+export { GtkAdjustment as Adjustment } from '@gjsify/adwaita-core';
+export { GtkActionBar as ActionBar } from '../elements/gtk-action-bar.js';
+export { GtkBox as Box } from '../elements/gtk-box.js';
 export { GtkButton as Button } from '../elements/gtk-button.js';
 export { GtkCheckButton as CheckButton } from '../elements/checks.js';
 export { GtkDropDown as DropDown } from '../elements/gtk-drop-down.js';
 export { GtkEntry as Entry } from '../elements/gtk-entry.js';
 export { GtkImage as Image } from '../elements/gtk-image.js';
+export { GtkLabel as Label } from '../elements/gtk-label.js';
 export { GtkMenuButton as MenuButton } from '../elements/gtk-menu-button.js';
 export { GtkPopover as Popover } from '../elements/gtk-popover.js';
 export { GtkProgressBar as ProgressBar } from '../elements/gtk-progress-bar.js';
+export { GtkStringList as StringList } from '@gjsify/adwaita-core';
 export { GtkSwitch as Switch } from '../elements/gtk-switch.js';

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

@@ -0,0 +1,64 @@
+import type { SharedTreeNode } from '@gjsify/adwaita-core/conformance';
+/** One authored placement, kept so {@link mountSharedTree} can hold the renderer to it. */
+interface PlacedChild {
+    parent: HTMLElement;
+    child: HTMLElement;
+    slot: string;
+}
+/** One node that authored `extensions`, kept so {@link mountSharedTree} can hold it too. */
+interface ExtendedNode {
+    el: HTMLElement;
+    node: SharedTreeNode;
+}
+/** What one build collects for the checks that can only run once the tree is connected. */
+interface BuildRecord {
+    placed: PlacedChild[];
+    extended: ExtendedNode[];
+}
+/**
+ * A `SharedTreeNode`, realised as a DETACHED element tree: a tag, its authored properties as
+ * attributes, its style classes as classes, its extensions (ADR 0072) as the markup the element
+ * reads, its placement as `slot=`, its children, in that order — recursive and total,
+ * no tag list, no per-block case. A boolean authored property is the ATTRIBUTE'S PRESENCE
+ * (`toggleAttribute`), which is what every element in the corpus reads
+ * (`hasAttribute('revealed')`, `hasAttribute('expanded')`); spelling `"true"` would set a
+ * present attribute for `false` as well.
+ *
+ * EXCEPT AN AUTHORED `false` ON A PROPERTY THE ELEMENT DECLARES. Absence cannot say `false`
+ * where the GTK default is TRUE — `AdwNavigationPage:can-pop`, `GtkActionBar:revealed` —
+ * because those elements read an absent attribute as that default, so `can-pop: false`
+ * reached the page as `can-pop` unset and the page stayed poppable. The element's own
+ * property setter knows its attribute convention, so an authored `false` is written
+ * through it when the element (already upgraded: `createElement` of a defined tag
+ * constructs it) declares one; everything else keeps the presence rule. "Declares" means a
+ * member it can WRITE ({@link isWritable}): a getter-only accessor of the same name — the
+ * split button's and the menu button's read-only `active` — would throw a bare `TypeError`
+ * out of the assignment, so such a property falls back to the presence rule too.
+ *
+ * THE SLOT IS WRITTEN AS THE ATTRIBUTE THIS RENDERER ALREADY ROUTES ON, not translated:
+ * `src/slotted-children.ts` reads `slot=` off every light-DOM child and keeps the routing
+ * live. This builder read `tag`, `props` and `children` and dropped `slot` silently until a
+ * real `.blp` authored one — the `[top]` header bar landed in `adw-toolbar-view-content` and
+ * the window title was then discarded by `<adw-header-bar>`'s own build, at exit 0.
+ *
+ * NOT YET LIVE — see the file header. Nothing here has run `connectedCallback` until
+ * something connects it: {@link mountSharedTree} for the common case, or a caller's own
+ * container. A DETACHED build therefore cannot check a slot either: an element that has not
+ * upgraded has declared no slots yet, so the refusal below belongs to the mount.
+ */
+export declare function buildSharedTree(node: SharedTreeNode, record?: BuildRecord): HTMLElement;
+/** A tree {@link mountSharedTree} built and connected. */
+export interface MountedSharedTree {
+    /** The authored root — connected, so every custom element under it has upgraded and run. */
+    root: HTMLElement;
+    /** Disconnects and discards the mount point. */
+    unmount: () => void;
+}
+/**
+ * {@link buildSharedTree}, attached under a fresh host `<div>` in `document.body` so the tree
+ * — and every custom element in it — is REAL rather than merely constructed. This is the
+ * instantiation half a caller reading the corpus's elements normally wants; a bare
+ * `buildSharedTree` is for a caller that already has somewhere of its own to attach it.
+ */
+export declare function mountSharedTree(node: SharedTreeNode): MountedSharedTree;
+export {};

package/lib/types/source-view/asm6502.d.ts

@@ -1,25 +1,6 @@
-import { type StreamParser, type StringStream } from '@codemirror/language';
+import { type StreamParser } from '@codemirror/language';
 import { type Extension } from '@codemirror/state';
 import { type Tag } from '@lezer/highlight';
-/** The 56 official NMOS 6502 mnemonics (uppercased for case-insensitive match). */
-export declare const OPCODES: ReadonlySet<string>;
-/** The registers that appear as bare operands (`ASL A`, `LDA $00,X`). */
-export declare const REGISTERS: ReadonlySet<string>;
-/** Assembler pseudo-ops. `define`/`dcb` are the easy6502 dialect; the rest are
- *  common cross-assembler directives (with the leading dot handled separately). */
-export declare const DIRECTIVE_WORDS: ReadonlySet<string>;
-/**
- * Classify an identifier-shaped token. Pure + side-effect-free so it is unit
- * testable without a CodeMirror stream. `atLineStart` decides whether an
- * unknown word is a label DEFINITION (column 0) or a symbol REFERENCE.
- */
-export declare function classifyWord(word: string, atLineStart: boolean): string;
-/**
- * Tokenize one token from the stream. Exported for unit tests (feed it a
- * `StringStream`). Returns a token-class name (see file header) or `null` for
- * whitespace/unclassified punctuation.
- */
-export declare function token6502(stream: StringStream): string | null;
 /** Maps this mode's token-class names to @lezer/highlight tags. */
 export declare const asm6502TokenTable: Record<string, Tag>;
 /** The StreamParser powering the 6502 mode. */

package/lib/types/source-view/index.d.ts

@@ -1,4 +1,5 @@
 export { AdwSourceView } from './adw-source-view.js';
-export { asm6502, asm6502Parser, asm6502TokenTable, classifyWord, token6502, OPCODES, REGISTERS, DIRECTIVE_WORDS, } from './asm6502.js';
+export { asm6502, asm6502Parser, asm6502TokenTable } from './asm6502.js';
 export { adwaitaEditorTheme, adwaitaHighlightStyle, ensureSourceViewStyleInjected, SOURCE_VIEW_CSS, SOURCE_VIEW_STYLE_ID, } from './theme.js';
-export { formatHexAddress, formatLineNumber, stripWhitespace, HEX_ADDRESS_STRIDE } from './hex.js';
+export { ADW_SOURCE_6502_DIRECTIVES as DIRECTIVE_WORDS, ADW_SOURCE_6502_OPCODES as OPCODES, ADW_SOURCE_6502_REGISTERS as REGISTERS, ADW_SOURCE_HEX_STRIDE as HEX_ADDRESS_STRIDE, classifyAsm6502Word as classifyWord, formatHexAddress, formatLineNumber, stripSourceWhitespace as stripWhitespace, tokenizeAsm6502 as token6502, } from '@gjsify/adwaita-core';
+export type { AdwSourceTokenClass, AdwSourceTokenStream } from '@gjsify/adwaita-core';

package/lib/types/source-view/theme.d.ts

@@ -6,7 +6,7 @@ export declare const adwaitaHighlightStyle: HighlightStyle;
 /** Element id of the injected stylesheet (idempotency guard). */
 export declare const SOURCE_VIEW_STYLE_ID = "adw-source-view-style";
 /** The chrome stylesheet: container, copy button, LTR pin, syntax palette. */
-export declare const SOURCE_VIEW_CSS = "\n.adw-source-view {\n    --adw-src-comment: #5e5c64;\n    --adw-src-keyword: #1c71d8;\n    --adw-src-number: #c64600;\n    --adw-src-string: #26a269;\n    --adw-src-label: #813d9c;\n    --adw-src-register: #007e8a;\n    --adw-src-directive: #a51d2d;\n    --adw-src-operator: rgba(0, 0, 6, 0.55);\n    --adw-src-selection: color-mix(in srgb, var(--accent-bg-color, #3584e4) 26%, transparent);\n    --adw-src-gutter-bg: var(--view-bg-color, #ffffff);\n    --adw-src-gutter-fg: rgba(0, 0, 6, 0.35);\n    --adw-src-active-line: color-mix(in srgb, var(--view-fg-color, #00000a) 4%, transparent);\n\n    /* Source code is inherently LTR \u2014 pin the whole widget so the gutter,\n       scrollbar and copy button never mirror under an RTL page. */\n    direction: ltr;\n    position: relative;\n    display: block;\n    box-sizing: border-box;\n    overflow: hidden;\n    border-radius: var(--card-radius, 12px);\n    background-color: var(--view-bg-color, #ffffff);\n    color: var(--view-fg-color, rgba(0, 0, 6, 0.8));\n}\n\n.adw-source-view .cm-editor {\n    border-radius: inherit;\n    max-height: 100%;\n}\n\n.adw-source-view.adw-source-view--fill,\n.adw-source-view.adw-source-view--fill .cm-editor {\n    height: 100%;\n}\n\n.adw-source-view .cm-editor.cm-focused {\n    outline: none;\n}\n\n.adw-source-view__copy {\n    position: absolute;\n    top: 6px;\n    right: 6px;\n    z-index: 2;\n    display: inline-flex;\n    align-items: center;\n    justify-content: center;\n    width: 30px;\n    height: 30px;\n    padding: 0;\n    border: none;\n    border-radius: var(--button-radius, 9px);\n    background-color: color-mix(in srgb, var(--view-bg-color, #ffffff) 82%, transparent);\n    color: var(--view-fg-color, rgba(0, 0, 6, 0.75));\n    opacity: 0.72;\n    cursor: pointer;\n    transition: opacity 0.15s ease, background-color 0.15s ease;\n    -webkit-backdrop-filter: blur(6px);\n    backdrop-filter: blur(6px);\n}\n\n.adw-source-view__copy:hover {\n    opacity: 1;\n    background-color: var(--button-hover-color, rgba(0, 0, 6, 0.13));\n}\n\n.adw-source-view__copy:active {\n    background-color: var(--button-active-color, rgba(0, 0, 6, 0.19));\n}\n\n.adw-source-view__copy:focus-visible {\n    opacity: 1;\n    outline: 2px solid var(--accent-color, #1c71d8);\n    outline-offset: 1px;\n}\n\n.adw-source-view__copy[hidden] {\n    display: none;\n}\n\n.adw-source-view__copy svg {\n    width: 16px;\n    height: 16px;\n    display: block;\n}\n\n.adw-source-view__copy .adw-icon {\n    width: 16px;\n    height: 16px;\n    background-color: currentColor;\n    -webkit-mask-repeat: no-repeat;\n    mask-repeat: no-repeat;\n    -webkit-mask-position: center;\n    mask-position: center;\n}\n\n@media (prefers-color-scheme: dark) {\n    :root:not(.theme-light) .adw-source-view {\n    --adw-src-comment: #9a9996;\n    --adw-src-keyword: #78aeed;\n    --adw-src-number: #ffa348;\n    --adw-src-string: #8ff0a4;\n    --adw-src-label: #dc8add;\n    --adw-src-register: #33d1c9;\n    --adw-src-directive: #f66151;\n    --adw-src-operator: rgba(255, 255, 255, 0.55);\n    --adw-src-gutter-fg: rgba(255, 255, 255, 0.35);\n    --adw-src-active-line: color-mix(in srgb, #ffffff 6%, transparent);\n    }\n}\n\n:root.theme-dark .adw-source-view {\n    --adw-src-comment: #9a9996;\n    --adw-src-keyword: #78aeed;\n    --adw-src-number: #ffa348;\n    --adw-src-string: #8ff0a4;\n    --adw-src-label: #dc8add;\n    --adw-src-register: #33d1c9;\n    --adw-src-directive: #f66151;\n    --adw-src-operator: rgba(255, 255, 255, 0.55);\n    --adw-src-gutter-fg: rgba(255, 255, 255, 0.35);\n    --adw-src-active-line: color-mix(in srgb, #ffffff 6%, transparent);\n}\n";
+export declare const SOURCE_VIEW_CSS: string;
 /**
  * Inject the chrome stylesheet once (browser-only, idempotent). Matches the
  * self-injection pattern of `@gjsify/adwaita-web`'s main entry, so importing

package/lib/types/string-list-slot.d.ts

@@ -0,0 +1,4 @@
+import type { AdwComboOption } from '@gjsify/adwaita-core';
+import type { AdwSlotConsume } from './slotted-children.js';
+/** The `model` slot, handing the authored list to `adopt`. */
+export declare function stringListSlot(adopt: (model: AdwComboOption[]) => void): AdwSlotConsume;