@gjsify/gtk-host 0.45.0 → 0.46.0

package/lib/types/style/tokens.d.ts

@@ -43,8 +43,84 @@ export interface StyleTokens {
  * scale would let a project's typo resolve against a value nobody chose, which is
  * the failure the declared-vocabulary rule exists to prevent — and it would make
  * "the values come from the project" false in the common case.
+ *
+ * That decision stands, and {@link TAILWIND_DEFAULT_TOKENS} is not a retreat from
+ * it: the measured gap is that a project REPLACING this default with its own
+ * generated scales loses `0` and `full`, which nothing in its `@theme` was ever
+ * going to declare. The answer is an opt-in a reader can see in their own code, not
+ * a wider default nobody chose. This constant stays as small as it is.
  */
 export declare const MINIMAL_TOKENS: StyleTokens;
+/**
+ * The Tailwind defaults a project's own `@theme` does not replace — OPT-IN.
+ *
+ * MEASURED, and this is the highest-frequency finding of the whole exercise. Running
+ * one production-shaped application's real class vocabulary — 87 distinct utilities,
+ * 826 occurrences — through this partition with tokens generated mechanically from
+ * its Tailwind v4 `@theme` resolves **81 of 87 distinct and 803 of 826 occurrences**.
+ * Five of the six failures are one thing: `rounded-full` (11 uses) and
+ * `inset-0`/`left-0`/`right-0`/`top-0` (9 between them). The project's declared
+ * scales simply have no `full` and no `0`.
+ *
+ * They have no reason to. **`0` and `full` are not design decisions.** A token source
+ * emits the values a designer chose; `inset-0` means "flush" and `rounded-full` means
+ * "a pill", and neither is a number anybody picked. A project that declares its whole
+ * palette still leans on Tailwind for the STRUCTURAL tokens, and finds out one class
+ * at a time.
+ *
+ * So this set is deliberately NOT a copy of Tailwind's default theme, and the name
+ * would be a lie if it carried the numeric ladder: shipping `spacing-4` … `spacing-96`
+ * would be shipping a design decision the project has already made differently, which
+ * is the opposite of the point. It carries the structural tokens and the keyword sets
+ * — the ones a `@theme` has no reason to name — and nothing that is a value someone
+ * chose.
+ *
+ * THREE DIVERGENCES FROM TAILWIND'S OWN NUMBERS, each forced and each measured:
+ *
+ *   - **Every length is px, not rem.** Tailwind v4's spacing is rem-based. A `rem`
+ *     token reaches CSS padding unchanged and is a NAMED ERROR the moment the same
+ *     token is asked to become a margin, because `Gtk.Widget:margin-top` is a `gint`
+ *     of device pixels with no unit conversion behind it. A rem scale here would
+ *     therefore trade "the token is missing" for "the token throws on half the
+ *     families", which is worse.
+ *   - **`full` is `9999px`, not `calc(infinity * 1px)`.** GTK's parser has no
+ *     infinity, and a border radius larger than the box is clamped anyway.
+ *   - **`inherit` is absent from the colours.** `color: inherit` parses, but
+ *     `alpha(inherit, 0.5)` does not (measured: *"inherit" is not a valid color
+ *     name*), so `bg-inherit/50` would be a refusal rather than a colour. The other
+ *     four keywords survive the alpha modifier and are carried.
+ *
+ * Opting in is a VISIBLE LINE in the consumer's code, which is the whole design:
+ *
+ * ```ts
+ * configureStyle({ tokens: mergeTokens(TAILWIND_DEFAULT_TOKENS, projectTokens) });
+ * ```
+ *
+ * Use {@link mergeTokens} and not a spread. `{ ...TAILWIND_DEFAULT_TOKENS,
+ * ...projectTokens }` replaces whole SCALES, so a project declaring any `spacing` at
+ * all loses `0` again — which is the exact bug this constant exists to answer.
+ */
+export declare const TAILWIND_DEFAULT_TOKENS: StyleTokens;
+/**
+ * Several token sets into one, merging PER TOKEN and not per scale.
+ *
+ * The distinction is the whole function. `{ ...defaults, ...project }` is an object
+ * spread over the SCALE names, so a project that declares any `spacing` replaces the
+ * default `spacing` wholesale and loses `0` — silently, and visible only as
+ * `inset-0` throwing much later. Later sets win token by token, which is what a
+ * reader means by "my values on top of the defaults".
+ */
+export declare function mergeTokens(...sets: readonly StyleTokens[]): StyleTokens;
+/**
+ * The sentence a scale-miss error adds when Tailwind's defaults DO define the token.
+ *
+ * The measured six failures each become a one-line fix with this and stay a search
+ * without it: "not in the borderRadius scale. Known: l, m, s" sends a reader to
+ * invent a radius, where naming the opt-in sends them to the line that was missing.
+ * Empty for a token nothing would have answered, so an ordinary typo is not offered
+ * a remedy that would not have helped.
+ */
+export declare function tailwindDefaultHint(scaleName: string, token: string): string;
 /** A token's value, or `undefined` when the scale is absent or does not carry it. */
 export declare const lookupToken: (scale: Scale | undefined, token: string) => string | undefined;
 /**

package/lib/types/style/tokens.spec.d.ts

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

package/lib/types/types.d.ts

@@ -140,6 +140,20 @@ export type ChildPolicy = {
     slots: Record<string, string>;
     defaultSlot: string;
     remove?: string;
+    /**
+     * Slots whose adder hands the child to an inner `Gtk.ListBox`, and which
+     * therefore need the same wrap `indexed` declares — keyed by slot, because a
+     * widget can have one such slot and two ordinary ones.
+     *
+     * MEASURED on GTK 4.22.4, and it is the wrap or a leak: `gtk_list_box_remove`
+     * does NOT unwrap. A `Gtk.ListBox` given a non-row child puts it inside an
+     * implicit `GtkListBoxRow`, and removing the ORIGINAL child then answers
+     * `Gtk-WARNING **: Tried to remove non-child 0x…` and leaves it parented —
+     * with a plain `Gtk.Label` and with a `Gtk.Button` alike. `Adw.ExpanderRow`'s
+     * `add_row` is that adder, so its disclosure slot declares the wrap and the
+     * host addresses the row it made.
+     */
+    wrapSlots?: Readonly<Record<string, 'list-box-row'>>;
 }
 /**
  * `Gtk.Stack`, `Adw.NavigationView`: children addressed by name/tag.
@@ -156,6 +170,55 @@ export type ChildPolicy = {
     remove: string;
     nameFrom: string;
     titled: boolean;
+    /**
+     * Take the child out of view BEFORE the parent removes it, and put its
+     * own `visible` back afterwards. Declared per widget, because it is a
+     * defect in one of them rather than a property of being keyed.
+     *
+     * The defect is libadwaita's. `stack_remove` — what both
+     * `adw_view_stack_remove` and dispose call — clears `visible_child`, then
+     * does `g_clear_object (&page->widget)`, and never touches
+     * `last_visible_child`, which can still point at that same page. A later
+     * reader then dereferences a page whose widget is NULL:
+     *
+     *     Gtk-CRITICAL **: gtk_widget_set_child_visible: assertion 'GTK_IS_WIDGET (widget)' failed
+     *
+     * Source: `refs/libadwaita/src/adw-view-stack.c` — `stack_remove` at 1184,
+     * the stale read at 934 in `transition_done_cb`. Read at 42f647f
+     * (1.10.alpha.1); that file is byte-identical at the 1.9.3 tag, which is
+     * what is installed here, so one reading covers both.
+     *
+     * MEASURED on libadwaita 1.9.3 / GTK 4.22.4 / GJS 1.88.1. Reproducer, no
+     * renderer involved: add `a` and `b`, present a window holding the stack,
+     * `set_visible_child_name('b')`, `remove(a)`, then let the window go away.
+     * Each precondition alone is silent, a stack never made visible included —
+     * `set_visible_child` only records `last_visible_child` when
+     * `gtk_widget_is_visible` answers yes. `Gtk.Stack` and
+     * `Adw.NavigationView`, the other two `keyed` descriptors, do not
+     * reproduce it at all, which is why this is a field and not the kind.
+     *
+     * WHICH read fires decides what a test has to do, so it is measured rather
+     * than listed: the UNMAP one. `AdwAnimation` connects `adw_animation_skip`
+     * to its widget's `unmap` (`adw-animation.c`) and the skip runs
+     * `transition_done_cb`, so merely hiding the window is enough and
+     * destroying it does the same — while a queued resize plus draw, and a
+     * direct `measure()`, both stayed quiet. The file's other reads (snapshot,
+     * size-allocate, measure) are real paths this reproducer does not reach.
+     *
+     * Hiding first is libadwaita's OWN cleanup: the visibility notify runs
+     * `update_child_visible`, which does clear `last_visible_child`. Measured
+     * SUFFICIENT and not merely necessary — 400 randomised
+     * add/remove/switch/reorder steps against a live 200 ms transition, three
+     * seeds, 44/23/25 criticals unpatched against 0/0/0 patched.
+     *
+     * The restore is load-bearing. `reorderMode` answers `remove-all` for
+     * `keyed`, and measured, a reversal that hides without restoring leaves the
+     * stack with no visible child and no way back: the last line of
+     * `adw_view_stack_set_visible_child_name` is
+     * `if (gtk_widget_get_visible (page->widget)) set_visible_child (...)`, so
+     * for a hidden page it is a no-op with no warning at all.
+     */
+    hideBeforeRemove?: boolean;
 }
 /** `Gtk.Grid`: position is data on the child, so document order carries nothing. */
  | {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gjsify/gtk-host",
-    "version": "0.45.0",
+    "version": "0.46.0",
     "description": "Framework-agnostic GTK4/Adwaita host: the element model UI-framework renderers bind to",
     "type": "module",
     "module": "lib/esm/index.js",
@@ -71,11 +71,11 @@
         "build:gjsify": "gjsify build --library 'src/**/*.{ts,js}' --exclude 'src/**/*.spec.{mts,ts}' 'src/test.{mts,ts}'",
         "build:types": "gjsify tsc",
         "build:test": "gjsify run build:test:gjs",
-        "build:test:node": "gjsify build src/test.mts --app node --outfile dist/test.node.mjs --define '__VUE_OPTIONS_API__=false' --define '__VUE_PROD_DEVTOOLS__=false' --define '__VUE_PROD_HYDRATION_MISMATCH_DETAILS__=false' --define 'process.env.NODE_ENV=\"production\"' --exclude-globals navigator",
-        "build:test:gjs": "gjsify build src/test.mts --app gjs --outfile test.gjs.mjs --define '__VUE_OPTIONS_API__=false' --define '__VUE_PROD_DEVTOOLS__=false' --define '__VUE_PROD_HYDRATION_MISMATCH_DETAILS__=false' --define 'process.env.NODE_ENV=\"production\"' --exclude-globals navigator",
+        "build:test:node": "gjsify build src/test.mts --app node --outfile dist/test.node.mjs --define __VUE_OPTIONS_API__=false --define __VUE_PROD_DEVTOOLS__=false --define __VUE_PROD_HYDRATION_MISMATCH_DETAILS__=false --define \"process.env.NODE_ENV='production'\" --exclude-globals navigator",
+        "build:test:gjs": "gjsify build src/test.mts --app gjs --outfile test.gjs.mjs --define __VUE_OPTIONS_API__=false --define __VUE_PROD_DEVTOOLS__=false --define __VUE_PROD_HYDRATION_MISMATCH_DETAILS__=false --define \"process.env.NODE_ENV='production'\" --exclude-globals navigator",
         "test": "gjsify run build:gjsify && gjsify run build:test && gjsify run test:gjs",
         "test:gjs": "gjsify run test.gjs.mjs",
-        "test:gjs-on-node": "gjsify run build:gjsify && gjsify run build:test:node && NODE_GI_NATIVE=${NODE_GI_NATIVE:-prebuild} node dist/test.node.mjs",
+        "test:gjs-on-node": "gjsify run build:gjsify && gjsify run build:test:node && node dist/test.node.mjs",
         "generate": "gjsify build src/generator/main.mts --app gjs --outfile tmp/generate.gjs.mjs && gjsify run tmp/generate.gjs.mjs -- --out src/generated && gjsify format src/generated"
     },
     "keywords": [
@@ -86,14 +86,14 @@
         "host"
     ],
     "dependencies": {
-        "@girs/adw-1": "^4.1.0",
-        "@girs/gdk-4.0": "^4.1.0",
-        "@girs/gio-2.0": "^4.1.0",
-        "@girs/gjs": "^4.1.0",
-        "@girs/glib-2.0": "^4.1.0",
-        "@girs/gobject-2.0": "^4.1.0",
-        "@girs/gtk-4.0": "^4.1.0",
-        "@girs/pango-1.0": "^4.1.0"
+        "@girs/adw-1": "4.6.0",
+        "@girs/gdk-4.0": "4.6.0",
+        "@girs/gio-2.0": "4.6.0",
+        "@girs/gjs": "4.6.0",
+        "@girs/glib-2.0": "4.6.0",
+        "@girs/gobject-2.0": "4.6.0",
+        "@girs/gtk-4.0": "4.6.0",
+        "@girs/pango-1.0": "4.6.0"
     },
     "peerDependencies": {
         "@vue/runtime-core": "^3.5.0",
@@ -116,13 +116,12 @@
         }
     },
     "devDependencies": {
-        "@gjsify/cli": "^0.45.0",
+        "@gjsify/cli": "^0.46.0",
         "@vue/runtime-core": "^3.5.0",
         "solid-js": "^1.9.0",
-        "@gjsify/unit": "^0.45.0",
+        "@gjsify/unit": "^0.46.0",
         "@types/node": "^25.9.2",
         "typescript": "^6.0.3",
-        "@gjsify/domparser": "^0.45.0",
         "@gjsify/node-gi": "file:../../node-gi/node-gi",
         "vue": "^3.5.41",
         "vue-tsc": "^3.3.11",

package/lib/types/generator/gir.d.mts

@@ -1,190 +0,0 @@
-/**
- * Read the GIR XML into a plain model.
- *
- * WHY THE XML AND NOT THE TYPELIB. Both carry the structure — measured on gtk
- * 4.22.4, `GIRepository` 3.0 answers class enumeration, abstractness, properties
- * with `CONSTRUCT_ONLY`, signals, methods and property enum types, and its
- * concrete-widget set is IDENTICAL to the XML's. What the typelib does not carry,
- * and offers no API that could, is documentation, default values and
- * since-versions: it strips them by design, which is why gi-docgen reads the GIR.
- * ADR 0028 § 6 makes these surfaces a PUBLISHED artifact whose point is what a
- * consumer's editor shows on hover, so the richer input wins.
- *
- * WHY @gjsify/domparser. Measured on the 6.2 MB `Gtk-4.0.gir`: 232 ms, RSS 53 MB
- * -> 96 MB, and its `application/xml` mode is right where it has to be —
- * selectors are case-SENSITIVE (`CLASS` matches nothing), namespaced tags work
- * (`glib\:signal` -> 352), namespaced attributes work (`[glib\:type-name]` ->
- * 445). No new dependency, and a tier-1 package gets dogfooded against a real
- * 6 MB document.
- *
- * ONE FROZEN WART TO KNOW ABOUT: in XML mode `tagName` is LOWERCASED and
- * `nodeName` UPPERCASED, both wrong by the XML spec and both deliberately frozen
- * (ADR 0026 § Decision 4) because a measured consumer switches on lowercase tag
- * literals at 24 sites. Harmless here — every GIR tag is lowercase already — but
- * a generator for a mixed-case dialect could not use this reader as-is.
- */
-/**
- * A GIR type reference, with the array flag kept SEPARATE.
- *
- * Not a nicety: `<property name="css-classes"><array><type name="utf8"/></array>`
- * is `string[]`, and a reader that asked for a descendant `<type>` would answer
- * `string` — for a property authored as `cssClasses={['card']}` on every second
- * widget. `querySelector` searches descendants, so the array case has to be
- * checked FIRST, on own children only.
- */
-export interface GirType {
-    /** Qualified where GIR wrote a reference (`Gtk.Orientation`), bare for a C scalar (`gboolean`). */
-    readonly name: string;
-    readonly array: boolean;
-}
-export interface GirProperty {
-    readonly name: string;
-    readonly writable: boolean;
-    readonly readable: boolean;
-    readonly constructOnly: boolean;
-    readonly type: GirType;
-    /** GIR carries it, the typelib does not — `GTK_ORIENTATION_HORIZONTAL`. */
-    readonly defaultValue?: string;
-    readonly deprecated: boolean;
-    /** GIR's `version` attribute — the release that introduced this member. */
-    readonly since?: string;
-    readonly doc?: string;
-}
-/**
- * The GObject nick a GIR enum member would get if GIR did not say.
- *
- * GIR writes `baseline_fill`; the nick GObject registered is `baseline-fill`. This
- * is the FALLBACK for a `<member>` with no `glib:nick` — the attribute itself is
- * the answer wherever it exists, because the substitution is right for Gtk and Adw
- * by luck and not by construction: some nicks keep an underscore it would have
- * replaced, and nothing but the attribute knows which one survived.
- *
- * The count that used to sit here is now `ts-for-gir/scripts/check-nick-derivation.mjs`,
- * which owns the corpus this measures over. It also settles what looked like a
- * contradiction: this file said 97 and ts-for-gir said 889 over the SAME 705 GIRs,
- * and both were right — the derivations differ. 889 counts a fallback that also
- * lowercases, which adds the 792 members whose GIR name carries uppercase and whose
- * nick preserves it. This one does not lowercase, so 97 is its number. Quote a
- * derived-nick count without naming its derivation and you get that pair back.
- */
-export declare const nickOf: (member: string) => string;
-export interface GirParam {
-    readonly name: string;
-    readonly type: GirType;
-    /** GIR's `direction`, which defaults to `in` when the attribute is absent. */
-    readonly direction: 'in' | 'out' | 'inout';
-    /**
-     * GIR's `caller-allocates`. It decides whether a non-`in` slot holds anything
-     * at all — see `renderParam` in `surface.mts`, which is the only reader.
-     */
-    readonly callerAllocates: boolean;
-}
-export interface GirSignal {
-    readonly name: string;
-    /**
-     * WITHOUT the emitting object. GIR lists a signal's `<parameters>` free of the
-     * instance (unlike a `<method>`), and the host strips the instance too —
-     * `next(...args.slice(1))` in `signals.ts`. The two line up exactly, which is
-     * why a generated handler signature can be taken from here verbatim.
-     */
-    readonly params: readonly GirParam[];
-    readonly deprecated: boolean;
-    /** GIR's `version` attribute — the release that introduced this signal. */
-    readonly since?: string;
-    readonly doc?: string;
-}
-export interface GirClass {
-    /** The GType name — `GtkBox`. Absent for a class GIR declares without one. */
-    readonly gtype: string;
-    /** GIR-local name — `Box`. */
-    readonly name: string;
-    readonly namespace: string;
-    readonly kind: 'class' | 'interface';
-    readonly abstract: boolean;
-    /** Namespace-qualified parent — `Gtk.Widget` — or null at the root. */
-    readonly parent: string | null;
-    /** Qualified interfaces (`<implements>`), or an interface's `<prerequisite>`s. */
-    readonly implements: readonly string[];
-    readonly methods: readonly string[];
-    readonly signals: readonly GirSignal[];
-    readonly properties: readonly GirProperty[];
-    readonly doc?: string;
-}
-export interface GirEnum {
-    readonly gtype: string;
-    /** Namespace-qualified — `Gtk.Orientation`. */
-    readonly qualified: string;
-    readonly flags: boolean;
-    /** The NICKS, which is what a string-accepting surface needs. */
-    readonly members: readonly string[];
-}
-export interface GirNamespace {
-    readonly name: string;
-    readonly version: string;
-    /** Classes AND interfaces, in one list: `implements` resolves against the same index. */
-    readonly classes: readonly GirClass[];
-    readonly enums: readonly GirEnum[];
-    /** Every other named type GIR declares — records, unions, callbacks, aliases. */
-    readonly otherTypes: readonly string[];
-}
-export declare function readNamespace(xml: string): GirNamespace;
-/** Every class and interface across the namespaces read, keyed the way GIR references them. */
-export declare function indexClasses(namespaces: readonly GirNamespace[]): Map<string, GirClass>;
-/**
- * Walk to the root, or as far as the loaded namespaces reach.
- *
- * A chain that leaves the loaded set is not an error: `Gtk.Widget`'s own parent
- * is `GObject.InitiallyUnowned`, and loading GObject-2.0 to learn that would buy
- * nothing. What matters is whether `Gtk.Widget` is ON the chain.
- */
-export declare function ancestors(cls: GirClass, index: Map<string, GirClass>): GirClass[];
-/**
- * Every declaration a class's members can come from — self, ancestors, interfaces.
- *
- * The interfaces are not optional and the measurement says why: `GtkBox` declares
- * four properties of its own and `orientation` is NOT among them. It lives on
- * `Gtk.Orientable`, an `<implements>` of `GtkBox`, because GObject installs
- * interface properties on the implementor at runtime while GIR keeps them once,
- * on the interface. A class-only reader therefore emits a surface in which
- * `<gtk-box orientation="vertical">` — the most-written GtkBox attribute there is
- * — is a type error.
- *
- * Order is self, then the parent chain, then interfaces of each, so a nearer
- * declaration of the same property name wins.
- */
-export declare function declarations(cls: GirClass, index: Map<string, GirClass>): GirClass[];
-/**
- * Concrete descendants of a root class — the set a renderer can actually create.
- *
- * The root is a PARAMETER so a fixture can exercise this with a five-class GIR of
- * its own. Hard-coding `GtkWidget` would leave the walk, the abstract filter and
- * the namespace-crossing parent chain testable only against the real 6.2 MB file,
- * where an off-by-one is invisible.
- */
-export declare function concreteWidgets(namespaces: readonly GirNamespace[], root?: string): GirClass[];
-/**
- * The placement carriers: concrete classes that are NOT widgets and yet hold one.
- *
- * GTK4's list widgets do not take children. A `Gtk.ListView` installs no `append`,
- * `add`, `insert`, `prepend`, `remove` or `set_child` at all — measured against its
- * prototype — because what it takes is a factory, and the factory hands back a
- * carrier whose `child` is where a row's subtree goes. Those carriers are plain
- * `GObject.Object` descendants: `GObject.type_is_a(Gtk.ListItem, Gtk.Widget)` is
- * FALSE, measured on gjs 1.88.1 / GTK 4.22.4.
- *
- * So "every concrete descendant of GtkWidget" is one class short of the set a
- * renderer must be able to name, and this is the other half. It is a RULE and not a
- * list on purpose: a hand-written list is the kind of curated data ADR 0028 § 2
- * reserves for what the GIR cannot express, and the GIR expresses this perfectly
- * well — a carrier is a concrete non-widget that declares both halves of a
- * one-child slot.
- *
- * Measured across Gtk-4.0 + Adw-1, the rule selects exactly four:
- * `GtkListItem`, `GtkListHeader`, `GtkColumnViewCell` and `AdwToggle`. The fourth is
- * the argument for the rule — it was not on the hand-written list that preceded it,
- * has the identical shape, and would have been an arbitrary gap.
- *
- * What this does NOT do is give them a policy. A generated row is always
- * `uncurated`; which method adopts the child stays curated, exactly as for widgets.
- */
-export declare function placementCarriers(namespaces: readonly GirNamespace[]): GirClass[];

package/lib/types/generator/mini.fixture.d.mts

@@ -1,30 +0,0 @@
-/**
- * A five-class GIR, so the generator is testable without the 6.2 MB one.
- *
- * Every element here earns its place by exercising a branch the real GIR cannot
- * exercise ON DEMAND:
- *
- *  - `Orientable.label` is a `gint` and `Box.label` a `utf8`, so the two bases of
- *    `MiniBoxProps` disagree and the `Omit` machinery has to fire. Measured, the
- *    real Gtk+Adw hierarchy produces ZERO such conflicts, which left that code
- *    shipped and unexercised — this is what turns it into a tested path.
- *  - `baseline_fill` is a two-word enum member, so the GIR-underscore-to-nick
- *    substitution is visible.
- *  - `css-classes` is an ARRAY of a scalar, the case a descendant `<type>` lookup
- *    gets wrong by answering `string` for `string[]`.
- *  - `locked` is readable and NOT writable, so the writable filter has something to
- *    drop.
- *  - `MiniGLThing` has two adjacent capitals, so `tagOf`'s acronym rule and the
- *    Volar-resolution gap both have a case.
- *  - `Nameless` has no `glib:type-name`, and `NotAWidget` does not descend from the
- *    root — the two reasons a class is skipped.
- *
- * Embedded as a string rather than a file: the test bundle runs under gjs from a
- * path that is not the source tree, and a fixture that cannot be found is a test
- * that silently checks nothing.
- */
-export declare const MINI_GIR = "<?xml version=\"1.0\"?>\n<repository version=\"1.2\"\n            xmlns=\"http://www.gtk.org/introspection/core/1.0\"\n            xmlns:c=\"http://www.gtk.org/introspection/c/1.0\"\n            xmlns:glib=\"http://www.gtk.org/introspection/glib/1.0\">\n  <namespace name=\"Mini\" version=\"1.0\">\n    <enumeration name=\"Align\" glib:type-name=\"MiniAlign\">\n      <member name=\"fill\" value=\"0\"/>\n      <member name=\"baseline_fill\" value=\"1\"/>\n      <!-- A nick GIR CARRIES and the substitution would get wrong. 97 members\n           across this workspace's GIRs are shaped like this. -->\n      <member name=\"two_words\" value=\"2\" glib:nick=\"renamed\"/>\n    </enumeration>\n    <bitfield name=\"StateFlags\" glib:type-name=\"MiniStateFlags\">\n      <member name=\"active\" value=\"1\"/>\n    </bitfield>\n    <record name=\"Rect\" c:type=\"MiniRect\"/>\n    <interface name=\"Orientable\" glib:type-name=\"MiniOrientable\">\n      <doc xml:space=\"preserve\">Anything with an orientation. Second sentence, dropped.</doc>\n      <property name=\"orientation\" writable=\"1\">\n        <doc xml:space=\"preserve\">Which way round it goes.</doc>\n        <type name=\"Align\"/>\n      </property>\n      <property name=\"label\" writable=\"1\">\n        <type name=\"gint\"/>\n      </property>\n    </interface>\n    <class name=\"Widget\" glib:type-name=\"MiniWidget\" abstract=\"1\" parent=\"GObject.Object\">\n      <property name=\"visible\" writable=\"1\"><type name=\"gboolean\"/></property>\n      <property name=\"css-classes\" writable=\"1\"><array><type name=\"utf8\"/></array></property>\n      <property name=\"locked\"><type name=\"gint\"/></property>\n      <property name=\"area\" writable=\"1\"><type name=\"Rect\"/></property>\n      <glib:signal name=\"destroy\"/>\n      <method name=\"show\"/>\n    </class>\n    <class name=\"Box\" glib:type-name=\"MiniBox\" parent=\"Widget\">\n      <implements name=\"Orientable\"/>\n      <property name=\"spacing\" writable=\"1\"><type name=\"gint\"/></property>\n      <property name=\"label\" writable=\"1\"><type name=\"utf8\"/></property>\n      <property name=\"old-thing\" writable=\"1\" deprecated=\"1\"><type name=\"gboolean\"/></property>\n      <glib:signal name=\"row-activated\" version=\"1.2\">\n        <parameters>\n          <parameter name=\"row\"><type name=\"Widget\"/></parameter>\n          <parameter name=\"how\"><type name=\"Align\"/></parameter>\n        </parameters>\n      </glib:signal>\n      <method name=\"append\"/>\n      <method name=\"remove\"/>\n    </class>\n    <class name=\"GLThing\" glib:type-name=\"MiniGLThing\" parent=\"Widget\">\n      <property name=\"mode\" writable=\"1\"><type name=\"Align\"/></property>\n      <property name=\"flags\" writable=\"1\"><type name=\"StateFlags\"/></property>\n    </class>\n    <class name=\"Nameless\" parent=\"Widget\"/>\n    <class name=\"NotAWidget\" glib:type-name=\"MiniNotAWidget\" parent=\"GObject.Object\"/>\n  </namespace>\n</repository>\n";
-/** The fixture's own namespace-to-package map, which the real one has no entry for. */
-export declare const MINI_PACKAGES: {
-    readonly Mini: "@girs/mini-1.0";
-};

package/lib/types/generator/surface.d.mts

@@ -1,62 +0,0 @@
-/**
- * Build the declaration graph the type surfaces are emitted from.
- *
- * ONE INTERFACE PER GIR DECLARATION, carrying its OWN members and extending its
- * bases — not one flat interface per widget. The measurement decides it: the 164
- * concrete widgets have 6768 writable property slots between them and only 561
- * distinct property names. Flattening would emit the same `visible?: boolean`
- * 164 times; mirroring GIR's own inheritance emits it once, on `GtkWidgetProps`,
- * and the diff of a GTK update then shows what actually changed.
- *
- * THE CONFLICT MACHINERY IS NOT DEFENSIVE. TypeScript requires a multiply
- * inherited member to be IDENTICAL in every base — `string` and `string | null`
- * are not — and GTK's interfaces do redeclare class properties. So a base that
- * loses a member is emitted as `Omit<Base, 'name'>`, because a local redeclaration
- * does NOT repair incompatible bases (it turns one error into another).
- */
-import { type GirClass, type GirNamespace } from './gir.mjs';
-import { type Universe } from './tsmap.mjs';
-export interface PropMember {
-    readonly kebab: string;
-    readonly camel: string;
-    readonly ts: string;
-    readonly doc?: string;
-    readonly deprecated: boolean;
-    readonly since?: string;
-}
-export interface SignalMember {
-    readonly signal: string;
-    readonly prop: string;
-    /** Already rendered — `(row: Gtk.ListBoxRow) => void`. */
-    readonly ts: string;
-    readonly doc?: string;
-    readonly deprecated: boolean;
-    readonly since?: string;
-}
-export interface Declaration {
-    /** GIR-qualified — `Gtk.Box`. The graph is keyed on this, the way GIR references. */
-    readonly key: string;
-    readonly gtype: string;
-    readonly kind: 'class' | 'interface';
-    /** `GtkBoxProps`. */
-    readonly iface: string;
-    readonly bases: readonly string[];
-    readonly props: readonly PropMember[];
-    readonly signals: readonly SignalMember[];
-    readonly doc?: string;
-}
-export interface SurfaceModel {
-    /** The 164, sorted by GType name. */
-    readonly widgets: readonly GirClass[];
-    readonly declarations: ReadonlyMap<string, Declaration>;
-    /** Widget GType -> the GTypes of every declaration its members come from, self first. */
-    readonly closure: ReadonlyMap<string, readonly string[]>;
-    /** Enum GType -> nicks, for the emitted aliases and for the runtime nick check. */
-    readonly enumNicks: ReadonlyMap<string, readonly string[]>;
-    readonly namespacesUsed: ReadonlySet<string>;
-    /** Copied from the universe, so the emitter needs no second source for it. */
-    readonly packages: Readonly<Record<string, string>>;
-    /** Base -> members it must not contribute, because a nearer declaration disagrees. */
-    readonly omissions: ReadonlyMap<string, ReadonlyMap<string, readonly string[]>>;
-}
-export declare function buildSurface(widgets: readonly GirClass[], namespaces: readonly GirNamespace[], universe: Universe): SurfaceModel;

package/lib/types/generator/tsmap.d.mts

@@ -1,73 +0,0 @@
-/**
- * GIR type -> TypeScript type, and the two places variance decides the answer.
- *
- * Measured over the real Gtk-4.0 + Adw-1 GIR with the seven referenced namespaces
- * loaded: 6768 writable property slots and 1889 signal parameters, and NOT ONE
- * type name that fails to resolve. So there is no "unknown fallback" branch to
- * hide behind — every type either maps or the generator fails and says which.
- *
- * WHERE PROPERTIES AND PARAMETERS MUST DIFFER, twice, both times because a
- * property is an INPUT and a handler parameter is an OUTPUT:
- *
- *  1. An enum PROPERTY takes the nick (`orientation="vertical"`) — the host
- *     resolves it (`coerce()` in props.ts) precisely because GObject would
- *     silently keep the old value. An enum PARAMETER arrives as a NUMBER: GJS
- *     hands the marshalled value. Offering the nick union in a parameter would
- *     invite `if (mode === 'single')`, which is always false — a silent bug worse
- *     than no typing at all.
- *  2. Nullability widens a property harmlessly and BREAKS a parameter. GIR marks
- *     many parameters `nullable="1"`, but a parameter type is contravariant: with
- *     `(row: Gtk.ListBoxRow | null) => void` declared, the ordinary
- *     `onRowActivated={(row: Gtk.ListBoxRow) => …}` stops compiling. So object
- *     PROPERTIES get `| null` (clearing one is legitimate) and parameters do not,
- *     and this comment is the record that the second was a decision rather than an
- *     oversight.
- *
- * FLAGS ARE `number`, in both positions, and that mirrors the runtime exactly: the
- * host REFUSES a nick string for a flags property by name (`err.badFlags`),
- * because resolving a nick set ("horizontal|vertical") is not something GObject
- * exposes. A union of nicks here would type-check something the host rejects.
- */
-import type { GirClass, GirEnum, GirNamespace, GirType } from './gir.mjs';
-/** GIR namespace -> the `@girs` package that types it. Only these seven are referenced. */
-export declare const GIRS_PACKAGES: Readonly<Record<string, string>>;
-export interface Universe {
-    readonly enums: Map<string, GirEnum>;
-    readonly classes: Map<string, GirClass>;
-    readonly others: Set<string>;
-    /**
-     * GIR namespace -> the `@girs` package that types it.
-     *
-     * Carried here rather than read from the module constant, so a fixture can
-     * supply its own five-class namespace. Without it the type mapper is only ever
-     * exercised against the real GIR, where the branch that refuses an unknown
-     * namespace can never be reached.
-     */
-    readonly packages: Readonly<Record<string, string>>;
-}
-export declare function buildUniverse(namespaces: readonly GirNamespace[], packages?: Readonly<Record<string, string>>): Universe;
-export { nickOf } from './gir.mjs';
-export interface TsType {
-    readonly text: string;
-    /** GIR namespaces whose `@girs` import the emitted text needs. */
-    readonly namespaces: readonly string[];
-    /** Enum GTypes whose nick alias the emitted text references. */
-    readonly enums: readonly string[];
-}
-export declare class TypeMapError extends Error {
-}
-/** A nick union, or `never` for an enum GIR declares with no members. */
-export declare const nickUnion: (e: GirEnum) => string;
-/** The alias name a nick union is emitted under — the GType name, so it is unique. */
-export declare const nickAliasOf: (e: GirEnum) => string;
-/**
- * Map one GIR type.
- *
- * `where` is not decoration: see the header — an enum in a `prop` accepts nicks
- * and in a `param` never does, and an object in a `prop` accepts null.
- */
-export declare function tsTypeOf(type: GirType, u: Universe, where: 'prop' | 'param'): TsType;
-/** `row-activated` -> `onRowActivated`; `notify` handled by the caller. */
-export declare const eventPropOf: (signal: string) => string;
-/** `can-focus` -> `canFocus`. The inverse of the host's `toPropertyName`. */
-export declare const camelOf: (kebab: string) => string;