@gtkx/codegen 0.21.0 → 1.0.0-rc.2

package/src/dsl/emit.ts

@@ -1,42 +0,0 @@
-/**
- * Tiny string-builder helpers used by the writers to assemble TypeScript
- * source. The DSL deliberately stops short of modelling expressions or
- * statements — writers compose strings directly using these primitives.
- */
-
-/**
- * Indents each line of `block` by `level` four-space units.
- *
- * Lines that are empty stay empty (no trailing whitespace).
- *
- * @param block - The multi-line source fragment
- * @param level - Number of indentation steps to apply
- */
-export const indent = (block: string, level: number): string => {
-    if (level <= 0) return block;
-    const prefix = "    ".repeat(level);
-    return block
-        .split("\n")
-        .map((line) => (line.length === 0 ? line : `${prefix}${line}`))
-        .join("\n");
-};
-
-/**
- * Joins `parts` with commas, dropping `undefined` entries.
- */
-export const joinArgs = (parts: ReadonlyArray<string | undefined>): string =>
-    parts.filter((part): part is string => part !== undefined).join(", ");
-
-/**
- * Renders an array literal multi-line, indenting each element four spaces
- * and adding a trailing comma.
- *
- * Empty input renders as `[]`.
- *
- * @param elements - Already-rendered element expressions
- */
-export const arrayLiteral = (elements: readonly string[]): string => {
-    if (elements.length === 0) return "[]";
-    const lines = elements.map((element) => `    ${element},`);
-    return `[\n${lines.join("\n")}\n]`;
-};

package/src/dsl/identifier.ts

@@ -1,52 +0,0 @@
-import { toCamelCase, toIdentifier } from "@gtkx/utils";
-
-/**
- * Derives the public camelCase export name for a namespace-level callable.
- *
- * The GIR `name` attribute is camelCased (`quark_from_string` →
- * `quarkFromString`); for a shadowing function it is the shadowed short name,
- * so `g_idle_add_full` (which shadows `idle_add`) exports as `idleAdd`. When the
- * `name` is empty the C identifier is used instead, with the namespace's
- * `c:symbol-prefixes` value stripped (e.g. `g_` from `g_quark_from_string`).
- * The result is escaped so it never collides with a reserved word.
- *
- * @param cIdentifier - The C symbol identifier from GIR
- * @param girName - The GIR `name` attribute (shadow-resolved)
- * @param symbolPrefixes - The namespace's `c:symbol-prefixes` values
- */
-export const namespaceFunctionExportName = (
-    cIdentifier: string,
-    girName: string,
-    symbolPrefixes: readonly string[],
-): string => {
-    if (girName.length > 0) {
-        return toIdentifier(toCamelCase(girName));
-    }
-    const stripped = stripLongestPrefix(cIdentifier, symbolPrefixes);
-    return toIdentifier(toCamelCase(stripped));
-};
-
-/**
- * Derives the exported identifier for a GIR `<alias>`.
- *
- * Aliases are surfaced under their GIR `name` (e.g. `Quark`, `Pid`,
- * `Allocation`), matching the `@girs` convention. GObject's `Type` alias is the
- * one exception: it is published as `GType` so it lines up with the GObject
- * runtime's `GType` type and the references that resolve through it.
- *
- * @param namespaceName - The namespace the alias is declared in
- * @param aliasName - The alias's GIR `name`
- */
-export const aliasExportName = (namespaceName: string, aliasName: string): string =>
-    namespaceName === "GObject" && aliasName === "Type" ? "GType" : aliasName;
-
-const stripLongestPrefix = (input: string, prefixes: readonly string[]): string => {
-    let best = "";
-    for (const prefix of prefixes) {
-        const candidate = `${prefix}_`;
-        if (input.startsWith(candidate) && candidate.length > best.length) {
-            best = candidate;
-        }
-    }
-    return best.length === 0 ? input : input.slice(best.length);
-};

package/src/dsl/imports.ts

@@ -1,109 +0,0 @@
-import { quote } from "@gtkx/utils";
-
-/**
- * Tracks imports for a single generated module.
- *
- * The DSL is intentionally tiny: it covers what is awkward to do with
- * string concatenation (deduplicating named imports, sorting them, mixing
- * side-effect and named imports from the same specifier) and leaves
- * everything else to raw TS strings the writers compose themselves.
- */
-export class ImportsBuilder {
-    private readonly named = new Map<string, Map<string, boolean>>();
-    private readonly defaultNames = new Map<string, string>();
-    private readonly namespaces = new Map<string, string>();
-    private readonly sideEffects = new Set<string>();
-
-    /**
-     * Records a named import: `import { foo, bar } from "lib"`.
-     *
-     * Repeated calls deduplicate; the final emit alphabetises within the
-     * braces. A name is emitted with the inline `type` modifier only when
-     * every recording of it is type-only — a single value import of the same
-     * name keeps it a value import.
-     *
-     * @param specifier - The module specifier (e.g. `"@gtkx/ffi"`)
-     * @param name - The identifier to import
-     * @param isType - Whether this recording is type-only (`import { type X }`)
-     */
-    addNamed(specifier: string, name: string, isType = false): void {
-        let bucket = this.named.get(specifier);
-        if (bucket === undefined) {
-            bucket = new Map();
-            this.named.set(specifier, bucket);
-        }
-        bucket.set(name, (bucket.get(name) ?? true) && isType);
-    }
-
-    /**
-     * Records a namespace import: `import * as Alias from "lib"`.
-     *
-     * The first call wins if a different alias is reused for the same
-     * specifier.
-     *
-     * @param specifier - The module specifier
-     * @param alias - The local alias bound by the import
-     */
-    addNamespace(specifier: string, alias: string): void {
-        if (!this.namespaces.has(specifier)) {
-            this.namespaces.set(specifier, alias);
-        }
-    }
-
-    /**
-     * Records a default import: `import Alias from "lib"`. Subsequent calls
-     * with a different alias are ignored.
-     *
-     * @param specifier - The module specifier
-     * @param alias - The local name bound to the default export
-     */
-    addDefault(specifier: string, alias: string): void {
-        if (!this.defaultNames.has(specifier)) {
-            this.defaultNames.set(specifier, alias);
-        }
-    }
-
-    /**
-     * Records a side-effect-only import: `import "lib"`.
-     *
-     * @param specifier - The module specifier
-     */
-    addSideEffect(specifier: string): void {
-        this.sideEffects.add(specifier);
-    }
-
-    /**
-     * Renders all imports as a single string ending with a trailing
-     * newline. Side-effect imports come first (in insertion order),
-     * followed by named/namespace/default imports sorted by specifier.
-     */
-    toSource(): string {
-        const lines: string[] = [];
-        for (const specifier of this.sideEffects) {
-            lines.push(`import ${quote(specifier)};`);
-        }
-        const specifiers = new Set<string>([
-            ...this.named.keys(),
-            ...this.namespaces.keys(),
-            ...this.defaultNames.keys(),
-        ]);
-        const sortedSpecifiers = [...specifiers].sort((a, b) => a.localeCompare(b));
-        for (const specifier of sortedSpecifiers) {
-            const defaultAlias = this.defaultNames.get(specifier);
-            const namespaceAlias = this.namespaces.get(specifier);
-            const namedNames = this.named.get(specifier);
-            const parts: string[] = [];
-            if (defaultAlias !== undefined) parts.push(defaultAlias);
-            if (namespaceAlias !== undefined) parts.push(`* as ${namespaceAlias}`);
-            if (namedNames !== undefined && namedNames.size > 0) {
-                const sortedNames = [...namedNames.entries()]
-                    .sort(([a], [b]) => a.localeCompare(b))
-                    .map(([name, isType]) => (isType ? `type ${name}` : name));
-                parts.push(`{ ${sortedNames.join(", ")} }`);
-            }
-            if (parts.length === 0) continue;
-            lines.push(`import ${parts.join(", ")} from ${quote(specifier)};`);
-        }
-        return lines.length === 0 ? "" : `${lines.join("\n")}\n`;
-    }
-}

package/src/dsl/module.ts

@@ -1,75 +0,0 @@
-import { ImportsBuilder } from "./imports.js";
-
-/**
- * Accumulator for one generated TypeScript module's source.
- *
- * Writers append code in three logical phases:
- *
- * 1. *Bindings* — the `const fn_name = t.fn(...)` block at the top.
- * 2. *Declarations* — the class bodies, free function exports, enums,
- *    constants.
- * 3. *Registrations* — the trailing `registerNativeClass(...)` block.
- *
- * Keeping the three buckets independent removes ordering constraints
- * between writers and lets {@link emit} stitch a final source string with
- * the same shape every generated file uses today.
- */
-export class ModuleBuilder {
-    /** Imports manifest the writers feed into. */
-    public readonly imports = new ImportsBuilder();
-    private readonly bindings: string[] = [];
-    private readonly bindingNames = new Set<string>();
-    private readonly declarations: string[] = [];
-    private readonly registrations: string[] = [];
-
-    /**
-     * Appends a top-level FFI binding (`const foo = t.fn(...)`).
-     *
-     * Duplicates are dropped when a `name` is supplied that matches a
-     * previously appended binding; this is the common case for GIR
-     * callables that appear both as a namespace function and as a
-     * constructor or static on a class.
-     *
-     * @param code - The source fragment, without a trailing newline
-     * @param name - Optional binding identifier used for deduplication
-     */
-    appendBinding(code: string, name?: string): void {
-        if (name !== undefined) {
-            if (this.bindingNames.has(name)) return;
-            this.bindingNames.add(name);
-        }
-        this.bindings.push(code);
-    }
-
-    /**
-     * Appends a declaration (class, function, enum, constant).
-     *
-     * @param code - The source fragment, without a trailing newline
-     */
-    appendDeclaration(code: string): void {
-        this.declarations.push(code);
-    }
-
-    /**
-     * Appends a trailing registration statement (`registerNativeClass(…)`).
-     *
-     * @param code - The source fragment, without a trailing newline
-     */
-    appendRegistration(code: string): void {
-        this.registrations.push(code);
-    }
-
-    /**
-     * Renders the full TypeScript source: imports, bindings, declarations,
-     * registrations — separated by a single blank line.
-     */
-    toSource(): string {
-        const sections: string[] = [];
-        const importsBlock = this.imports.toSource();
-        if (importsBlock.length > 0) sections.push(importsBlock.trimEnd());
-        if (this.bindings.length > 0) sections.push(this.bindings.join("\n\n"));
-        if (this.declarations.length > 0) sections.push(this.declarations.join("\n\n"));
-        if (this.registrations.length > 0) sections.push(this.registrations.join("\n\n"));
-        return `${sections.join("\n\n")}\n`;
-    }
-}

package/src/ffi/pipeline.ts

@@ -1,113 +0,0 @@
-import { ModuleContext } from "../dsl/context.js";
-import type { GirClass } from "../gir/class.js";
-import type { GirNamespace } from "../gir/namespace.js";
-import type { GirRepository } from "../gir/repository.js";
-import { emitAlias } from "../writers/alias.js";
-import { emitBoxed } from "../writers/boxed.js";
-import { emitCallback } from "../writers/callback.js";
-import { emitClass } from "../writers/class.js";
-import { emitConstant } from "../writers/constant.js";
-import { emitEnum } from "../writers/enum.js";
-import { emitNamespaceBootstrap, emitNamespaceFunction } from "../writers/function.js";
-import { emitInterface } from "../writers/interface.js";
-
-/**
- * Generates the TypeScript source for one FFI namespace module.
- *
- * Walks the namespace's declared enums, boxeds, classes, interfaces,
- * callbacks, functions, constants, and aliases, dispatching to the
- * per-construct writers in `writers/`: bindings first, declarations second,
- * registrations trailing.
- *
- * @param namespace - The namespace to emit
- * @param repository - The full repository (for cross-namespace lookups)
- * @returns The relative output path and the TypeScript source string
- */
-export const generateNamespaceModule = (
-    namespace: GirNamespace,
-    repository: GirRepository,
-): { readonly path: string; readonly source: string } => {
-    const context = new ModuleContext(namespace, repository);
-    context.addGObjectBootstrapImports();
-
-    for (const enumeration of namespace.enums) {
-        emitEnum(context, enumeration);
-    }
-    for (const boxed of namespace.boxeds) {
-        emitBoxed(context, boxed);
-    }
-    for (const klass of topologicalClassOrder(namespace.classes, namespace.name)) {
-        emitClass(context, klass);
-    }
-    for (const iface of namespace.interfaces) {
-        emitInterface(context, iface);
-    }
-    for (const callback of namespace.callbacks) {
-        emitCallback(context, callback);
-    }
-    for (const fn of namespace.functions) {
-        emitNamespaceFunction(context, fn);
-    }
-    emitNamespaceBootstrap(context, namespace);
-    for (const constant of namespace.constants) {
-        emitConstant(context, constant);
-    }
-    for (const alias of namespace.aliases) {
-        emitAlias(context, alias);
-    }
-
-    const directory = namespace.name.toLowerCase();
-    return {
-        path: `${directory}/${directory}.ts`,
-        source: context.module.toSource(),
-    };
-};
-
-/**
- * Returns the namespace's classes ordered so each class is preceded by every
- * same-namespace ancestor it extends.
- *
- * Generated JS classes use `extends`, which is a runtime reference: a child
- * class declaration that names its parent before the parent's class body runs
- * hits a temporal dead-zone error. GIR file order is source order, which does
- * not match the inheritance order for namespaces where a leaf type (e.g.
- * `GObject.Binding`) is declared earlier in the file than its base (e.g.
- * `GObject.Object`). The codegen sorts by inheritance instead.
- *
- * Cross-namespace parents are imported by the writer and do not participate in
- * the sort.
- *
- * @param classes - The classes to order
- * @param namespaceName - The namespace these classes live in
- */
-const topologicalClassOrder = (classes: readonly GirClass[], namespaceName: string): readonly GirClass[] => {
-    const byLocalName = new Map<string, GirClass>();
-    for (const klass of classes) byLocalName.set(klass.name, klass);
-    const result: GirClass[] = [];
-    const placed = new Set<GirClass>();
-    const visiting = new Set<GirClass>();
-    const visit = (klass: GirClass): void => {
-        if (placed.has(klass)) return;
-        if (visiting.has(klass)) return;
-        visiting.add(klass);
-        const parent = sameNamespaceParent(klass, namespaceName, byLocalName);
-        if (parent !== undefined) visit(parent);
-        visiting.delete(klass);
-        placed.add(klass);
-        result.push(klass);
-    };
-    for (const klass of classes) visit(klass);
-    return result;
-};
-
-const sameNamespaceParent = (
-    klass: GirClass,
-    namespaceName: string,
-    byLocalName: ReadonlyMap<string, GirClass>,
-): GirClass | undefined => {
-    if (klass.parent === undefined) return undefined;
-    const dot = klass.parent.indexOf(".");
-    if (dot === -1) return byLocalName.get(klass.parent);
-    if (klass.parent.slice(0, dot) !== namespaceName) return undefined;
-    return byLocalName.get(klass.parent.slice(dot + 1));
-};

package/src/gi-store.ts

@@ -1,199 +0,0 @@
-import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { type CodegenFingerprint, FINGERPRINT_FILENAME } from "./fingerprint.js";
-import { type StoreOptions, writeStore } from "./store-fs.js";
-import { transpileSource } from "./transpile.js";
-import { type StoreSourceFile, typecheckGiStore } from "./typecheck-store.js";
-
-/**
- * Absolute path to the hand-written augment overlay shipped with `@gtkx/codegen`.
- *
- * Resolves the same way whether codegen runs from `src/` (tsx) or `dist/`,
- * since `overlay/` sits at the package root next to both.
- */
-const OVERLAY_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..", "overlay");
-
-/**
- * Options for assembling the injected `@gtkx/gi` package.
- */
-export type GiStoreOptions = StoreOptions & {
-    /** Real (symlink-resolved) directory of the installed `@gtkx/ffi`. */
-    readonly realFfiDir: string;
-    /** Real (symlink-resolved) directory of the installed `@gtkx/native`. */
-    readonly realNativeDir: string;
-};
-
-/** Per-namespace inputs the store assembler turns into gi modules. */
-export type GiNamespaceInput = {
-    /** Lowercased namespace directory name (e.g. `"gtk"`). */
-    readonly directory: string;
-    /** Transpilable raw module source, or `null` for augment-only namespaces (gl). */
-    readonly rawSource: string | null;
-};
-
-/** Returns the augment `.ts` files for a namespace, or `[]` when it is pure pass-through. */
-const overlayFiles = (directory: string): readonly string[] => {
-    const dir = join(OVERLAY_ROOT, directory);
-    if (!existsSync(dir)) return [];
-    return readdirSync(dir).filter((name) => name.endsWith(".ts") && name !== "index.ts");
-};
-
-const isAugmented = (directory: string): boolean => existsSync(join(OVERLAY_ROOT, directory, "index.ts"));
-
-/**
- * Whether an augmented namespace's barrel re-exports a generated module (and so
- * may only be emitted when that namespace is generated), as opposed to a
- * standalone overlay like `gl` that has no GIR backing.
- */
-const barrelNeedsGenerated = (directory: string): boolean =>
-    readFileSync(join(OVERLAY_ROOT, directory, "index.ts"), "utf8").includes("../generated/");
-
-/**
- * Retargets a barrel-template specifier from its source layout (under
- * `overlay/<ns>/`) to its emitted layout (under `gi/<ns>/`): the namespace's
- * own generated module becomes a sibling, augment files move under `augment/`,
- * and relative runtime modules collapse to the `@gtkx/ffi` barrel. The
- * `@gtkx/native` specifier passes through so low-level primitives resolve
- * straight to the native package.
- */
-const retargetBarrelSpecifier = (spec: string, directory: string): string => {
-    const generated = spec.match(/^\.\.\/generated\/[a-z0-9]+\/([a-z0-9]+)\.js$/);
-    if (generated) return `./${generated[1]}.js`;
-    if (spec.startsWith("../")) return "@gtkx/ffi";
-    const sibling = spec.match(/^\.\/([a-z0-9-]+)\.js$/);
-    if (sibling) {
-        return existsSync(join(OVERLAY_ROOT, directory, `${sibling[1]}.ts`))
-            ? `./augment/${sibling[1]}.js`
-            : "@gtkx/ffi";
-    }
-    return spec;
-};
-
-const barrelSource = (directory: string): string => {
-    if (!isAugmented(directory)) {
-        return `export * from "./${directory}.js";\n`;
-    }
-    const template = readFileSync(join(OVERLAY_ROOT, directory, "index.ts"), "utf8");
-    return template.replace(/"([^"]+)"/g, (_match, spec) => `"${retargetBarrelSpecifier(spec, directory)}"`);
-};
-
-type CollectedFile = {
-    readonly stem: string;
-    readonly fileName: string;
-    readonly source: string;
-    readonly overlay: boolean;
-};
-
-/**
- * Gathers the per-namespace generated module, augment overlay, and barrel
- * sources into a flat file list, building the package `exports` map alongside.
- */
-const collectStoreSources = (
-    directories: ReadonlySet<string>,
-    standaloneSet: ReadonlySet<string>,
-    rawByDirectory: ReadonlyMap<string, string | null>,
-): { collected: CollectedFile[]; exportsMap: Record<string, unknown> } => {
-    const exportsMap: Record<string, unknown> = { "./package.json": "./package.json" };
-    const collected: CollectedFile[] = [];
-    for (const directory of directories) {
-        const rawSource = standaloneSet.has(directory) ? null : (rawByDirectory.get(directory) ?? null);
-        if (rawSource !== null) {
-            collected.push({
-                stem: `${directory}/${directory}`,
-                fileName: `${directory}/${directory}.ts`,
-                source: rawSource,
-                overlay: false,
-            });
-            exportsMap[`./${directory}/${directory}.js`] = {
-                types: `./${directory}/${directory}.d.ts`,
-                default: `./${directory}/${directory}.js`,
-            };
-        }
-        for (const file of overlayFiles(directory)) {
-            collected.push({
-                stem: `${directory}/augment/${file.slice(0, -".ts".length)}`,
-                fileName: `${directory}/augment/${file}`,
-                source: readFileSync(join(OVERLAY_ROOT, directory, file), "utf8"),
-                overlay: true,
-            });
-        }
-        collected.push({
-            stem: `${directory}/index`,
-            fileName: `${directory}/index.ts`,
-            source: barrelSource(directory),
-            overlay: false,
-        });
-        exportsMap[`./${directory}`] = {
-            types: `./${directory}/index.d.ts`,
-            default: `./${directory}/index.js`,
-        };
-    }
-    return { collected, exportsMap };
-};
-
-/**
- * Assembles the self-contained injected `@gtkx/gi` package.
- *
- * Writes every namespace's raw generated module, its augment overlay, and its
- * barrel into a temporary store, emits the `package.json` and gi's own
- * `node_modules/@gtkx/{ffi,gi}` symlinks — the self-referential `@gtkx/gi` link
- * lets augment modules resolve sibling namespaces without relying on the
- * project's top-level alias — swaps it into place, and points the visible
- * `node_modules/@gtkx/gi` alias at it.
- *
- * @param options - Resolved store/link/dependency paths
- * @param namespaces - Per-namespace raw module inputs
- * @param fingerprint - Staleness sentinel written into the store, when provided
- */
-export const writeGiStore = (
-    options: GiStoreOptions,
-    namespaces: readonly GiNamespaceInput[],
-    fingerprint?: CodegenFingerprint,
-): void => {
-    const standaloneOverlays = readdirSync(OVERLAY_ROOT).filter(
-        (name) => isAugmented(name) && !barrelNeedsGenerated(name),
-    );
-    const standaloneSet = new Set(standaloneOverlays);
-    const directories = new Set<string>([...namespaces.map((n) => n.directory), ...standaloneOverlays]);
-    const rawByDirectory = new Map(namespaces.map((n) => [n.directory, n.rawSource]));
-
-    const { collected, exportsMap } = collectStoreSources(directories, standaloneSet, rawByDirectory);
-
-    writeStore({
-        storeDir: options.storeDir,
-        linkDir: options.linkDir,
-        files: collected.map((file) => ({ stem: file.stem, fileName: file.fileName, source: file.source })),
-        manifest: {
-            name: "@gtkx/gi",
-            type: "module",
-            version: options.version,
-            sideEffects: true,
-            exports: exportsMap,
-        },
-        rawFiles:
-            fingerprint === undefined
-                ? []
-                : [{ relativePath: FINGERPRINT_FILENAME, content: `${JSON.stringify(fingerprint, null, 2)}\n` }],
-        symlinks: [
-            { segments: ["node_modules", "@gtkx", "ffi"], target: options.realFfiDir },
-            { segments: ["node_modules", "@gtkx", "native"], target: options.realNativeDir },
-            { segments: ["node_modules", "@gtkx", "gi"], target: "self" },
-        ],
-        validate: (tmp) => {
-            const sources: StoreSourceFile[] = collected.map((file) =>
-                file.overlay
-                    ? { path: join(tmp, file.fileName), source: file.source, overlay: true }
-                    : {
-                          path: join(tmp, `${file.stem}.d.ts`),
-                          source: transpileSource(file.fileName, file.source).dts,
-                          overlay: false,
-                      },
-            );
-            typecheckGiStore(tmp, sources, {
-                ffiEntry: join(options.realFfiDir, "src", "index.ts"),
-                nativeEntry: join(options.realNativeDir, "dist", "index.d.ts"),
-            });
-        },
-    });
-};

package/src/gir/boxed.ts

@@ -1,94 +0,0 @@
-import { fieldFromNode, type GirField } from "./field.js";
-import { functionFromNode, type GirFunction } from "./function.js";
-import { attr, attrBool, childrenOf, GIR_CONSTRUCTOR_TAG, type RawNode } from "./parse.js";
-
-/**
- * Discriminator for the different shapes a `<record>` (or `<glib:boxed>`)
- * can take in GIR.
- *
- * - `boxed` — a record with a `glib:get-type`; registers as a GObject boxed.
- * - `plain-struct` — a record without GType; passed by pointer using
- *   `t.struct(ownership)`.
- * - `vtable` — a record carrying `glib:is-gtype-struct-for`; its fields are
- *   function pointers consumed by the class struct registration.
- * - `glib-boxed` — a top-level `<glib:boxed>` element with no struct body.
- */
-export type BoxedKind = "boxed" | "plain-struct" | "vtable" | "glib-boxed";
-
-/** A `<record>`, `<glib:boxed>`, or `<union>` declaration. */
-export type GirBoxed = {
-    readonly kind: BoxedKind;
-    /** Local name inside the namespace (no prefix). */
-    readonly name: string;
-    readonly cType: string | undefined;
-    /** GLib type name (e.g. `"GtkBorder"`); absent on plain structs. */
-    readonly glibTypeName: string | undefined;
-    /** GLib get-type C symbol; absent on plain structs. */
-    readonly glibGetType: string | undefined;
-    /** Class name this record is the vtable for (`glib:is-gtype-struct-for`). */
-    readonly glibIsGTypeStructFor: string | undefined;
-    /** GLib ref/unref/etc. function names on fundamentals. */
-    readonly glibRefFunc: string | undefined;
-    readonly glibUnrefFunc: string | undefined;
-    readonly glibSetValueFunc: string | undefined;
-    readonly glibGetValueFunc: string | undefined;
-    /** `copy-function`/`free-function` — the ref/unref pair for records that are reference-counted rather than g_boxed-copyable. */
-    readonly copyFunc: string | undefined;
-    readonly freeFunc: string | undefined;
-    /** `disguised="1"` — record has no introspectable fields. */
-    readonly disguised: boolean;
-    /** `opaque="1"` — record is opaque to callers. */
-    readonly opaque: boolean;
-    readonly introspectable: boolean;
-    readonly fields: readonly GirField[];
-    readonly methods: readonly GirFunction[];
-    readonly constructors: readonly GirFunction[];
-    readonly functions: readonly GirFunction[];
-    /** `true` when the source element was `<union>` rather than `<record>`. */
-    readonly isUnion: boolean;
-};
-
-/**
- * Builds a {@link GirBoxed} from a `<record>`, `<union>`, or `<glib:boxed>` element.
- *
- * @param node - The XML element
- * @param kind - The kind inferred from element name and attribute set
- * @param isUnion - `true` when the source element was `<union>`
- */
-export const boxedFromNode = (node: RawNode, kind: BoxedKind, isUnion: boolean): GirBoxed => ({
-    kind,
-    name: attr(node, "name") ?? attr(node, "glib:name") ?? "",
-    cType: attr(node, "c:type"),
-    glibTypeName: attr(node, "glib:type-name"),
-    glibGetType: attr(node, "glib:get-type"),
-    glibIsGTypeStructFor: attr(node, "glib:is-gtype-struct-for"),
-    glibRefFunc: attr(node, "glib:ref-func"),
-    glibUnrefFunc: attr(node, "glib:unref-func"),
-    glibSetValueFunc: attr(node, "glib:set-value-func"),
-    glibGetValueFunc: attr(node, "glib:get-value-func"),
-    copyFunc: attr(node, "copy-function"),
-    freeFunc: attr(node, "free-function"),
-    disguised: attrBool(node, "disguised"),
-    opaque: attrBool(node, "opaque"),
-    introspectable: attr(node, "introspectable") !== "0",
-    fields: childrenOf(node, "field").map(fieldFromNode),
-    methods: childrenOf(node, "method").map((method) => functionFromNode(method, "method")),
-    constructors: childrenOf(node, GIR_CONSTRUCTOR_TAG).map((ctor) => functionFromNode(ctor, "constructor")),
-    functions: childrenOf(node, "function").map((function_) => functionFromNode(function_, "function")),
-    isUnion,
-});
-
-/**
- * Decides which {@link BoxedKind} applies to a `<record>` or `<union>` element.
- *
- * Vtable records (`glib:is-gtype-struct-for`) take precedence; otherwise a
- * `glib:get-type` flips the record to a registered boxed; otherwise it's a
- * plain struct.
- *
- * @param node - The `<record>` or `<union>` element
- */
-export const boxedKind = (node: RawNode): BoxedKind => {
-    if (attr(node, "glib:is-gtype-struct-for") !== undefined) return "vtable";
-    if (attr(node, "glib:get-type") !== undefined) return "boxed";
-    return "plain-struct";
-};