@gjsify/react-native 0.44.0 → 0.46.0

package/lib/types/primitives/errors.d.ts

@@ -1,3 +1,12 @@
+/**
+ * The sentence, without throwing it.
+ *
+ * `@gjsify/react-native/prop-table` has to hand a consumer the message a render WOULD
+ * have thrown, and ADR 0039 § 1 says it is the same string rather than a paraphrase.
+ * Two template literals that happen to agree are not that: the format is here once and
+ * both the throw and the static answer are built from it.
+ */
+export declare const primitiveErrorMessage: (primitive: string, subject: string, detail: string) => string;
 /** A primitive, prop or combination this layer cannot answer for, and why. */
 export declare class PrimitiveError extends Error {
     readonly name = "PrimitiveError";

package/lib/types/primitives/handles.d.ts

@@ -0,0 +1,56 @@
+import type { HandleKind } from './table.js';
+/**
+ * The imperative handle a `<TextInput ref>` receives.
+ *
+ * React Native's own member list, with every one of them answered — five over GTK
+ * and four refused by name. `widget` is the one addition, and it is not decoration:
+ * the ref used to BE the widget, so a port that already reached for `Gtk.Entry` API
+ * through it keeps working by spelling `ref.current.widget` — and it is also the way
+ * out of every refusal below.
+ */
+export interface TextInputHandle {
+    /** `Gtk.Widget.grab_focus()`. */
+    focus(): void;
+    /**
+     * Give up the focus — `Gtk.Root.set_focus(null)`, and ONLY when this widget holds it.
+     *
+     * The guard is the whole of the correctness here: `set_focus(null)` unsets the
+     * root's focus widget whoever it is, so an unguarded `blur()` on an unfocused
+     * input would take the focus away from whatever really had it.
+     */
+    blur(): void;
+    /** Remove all text. `Gtk.Editable.set_text('')`, or the buffer's own for a multiline input. */
+    clear(): void;
+    /**
+     * Is this the widget its root delivers keys to?
+     *
+     * `Gtk.Widget.is_focus()` and NOT `has-focus`: the latter is the GLOBAL input
+     * focus and is false whenever the window is not the compositor's active one
+     * (MEASURED on gtk 4.22.4 — a mapped, presented window that the compositor never
+     * activated reports `has_focus` false for the widget `grab_focus()` just
+     * returned true for). React Native's `isFocused()` is the per-application
+     * question, which is `is_focus()`.
+     */
+    isFocused(): boolean;
+    /** `Gtk.Editable.select_region(start, end)`, or `Gtk.TextBuffer.select_range` for a multiline input. */
+    setSelection(start: number, end: number): void;
+    /** The `Gtk.Entry` or `Gtk.TextView` itself — everything this handle does not answer. */
+    readonly widget: unknown;
+    /** Refused by name. GTK measures on allocation; see the message. */
+    measure(callback: unknown): never;
+    /** Refused by name — see `measure`. */
+    measureInWindow(callback: unknown): never;
+    /** Refused by name — see `measure`. */
+    measureLayout(relativeTo: unknown, onSuccess: unknown, onFail?: unknown): never;
+    /** Refused by name: the widget is right here, and every GTK property is settable on it. */
+    setNativeProps(props: object): never;
+}
+/**
+ * The handle a plan asks for, or the widget itself.
+ *
+ * `null` for `kind` is the ordinary case and is not an omission: React Native gives
+ * an imperative handle only to the components that document one, and every other
+ * primitive here hands a `ref` the `Gtk.Widget` — which is what it did before this
+ * file existed and what a port that reaches for GTK API relies on.
+ */
+export declare function createHandle(kind: HandleKind | null, widget: unknown, tag: string): unknown;

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

@@ -1,11 +1,17 @@
+export { answerFor, isAccepted, propNamesOf, unknownPrimitiveDetail, unknownPropDetail } from './answers.js';
+export type { PropAnswer, PropStatus } from './answers.js';
 export { splitVariants } from './classes.js';
+export { createHandle } from './handles.js';
+export type { TextInputHandle } from './handles.js';
+export { DEFAULT_ROWS, NORMALISED_DEFAULTS, defaultRowFor } from './defaults.js';
+export type { DefaultRow, DefaultVerdict } from './defaults.js';
 export type { ClassGroups, ClassNameInput } from './classes.js';
 export { PrimitiveError } from './errors.js';
 export { resolveIntent } from './intents.js';
 export type { ChildContext, ChildFacts, IntentInput, IntentResolution, Orientation, WidgetFacts } from './intents.js';
 export { declaresAbsolute, resolvePrimitive } from './resolve.js';
-export type { PrimitiveContext, PrimitivePlan, PrimitiveProps, ResolvedEvent, ResolvedFile, ResolvedGesture, WidgetNode, } from './resolve.js';
+export type { PrimitiveContext, PrimitivePlan, PrimitiveProps, ResolvedAnnouncement, ResolvedEvent, ResolvedFile, ResolvedGesture, WidgetNode, } from './resolve.js';
 export { flattenStyle, mintClass, normalise, variantDeclarations } from './style.js';
 export type { ClassNameSink, StyleAuthored, StyleInput, StyleObject } from './style.js';
 export { FRAMEWORK_PROPS, PRIMITIVE_NAMES, PRIMITIVES } from './table.js';
-export type { Coercion, ContentSpec, EventRoute, FileRoute, GestureRoute, IgnoredRoute, NodeKind, PrimitiveSpec, PropRoute, PropertyRoute, RefusedRoute, StylePropertyRoute, } from './table.js';
+export type { AnnounceRoute, Coercion, ContentSpec, EventRoute, FileRoute, GestureRoute, HandleKind, IgnoredRoute, NodeKind, PrimitiveSpec, PropRoute, PropertyRoute, RefusedRoute, StylePropertyRoute, } from './table.js';

package/lib/types/primitives/intents.d.ts

@@ -32,12 +32,33 @@ export interface ChildFacts {
     /** Whether any child is a text run, which competes with a prop for the text sink. */
     readonly text: boolean;
 }
+/**
+ * The widget an element becomes when its children WRAP, and what that class needs.
+ *
+ * Data rather than code because it is a fact about GTK's class hierarchy, the same
+ * way `overlayOnAbsoluteChild` is: a `Gtk.Box` has one line and a `Gtk.FlowBox` has
+ * as many as it needs, and neither is reachable from the other by setting a
+ * property. `null` is a primitive whose widget has no wrapping counterpart at all.
+ */
+export interface WrapsInto {
+    /** GType name of the wrapping class. */
+    readonly tag: string;
+    /**
+     * Properties the swapped-in class needs before a single utility is read.
+     *
+     * Not cosmetic: `Gtk.FlowBox` ships two defaults that make it something other
+     * than a wrapping box (measured, gtk 4.22.4), and both are corrected here.
+     */
+    readonly widgetProps: Readonly<Record<string, unknown>>;
+}
 /** What the element's own widget can take. Declared per primitive, measured in the spec. */
 export interface WidgetFacts {
     /** Installs `orientation` and `spacing` — a `Gtk.Box`. */
     readonly box: boolean;
     /** Installs `xalign` and `justify` — a `Gtk.Label`. */
     readonly alignsText: boolean;
+    /** What this element becomes when its children wrap, or `null` when nothing can. */
+    readonly wrapsInto: WrapsInto | null;
 }
 export interface IntentInput {
     readonly primitive: string;
@@ -50,6 +71,13 @@ export interface IntentInput {
     /** Widget properties already emitted by L1, read only to catch a clash. */
     readonly emittedProps: Readonly<Record<string, unknown>>;
 }
+/** The widget swap a wrap asks for, for the caller that owns the plan's tags. */
+export interface WrapResolution {
+    /** GType name the node the children go into takes instead of its own. */
+    readonly tag: string;
+    /** Properties that belong to the swapped-in class, the spacings included. */
+    readonly props: Readonly<Record<string, unknown>>;
+}
 export interface IntentResolution {
     /** Widget properties this resolution adds, GTK spelling. */
     readonly props: Readonly<Record<string, unknown>>;
@@ -59,6 +87,14 @@ export interface IntentResolution {
     readonly childContext: ChildContext;
     /** The `slot` this element declares to its parent, or null. */
     readonly slot: string | null;
+    /**
+     * The tag the node holding the children takes instead of its own, or null.
+     *
+     * Returned rather than applied because this function answers for PROPERTIES and
+     * the plan's tags belong to `resolve.ts` — the same division that keeps
+     * `overlayOnAbsoluteChild` out of here.
+     */
+    readonly wrapping: WrapResolution | null;
     /** What is still unresolved, for a caller that knows more. */
     readonly remaining: LayoutIntent;
 }

package/lib/types/primitives/resolve.d.ts

@@ -2,7 +2,7 @@ import type { LayoutIntent, StyleTokens } from '@gjsify/gtk-host/style';
 import type { ClassNameInput } from './classes.js';
 import { type ChildContext, type ChildFacts, type Orientation, type WidgetFacts } from './intents.js';
 import { type ClassNameSink, type StyleInput } from './style.js';
-import { type NodeKind } from './table.js';
+import { type HandleKind, type NodeKind } from './table.js';
 /** Everything L2 needs that is not the primitive and not its props. */
 export interface PrimitiveContext {
     /** The project's own token scales. ADR 0032 § 3: the families are declared, the values are the project's. */
@@ -57,6 +57,26 @@ export interface ResolvedGesture {
     /** The `Gtk.GestureClick` signal — `released` is a completed press. */
     readonly signal: string;
 }
+/**
+ * A live region: announce this widget's own text when the signal says it changed.
+ *
+ * Decided here and CALLED one layer up, for the reason {@link ResolvedFile} is:
+ * `Gtk.Accessible.announce()` takes a `Gtk.AccessibleAnnouncementPriority` enum
+ * member, and nothing under `primitives/` imports `gi://`. L2 holds the whole of the
+ * decision — which primitive can answer the prop at all, which signal reports the
+ * change, which property carries the message, and which GTK priority each React
+ * Native level is — and none of the call.
+ */
+export interface ResolvedAnnouncement {
+    /** The React Native prop that asked for it. */
+    readonly prop: string;
+    /** The GObject signal that means "the content changed". */
+    readonly signal: string;
+    /** The widget property holding the message. */
+    readonly read: string;
+    /** The `Gtk.AccessibleAnnouncementPriority` nick. */
+    readonly priority: 'low' | 'medium' | 'high';
+}
 export interface PrimitivePlan {
     readonly primitive: string;
     /** The node the PARENT adopts. */
@@ -78,6 +98,10 @@ export interface PrimitivePlan {
     readonly files: readonly ResolvedFile[];
     /** Presses that arrive through a gesture controller instead of a signal. */
     readonly gestures: readonly ResolvedGesture[];
+    /** Live regions this element declares. At most one, and empty for every primitive but `Text`. */
+    readonly announcements: readonly ResolvedAnnouncement[];
+    /** What a `ref` on this element receives, or null for the widget itself. */
+    readonly handle: HandleKind | null;
     /** Where a text child goes, or null when text under this primitive is refused. */
     readonly textSink: string | null;
     /** What this element publishes to its children. */

package/lib/types/primitives/table.d.ts

@@ -58,6 +58,44 @@ export interface RefusedRoute {
     /** One line: why GTK cannot answer it, and what to do instead. */
     readonly why: string;
 }
+/**
+ * A prop the LAYER answers by calling a method when a signal fires.
+ *
+ * `accessibilityLiveRegion` is the whole of it, and the shape is forced by the
+ * mismatch between the two platforms' models. React Native's prop is a DECLARATION
+ * — "when this element's content changes, tell the user" — and the platform's
+ * accessibility layer watches for the change. GTK has no such declaration: since
+ * 4.14 it has `gtk_accessible_announce(self, message, priority)` (MEASURED on
+ * gtk 4.22.4 — the method is on the `Gtk.Accessible` interface, so every widget has
+ * it, and it takes a `GtkAccessibleAnnouncementPriority` of LOW/MEDIUM/HIGH), which
+ * is an IMPERATIVE call: the caller supplies both the moment and the message.
+ *
+ * So a live region can only be built where this layer knows both. It knows both on
+ * exactly one primitive — `Text`, whose content IS one widget property, so
+ * `notify::label` is the moment and `label` is the message. Everywhere else the
+ * content is a SUBTREE and GTK emits nothing when one changes, which is why the
+ * common route refuses the prop by name rather than this route answering it.
+ *
+ * Like {@link FileRoute} and {@link GestureRoute}, the table holds the whole of the
+ * DECISION and none of the call: the priority is a `gi://Gtk` enum member and
+ * nothing under `primitives/` imports `gi://`.
+ */
+export interface AnnounceRoute {
+    readonly to: 'announce';
+    /** The signal whose emission means "the content this element shows has changed". */
+    readonly signal: string;
+    /** The widget property holding the message to announce. */
+    readonly read: string;
+    /**
+     * React Native's values → `Gtk.AccessibleAnnouncementPriority` nicks; `null` is
+     * "recognised, announce nothing".
+     *
+     * GTK's `low` is deliberately absent as a TARGET: React Native has three values
+     * and ARIA has two live-region levels, so a third GTK priority would have no
+     * spelling to arrive from.
+     */
+    readonly map: Readonly<Record<string, 'low' | 'medium' | 'high' | null>>;
+}
 /**
  * A prop that is a DECLARED no-op.
  *
@@ -106,7 +144,20 @@ export interface GestureRoute {
     /** The `Gtk.GestureClick` signal — `released` for a completed press. */
     readonly signal: string;
 }
-export type PropRoute = PropertyRoute | StylePropertyRoute | EventRoute | RefusedRoute | IgnoredRoute | FileRoute | GestureRoute;
+export type PropRoute = PropertyRoute | StylePropertyRoute | EventRoute | RefusedRoute | IgnoredRoute | FileRoute | GestureRoute | AnnounceRoute;
+/**
+ * The imperative handle a `ref` on this primitive receives, instead of the widget.
+ *
+ * DATA and not a per-binding decision, for the reason every other field here is
+ * data: React and Solid both hand a `ref` its value, and a handle built in one L3
+ * would be a second vocabulary the other one does not have. `handles.ts` turns the
+ * kind into the object; the table only says which primitives have one.
+ *
+ * A primitive with NO kind hands back the `Gtk.Widget` itself, which is what every
+ * primitive did before and still does — React Native only gives an imperative
+ * handle to the components that document one.
+ */
+export type HandleKind = 'text-input';
 /** A second styleable node inside the element, which the children go into. */
 export interface ContentSpec {
     readonly tag: string;
@@ -191,6 +242,17 @@ export interface PrimitiveSpec {
      * a silent drop for the reason every other one in this file is.
      */
     readonly refusesStyle?: string;
+    /**
+     * What a `ref` on this primitive receives, when it is not the widget.
+     *
+     * `TextInput` only, and it is React Native's own rule rather than a convenience:
+     * `TextInput` is a CLASS there, so `useRef<TextInput>(null)` is ordinary code and
+     * `ref.current.focus()` is documented API. Handing back the bare `Gtk.Widget`
+     * type-checked as `unknown` and answered `undefined is not a function` at the
+     * call — the shape this whole layer refuses to ship for props, arriving through
+     * the one channel that had no table.
+     */
+    readonly handle?: HandleKind;
 }
 export declare const PRIMITIVES: Readonly<Record<string, PrimitiveSpec>>;
 /** The primitives this layer answers for. Derived, so it cannot disagree with the table. */

package/lib/types/prop-table.d.ts

@@ -0,0 +1,56 @@
+import { type PropAnswer, type PropStatus } from './primitives/answers.js';
+import { PRIMITIVE_NAMES } from './primitives/table.js';
+export type { PropAnswer, PropStatus };
+/**
+ * Every primitive this layer answers for.
+ *
+ * The table's own constant, re-exported rather than recomputed: a second
+ * `Object.keys(PRIMITIVES)` is a second thing to keep in step for no gain, and this
+ * subpath exists precisely so there is one answer.
+ */
+export { PRIMITIVE_NAMES };
+/**
+ * One React Native prop that selects a DIFFERENT widget, and therefore a different
+ * prop set.
+ *
+ * `TextInput`'s `multiline` is the only one: `false` is a `Gtk.Entry` and `true` is a
+ * `Gtk.TextView`, whose content lives in a buffer rather than a property, so `value`
+ * is answered on one and refused on the other. A caller that does not say which gets
+ * the base variant, which is what an element with the prop absent resolves to.
+ */
+export declare const PRIMITIVE_VARIANTS: Readonly<Record<string, string>>;
+/** Which variant of a primitive to ask about — `{ multiline: true }` for a `TextInput`. */
+export type PropVariant = Readonly<Record<string, boolean>>;
+/**
+ * What this layer does about `prop` on `primitive`.
+ *
+ * The whole answer, not a boolean: the STATUS says which route it takes, `why` is the
+ * reason for the two statuses that throw and for the declared no-ops, and `gtk` names
+ * what it reaches — the properties, the signal, or nothing.
+ */
+export declare function propAnswer(primitive: string, prop: string, variant?: PropVariant): PropAnswer;
+/**
+ * Would rendering this prop on this primitive succeed?
+ *
+ * `true` for every prop that reaches GTK **and** for a declared no-op: `ignored` is an
+ * answer, not a refusal, and a test that treated it as one would fail on
+ * `autoCapitalize` — an ordinary prop that a desktop correctly does nothing with.
+ */
+export declare function acceptsProp(primitive: string, prop: string, variant?: PropVariant): boolean;
+/**
+ * The sentence a render would print, for a prop that would not render.
+ *
+ * `null` for a prop this layer accepts, so `explainProp(…) === null` is the assertion
+ * a consumer's test makes and the message is what it prints when it fails.
+ */
+export declare function explainProp(primitive: string, prop: string, variant?: PropVariant): string | null;
+/** Every prop name this primitive's table row carries, sorted. Framework props are not among them. */
+export declare function propNames(primitive: string, variant?: PropVariant): readonly string[];
+/**
+ * The whole surface as plain data — one entry per primitive per prop.
+ *
+ * For tooling that wants to walk it rather than ask about one name: a lint rule, a
+ * migration script, a dashboard. Built on demand rather than exported as a constant,
+ * so a consumer that only asks `acceptsProp` never pays for it.
+ */
+export declare function propTable(variant?: PropVariant): readonly PropAnswer[];

package/lib/types/prop-table.spec.d.ts

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

package/lib/types/router/href.d.ts

@@ -0,0 +1,58 @@
+/** What `router.push` and its siblings accept, as `expo-router` spells it. */
+export type Href = string | HrefObject;
+export interface HrefObject {
+    /** A route pattern — `/detail/[id]` — or a plain path. */
+    readonly pathname: string;
+    /** Values for the pattern's `[name]` segments; the rest become a query string. */
+    readonly params?: Readonly<Record<string, unknown>>;
+}
+/**
+ * React Navigation's own nesting keys, which are not the author's params.
+ *
+ * `screen`, `params`, `initial`, `state`, `path`, `pop` and `merge` are how a nested
+ * NAVIGATE addresses a child navigator. Handing them back as though the author had
+ * written them makes those seven param names silently unusable, which is why
+ * `useLocalSearchParams` has always filtered them — and why `hrefFrom` refuses to
+ * SEND one: a param this layer would not read back is a param that vanishes.
+ */
+export declare const INTERNAL_PARAMS: ReadonlySet<string>;
+/**
+ * A param value → the string a URL can carry, or `null` for one it cannot.
+ *
+ * `null` rather than a throw, because the two callers want different things from the
+ * same answer: `paramsSeenBy` DROPS what it cannot represent (a route really can
+ * arrive carrying a dispatched object, and `useLocalSearchParams` has always left it
+ * out), while `hrefFrom` REFUSES it by name (an author writing one meant it to
+ * survive the trip).
+ */
+export declare const scalar: (value: unknown) => string | null;
+/**
+ * What `useLocalSearchParams` will hand back for a route carrying `params`.
+ *
+ * The OUT direction of this file's one rule. Shared with `useLocalSearchParams`
+ * itself rather than reimplemented there: two copies of "what counts as a param"
+ * would be exactly the mismatch the round-trip test exists to catch, sitting on both
+ * sides of it.
+ */
+export declare function paramsSeenBy(params: Readonly<Record<string, unknown>> | undefined): Record<string, string>;
+/** `/detail/[id]` → the param names it carries, in order. */
+export declare function patternParams(pathname: string): readonly string[];
+/**
+ * An `Href` → the URL string the router resolves.
+ *
+ * A STRING PASSES THROUGH UNTOUCHED, which is not laziness: expo-router's string
+ * form is already a URL, params and all, and re-encoding one would double-escape a
+ * query string an author wrote by hand.
+ */
+export declare function hrefFrom(call: string, href: Href): string;
+/**
+ * The inverse: the params a URL built from `pathname` carries.
+ *
+ * Pure, and it exists for the round-trip property rather than for the runtime — the
+ * real read-back goes through React Navigation's own state. What this gives is a
+ * check the layer can run on ITSELF: whatever `hrefFrom` writes into a pattern, this
+ * reads out, and the two must agree with `paramsSeenBy`. A drift between the writer
+ * and the reader is the defect that produced this file, so it is the one thing here
+ * that is asserted rather than argued.
+ */
+export declare function paramsInHref(pathname: string, url: string): Record<string, string>;

package/lib/types/router/href.spec.d.ts

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

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

@@ -1,3 +1,5 @@
+export { hrefFrom, paramsInHref, paramsSeenBy, patternParams } from './href.js';
+export type { Href, HrefObject } from './href.js';
 export { router, usePathname, useLocalSearchParams, navigationRef } from './navigation.js';
 export { Stack, type StackProps, type StackScreenOptions } from './stack.js';
 export { Tabs, type TabsProps, type TabScreenOptions } from './tabs.js';
@@ -5,6 +7,6 @@ export { RouterRoot, type RouterRootProps } from './root.js';
 export { RouterError, type RouterErrorCode } from './errors.js';
 export { buildRouteTree, pathConfigOf, screenUrls, type PathConfigLeaf, type PathConfigNode, type PathConfigTree, type RouteManifest, type RouteManifestEntry, type RouteNode, } from './routes.js';
 export { componentFor, provideRouteNode, screenOptionsFrom, useRouteNode, useSynthesisedScreens, type ScreenDeclaration, } from './screens.js';
-export * from '../generated/unsupported-router-exports.js';
+export * from '../generated/unsupported-router.js';
 export { ROUTER_NAMES, ROUTER_SUPPORT_TABLE, explainUnsupported, isImportable } from '../support-table.js';
 export type { SupportEntry, SupportStatus, SupportTier } from '../support-table.js';

package/lib/types/router/navigation.d.ts

@@ -1,3 +1,4 @@
+import { type Href } from './href.js';
 import { type RouteNode } from './routes.js';
 /** The container ref every navigator in the tree hangs under. */
 export declare const navigationRef: import("@react-navigation/core").NavigationContainerRefWithCurrent<ReactNavigation.RootParamList>;
@@ -18,18 +19,31 @@ export declare function uninstallRouter(): void;
  */
 export declare function notifyStateChanged(): void;
 /**
- * `expo-router`'s `router`: four methods, and every argument a URL.
+ * `expo-router`'s `router`.
  *
  * ADR 0032 measured the calls — `push` 19 times, `back` and `replace` a handful
- * each, `navigate` where a screen must not stack up. That is the whole object.
+ * each, `navigate` where a screen must not stack up.
+ *
+ * EVERY ARGUMENT IS AN `Href`, which is `string | { pathname, params }`, and the
+ * second half of that used to be missing: an object reached the router interpolated
+ * as `[object Object]`, matched no route, and landed on `+not-found` — silently, on
+ * 10 measured call sites. `href.ts` holds the resolution and the rule it shares with
+ * `useLocalSearchParams`.
+ *
+ * AND THE THREE NAMES THIS OBJECT REFUSES ARE PRESENT. The support table already
+ * called `dismiss`, `dismissAll`, `dismissTo`, `setParams` and `canGoBack` "a named
+ * refusal rather than an undefined property read" — and they were absent, so reaching
+ * for one was `router.dismissTo is not a function`, which names nothing. `canGoBack`
+ * is now answered for real, because a back button calls it before deciding whether to
+ * render at all.
  */
 export declare const router: {
     /** Go to `href`, adding a history entry even when that screen is already showing. */
-    readonly push: (href: string) => void;
+    readonly push: (href: Href) => void;
     /** Go to `href`, reusing the screen when it is already the current one. */
-    readonly navigate: (href: string) => void;
+    readonly navigate: (href: Href) => void;
     /** Replace the current screen with `href`, leaving the history length alone. */
-    readonly replace: (href: string) => void;
+    readonly replace: (href: Href) => void;
     /**
      * Go back one entry.
      *
@@ -39,6 +53,34 @@ export declare const router: {
      * and nothing anywhere says why.
      */
     readonly back: () => void;
+    /**
+     * Is there anywhere to go back to?
+     *
+     * The question `back()` refuses to answer for you, and the reason it has to exist:
+     * a screen calls this to decide whether to render a back affordance AT ALL, so a
+     * missing method is a `router.canGoBack is not a function` the moment anything
+     * asks — latent until the first screen that guards its own back button.
+     *
+     * `false` BEFORE THE CONTAINER IS READY, and that is an answer rather than a
+     * placeholder: nothing has been navigated to yet, so there is genuinely nowhere to
+     * go back to. `usePathname` answers `/` in the same window for the same reason.
+     * Refusing here instead would make the guard need a guard.
+     */
+    readonly canGoBack: () => boolean;
+    /** A modal stack this layer does not have. */
+    readonly dismiss: () => never;
+    readonly dismissAll: () => never;
+    readonly dismissTo: () => never;
+    /**
+     * Change the current route's params without navigating.
+     *
+     * Refused rather than built, and the reason is this file's own rule: params travel
+     * INTO a route through the pattern (`href.ts`) and back OUT through
+     * `useLocalSearchParams`. `setParams` writes them at neither end — it edits the
+     * route object in place — so the URL and the params would stop agreeing, and
+     * `usePathname` would answer for a URL that no longer describes the screen.
+     */
+    readonly setParams: () => never;
 };
 /**
  * The current URL, without its query string.

package/lib/types/router/tabs.d.ts

@@ -1,10 +1,45 @@
 import { type ReactElement, type ReactNode } from 'react';
+import type Adw from '@girs/adw-1';
 import { type ScreenDeclaration } from './screens.js';
 /** What one tab can be told. */
 export interface TabScreenOptions {
     /** The switcher button's label. Defaults to the route name. */
     title?: string;
 }
+/**
+ * Put the stack on the focused page, or leave it alone because that page is not there yet.
+ *
+ * THE PRESENCE CHECK IS THE TERMINATING CONDITION, and the reason it has to be explicit is
+ * that the obvious guard is a bet rather than a test. Writing
+ *
+ *     if (stack.get_visible_child_name() !== focused) stack.set_visible_child_name(focused);
+ *
+ * reads as "set it unless it is already set", and it terminates only when the set TAKES.
+ * MEASURED on libadwaita 1.9.3: `set_visible_child_name` with a name the stack does not hold
+ * changes nothing, emits NO `notify::visible-child-name`, and prints
+ * `Adwaita-WARNING: Child name '…' not found in AdwViewStack`. So `get_visible_child_name()`
+ * still answers the old page, the comparison is still unequal, and the effect — which has no
+ * dependency array on purpose, because a page can materialise on a render where `focused` did
+ * not change — repeats the failing call on every render for as long as the mismatch lasts.
+ *
+ * A focused route whose page React has not committed yet is an ORDINARY intermediate state,
+ * not a fault: the effect runs after the commit that added the OTHER pages, and the missing
+ * one arrives on a later commit. So the answer is to do nothing and let the next render try,
+ * which is what "not there yet" deserves — and one warning per render for a normal state is
+ * how a log stops being read.
+ *
+ * AND THE SET HAS A SECOND WAY TO DO NOTHING, which is why presence alone is not the whole
+ * gate. `adw_view_stack_set_visible_child_name` ends on
+ * `if (gtk_widget_get_visible (page->widget)) set_visible_child (...)`, so a page that is
+ * there but HIDDEN changes nothing, emits no notify and — unlike the missing name — prints
+ * NOTHING AT ALL (measured). That is the same non-terminating state by the quieter road: the
+ * caller would be told the stack shows `focused` while it shows the other page, and no log
+ * anywhere would disagree. Both no-op paths are therefore asked about BEFORE the write, which
+ * is also what keeps each one attributable to its own failing assertion.
+ *
+ * @returns whether the stack now shows `focused`.
+ */
+export declare function showFocusedPage(stack: Adw.ViewStack, focused: string): boolean;
 /** A `<Tabs.Screen>` declaration. Read as data by `<Tabs>`; never rendered. */
 declare function TabsScreen(_props: ScreenDeclaration & {
     options?: TabScreenOptions;

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

@@ -1,5 +1,6 @@
 import { createElement, mount } from '@gjsify/gtk-host/solid';
 import type { ClassNameInput } from '../primitives/classes.js';
+import { type TextInputHandle } from '../primitives/handles.js';
 import type { StyleInput } from '../primitives/style.js';
 /**
  * The host's node type, named through the adapter rather than imported.
@@ -39,6 +40,8 @@ export interface TextProps extends CommonProps {
     numberOfLines?: number;
     ellipsizeMode?: 'head' | 'middle' | 'tail';
     selectable?: boolean;
+    /** Announce this label's text when it changes. `Text` alone — see the React binding's own note. */
+    accessibilityLiveRegion?: 'none' | 'polite' | 'assertive';
 }
 export declare function Text(props: TextProps): HostNode;
 export interface PressableProps extends CommonProps {
@@ -77,7 +80,7 @@ export interface ActivityIndicatorProps extends CommonProps {
     hidesWhenStopped?: boolean;
 }
 export declare function ActivityIndicator(props: ActivityIndicatorProps): HostNode;
-export interface TextInputProps extends CommonProps {
+export interface TextInputProps extends Omit<CommonProps, 'ref'> {
     value?: string;
     defaultValue?: string;
     placeholder?: string;
@@ -89,6 +92,17 @@ export interface TextInputProps extends CommonProps {
     maxLength?: number;
     secureTextEntry?: boolean;
     keyboardType?: 'default' | 'email-address' | 'phone-pad' | 'number-pad' | 'numeric' | 'decimal-pad' | 'url';
+    /** A declared no-op: there is no autofill service on a GTK desktop. */
+    autoComplete?: string;
+    /** `autoComplete`'s iOS spelling, and the same absent addressee. */
+    textContentType?: string;
+    /** A declared no-op: each widget has one Return behaviour, and `multiline` picks the widget. */
+    submitBehavior?: 'submit' | 'blurAndSubmit' | 'newline';
+    /** The imperative handle, not the widget — L2 decides that, so both bindings agree. */
+    ref?: (handle: TextInputHandle) => void;
+}
+/** The instance type, merged with the component below. React Native's `TextInput` is a class. */
+export interface TextInput extends TextInputHandle {
 }
 export declare function TextInput(props: TextInputProps): HostNode;
 export interface SwitchProps extends CommonProps {