@gtkx/codegen 1.1.0 → 1.2.1

package/src/gi.ts

@@ -9,10 +9,11 @@ type GiCodegenOptions = {
     gi: StoreOptions;
     libraries: string[];
     girPath: string[];
+    isByteArrayTyped: boolean;
 };
 
 const runGiCodegen = (library: Library, options: GiCodegenOptions): number => {
-    const { gi, libraries, girPath } = options;
+    const { gi, libraries, girPath, isByteArrayTyped } = options;
 
     const namespaces: GiNamespaceInput[] = Array.from(library.namespaces.values(), (namespace) => ({
         directory: namespaceDirectory(namespace),
@@ -20,7 +21,13 @@ const runGiCodegen = (library: Library, options: GiCodegenOptions): number => {
         girFile: namespace.girFile,
     }));
 
-    const fingerprint = computeGiFingerprint(library.girFiles, [...libraries], [...girPath]);
+    const fingerprint = computeGiFingerprint({
+        girFiles: library.girFiles,
+        libraries: [...libraries],
+        girPath: [...girPath],
+        isByteArrayTyped,
+    });
+
     writeGiStore(gi, namespaces, fingerprint);
 
     return library.namespaces.size;

package/src/gir/class.ts

@@ -11,6 +11,12 @@ type GirVirtualMethod = GirCallable & {
     invoker: string | undefined;
 };
 
+/** A `<glib:signal>` on a class or interface. */
+type GirSignal = GirCallable & {
+    /** Whether the signal takes a `::detail` suffix, so `changed::key` reaches only that detail. */
+    isDetailed: boolean;
+};
+
 /** A `<class>` or `<interface>` declared by a GIR namespace. */
 type GirClass = {
     /** Name GIR gives the type, without its namespace prefix. */
@@ -54,7 +60,7 @@ type GirClass = {
     /** GObject properties the type declares. */
     properties: GirProperty[];
     /** GObject signals the type declares. */
-    signals: GirCallable[];
+    signals: GirSignal[];
     /** Virtual methods the type declares, carrying the documentation their vtable slots are generated from. */
     vfuncs: GirVirtualMethod[];
 };
@@ -88,8 +94,11 @@ const classFromNode = (node: RawNode, isInterface: boolean, context: ParseContex
     constructors: getChildren(node, GIR_CONSTRUCTOR_TAG).map((ctor) => functionFromNode(ctor, context)),
     functions: getChildren(node, "function").map((fn) => functionFromNode(fn, context)),
     properties: getChildren(node, "property").map((property) => propertyFromNode(property, context)),
-    signals: getChildren(node, "glib:signal").map((signal) => parseCallable(signal, context)),
+    signals: getChildren(node, "glib:signal").map((signal) => ({
+        ...parseCallable(signal, context),
+        isDetailed: isAttrTrue(signal, "detailed"),
+    })),
     vfuncs: virtualMethodsFromNode(node, context),
 });
 
-export { classFromNode, type GirClass, type GirVirtualMethod };
+export { classFromNode, type GirClass, type GirSignal, type GirVirtualMethod };

package/src/gir/gir-path.ts

@@ -7,7 +7,7 @@ const SYSTEM_GIR_PATH = "/usr/share/gir-1.0";
 /**
  * The directories to search for `.gir` files, in precedence order: the config's own `girPath`, then
  * `GTKX_GIR_PATH`, then `/usr/share/gir-1.0`, then the girdir pkg-config reports for
- * gobject-introspection-1.0. Duplicates are dropped, and the last two are included only when they exist.
+ * gobject-introspection-1.0. Duplicates are dropped, and the system directories are included only when they exist.
  *
  * @throws If pkg-config is installed but fails while being queried.
  */

package/src/gir/library.ts

@@ -84,10 +84,12 @@ class Library {
      *
      * @param libraries GIR identifiers to load, such as `Gtk-4.0`.
      * @param girPath Directories searched, in order, for each `.gir` file.
+     * @param isByteArrayTyped Whether byte sequences render as `Uint8Array` rather than `number[]`.
      * @returns A library holding every namespace that was parsed.
      */
-    static load(libraries: string[], girPath: string[]): Library {
+    static load(libraries: string[], girPath: string[], isByteArrayTyped = false): Library {
         const library = new Library();
+        library.isByteArrayTypedValue = isByteArrayTyped;
         this.drive(library, libraries, girPath);
 
         return library;
@@ -99,6 +101,7 @@ class Library {
     private nsIdByName: Map<string, number> = new Map();
     private typeTables: TypeTable[] = [];
     private girFilesValue: string[] = [];
+    private isByteArrayTypedValue = false;
 
     /** Creates a library with no namespaces loaded; {@link Library.load} builds a populated one. */
     constructor() {
@@ -328,6 +331,11 @@ class Library {
         return this.namespacesByName;
     }
 
+    /** Whether byte sequences render as `Uint8Array` rather than `number[]`. */
+    public get isByteArrayTyped(): boolean {
+        return this.isByteArrayTypedValue;
+    }
+
     /** Paths of the `.gir` files that were read, in the order they were discovered. */
     public get girFiles(): string[] {
         return this.girFilesValue;

package/src/gir/parse.ts

@@ -5,6 +5,11 @@ type RawNode = Record<string, unknown>;
 
 const GIR_LABEL = "GIR file";
 
+const GIR_MALFORMED_REMEDY =
+    "No XML parser can read this file, so report it to whoever ships it. To get past it now, name the " +
+    "libraries you need explicitly in `libraries` and leave this one out, or put a corrected copy of the " +
+    "file in a directory listed in `girPath`, which is searched ahead of the system location.";
+
 const MULTI_TAGS: Set<string> = new Set([
     "include",
     "class",
@@ -44,7 +49,7 @@ function renameReservedTag(tag: string): string {
 }
 
 const parseGirFile = (path: string): RawNode =>
-    parseXmlFile({ parser: PARSER, label: GIR_LABEL, path }) as RawNode;
+    parseXmlFile({ parser: PARSER, label: GIR_LABEL, path, malformedRemedy: GIR_MALFORMED_REMEDY }) as RawNode;
 
 const attr = (node: RawNode | undefined, name: string): string | undefined => {
     if (node === undefined) {

package/src/gir/primitives.ts

@@ -110,7 +110,7 @@ const PRIMITIVE_TS_TYPE: Record<PrimitiveCategory, string> = {
     float64: "number",
     string: "string",
     unichar: "string",
-    pointer: "number",
+    pointer: "bigint",
 };
 
 const primitiveCategory = (name: string): PrimitiveCategory | undefined => PRIMITIVE_BY_NAME.get(name);

package/src/khronos/args.ts

@@ -2,6 +2,7 @@ import { toCamelIdentifier } from "@gtkx/utils";
 import type { GlCommand, GlParam } from "./model.js";
 import type { CommandPlan, GlScalar, ParamPlan, ReturnPlan } from "./plan.js";
 import {
+    type ArrayLayout,
     tArray,
     tBoolean,
     tBuffer,
@@ -50,6 +51,7 @@ type BuildArgOptions = {
 };
 
 const OUT_PLAN_KINDS: Set<string> = new Set(["ref-out", "ref-array-out", "ref-fixed-out", "string-out"]);
+const NUMERIC_LAYOUT: ArrayLayout = { isBytes: false };
 
 const scalarAliasOrGroup = (scalar: GlScalar, group: string | undefined): string =>
     group !== undefined && scalar.isGroupBearing === true ? group : scalar.tsAlias;
@@ -122,12 +124,13 @@ const buildInArg = (options: BuildArgOptions, name: string, track: (alias: strin
             return inArg(name, "string", tString("borrowed"));
         }
         case "string-array-in": {
-            return inArg(name, "string[]", tArray(tString("borrowed")));
+            return inArg(name, "string[]", tArray(tString("borrowed"), undefined, NUMERIC_LAYOUT));
         }
         case "array-in": {
             track(scalarAliasOrGroup(plan.scalar, param.group));
+            const descriptor = tArray(plan.scalar.descriptor, undefined, NUMERIC_LAYOUT);
 
-            return inArg(name, arrayInTsType(plan.scalar, param.group), tArray(plan.scalar.descriptor));
+            return inArg(name, arrayInTsType(plan.scalar, param.group), descriptor);
         }
         case "buffer": {
             return inArg(name, `ArrayBufferView | ${track("GLintptr")} | null`, tBuffer);
@@ -136,7 +139,7 @@ const buildInArg = (options: BuildArgOptions, name: string, track: (alias: strin
             return inArg(name, track("GLintptr"), tUint64);
         }
         case "byte-offset-array": {
-            return inArg(name, `${track("GLintptr")}[]`, tArray(tUint64));
+            return inArg(name, `${track("GLintptr")}[]`, tArray(tUint64, undefined, NUMERIC_LAYOUT));
         }
         case "ref-array-out":
         case "ref-fixed-out":
@@ -165,14 +168,14 @@ const outArgFields = (options: OutArgFieldsOptions): OutArgFields => {
             return {
                 seed: `const ${cellName} = { value: new Array<number>(${lenIdentifier}).fill(0) };`,
                 tsType: `${track(scalarAliasOrGroup(plan.scalar, param.group))}[]`,
-                descriptor: tRef(tSizedArray(plan.scalar.descriptor, sizeIndex)),
+                descriptor: tRef(tSizedArray(plan.scalar.descriptor, sizeIndex, undefined, NUMERIC_LAYOUT)),
             };
         }
         case "ref-fixed-out": {
             return {
                 seed: `const ${cellName} = { value: new Array<number>(${String(plan.length)}).fill(0) };`,
                 tsType: `${track(plan.scalar.tsAlias)}[]`,
-                descriptor: tRef(tFixedArray(plan.scalar.descriptor, plan.length)),
+                descriptor: tRef(tFixedArray(plan.scalar.descriptor, plan.length, undefined, NUMERIC_LAYOUT)),
             };
         }
         case "string-out": {
@@ -204,7 +207,7 @@ const buildOutArg = (options: BuildArgOptions, track: (alias: string) => string)
         throw new Error(`Parameter index ${String(index)} out of range on ${command.name}`);
     }
 
-    const cellName = `out${String(outIndex)}`;
+    const cellName = `__out${String(outIndex)}`;
     const cell: OutArgCell = { isOut: true, cellName, paramIndex: index };
 
     return { ...cell, ...outArgFields({ command, plan, param, cellName, track }) };

package/src/khronos/render.ts

@@ -114,7 +114,7 @@ const returnStatements = (call: string, returned: EmittedReturn, outs: OutArg[])
         return [`${call};`, tail];
     }
 
-    return [`const result = ${call};`, `return [${returned.expr("result")}, ${outValues.join(", ")}];`];
+    return [`const __result = ${call};`, `return [${returned.expr("__result")}, ${outValues.join(", ")}];`];
 };
 
 const renderCommand = (
@@ -135,7 +135,7 @@ const renderCommand = (
     const seeds = outs.map((out) => out.seed);
     const bindExpression = glBind(command.name, descriptors, returned.descriptor);
     const isInline = plan.params.some((paramPlan) => paramPlan.kind === "string-out");
-    const bindingName = isInline ? "binding" : toCamelIdentifier(command.name);
+    const bindingName = isInline ? "__binding" : toCamelIdentifier(command.name);
 
     const body = [
         ...seeds,
@@ -252,12 +252,14 @@ const deriveGenSingular = (
     const descriptors = [...prefix.map((arg) => arg.descriptor), countScalar.descriptor, tRef(outScalar.descriptor)];
     usedTypes.add(outScalar.tsAlias);
     const signature = prefix.map((arg) => `${arg.name}: ${arg.tsType}`).join(", ");
-    const callArgs = [...prefix.map((arg) => arg.name), "1", "out"].join(", ");
+    const callArgs = [...prefix.map((arg) => arg.name), "1", "__out"].join(", ");
     const jsDoc = genSingularJsDoc({ plan, provenance, docs }, prefix, shape);
 
-    const body = ["    const out = { value: 0 };", `    ${bindingName}(${callArgs});`, "    return out.value;"].join(
-        "\n",
-    );
+    const body = [
+        "    const __out = { value: 0 };",
+        `    ${bindingName}(${callArgs});`,
+        "    return __out.value;",
+    ].join("\n");
 
     const binding = glBind(plan.command.name, renderDescriptorList(descriptors), tVoid);
 

package/src/runner.ts

@@ -39,6 +39,8 @@ type CodegenRunnerOptions = {
     userOmittedProps?: OmittedProps;
     /** Regenerates both stores even when their fingerprints are fresh. */
     isForced?: boolean;
+    /** Emits GIR byte sequences as `Uint8Array` rather than `number[]`; defaults to false. */
+    isByteArrayTyped?: boolean;
 };
 
 /** What a `runCodegen` run produced. */
@@ -157,12 +159,14 @@ const emitStoresWithConfig = async (config: {
     girPath: string[];
 }): Promise<StoreResult> => {
     const { options, gi, jsx, libraries, girPath } = config;
+    const isByteArrayTyped = options.isByteArrayTyped === true;
     let library: Library | undefined;
-    const loadLibrary = (): Library => (library ??= Library.load(libraries, girPath));
-    const isGiRegenerated = options.isForced === true || !isGiStoreFresh(gi.storeDir, libraries, girPath);
+    const loadLibrary = (): Library => (library ??= Library.load(libraries, girPath, isByteArrayTyped));
+    const giInputs = { girFiles: [] as string[], libraries, girPath, isByteArrayTyped };
+    const isGiRegenerated = options.isForced === true || !isGiStoreFresh(gi.storeDir, giInputs);
 
     const namespaces = isGiRegenerated
-        ? runGiCodegen(loadLibrary(), { gi, libraries, girPath })
+        ? runGiCodegen(loadLibrary(), { gi, libraries, girPath, isByteArrayTyped })
         : 0;
 
     if (jsx === undefined) {

package/src/staging.ts

@@ -1,12 +1,10 @@
+import { errorCode } from "@gtkx/utils";
 import { mkdirSync, mkdtempSync, readdirSync, rmSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 
 const STAGING_SUFFIX = ".tmp-";
 const OWNER_PATTERN = /^(?<pid>\d+)-/;
 
-const errorCode = (error: unknown): string | undefined =>
-    error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : undefined;
-
 const isOwnerRunning = (pid: number): boolean => {
     if (!Number.isSafeInteger(pid) || pid <= 0) {
         return false;

package/src/store/compile-store.ts

@@ -1,52 +1,19 @@
-import { rmSync, writeFileSync } from "node:fs";
+import { rmSync } from "node:fs";
 import { join } from "node:path";
-import { compileProject, type ProjectFile, type SourceModule } from "../compile.js";
+import { emitModules, type SourceModule } from "../compile.js";
 
 type CompileStoreParams = {
     storeDir: string;
     files: SourceModule[];
     packageName: string;
-    requiresEnvReference?: boolean;
-};
-
-const EMIT_OPTIONS = {
-    declaration: true,
-    removeComments: false,
-    sourceMap: false,
-    declarationMap: false,
-    rootDir: ".",
-    outDir: ".",
-};
-
-const ENV_REFERENCE_FILE = "__gtkx-env__.d.ts";
-
-const writeEnvReference = (storeDir: string): (() => void) => {
-    writeFileSync(join(storeDir, ENV_REFERENCE_FILE), "/// <reference types=\"@gtkx/react/env\" />\n");
-
-    return () => {
-        rmSync(join(storeDir, ENV_REFERENCE_FILE), { force: true });
-    };
 };
 
 const compileStore = (params: CompileStoreParams): void => {
-    const removeEnvReference = params.requiresEnvReference === true
-        ? writeEnvReference(params.storeDir)
-        : (): void => undefined;
-
-    const files: ProjectFile[] = params.requiresEnvReference === true
-        ? [{ fileName: ENV_REFERENCE_FILE }, ...params.files]
-        : params.files;
-
-    try {
-        compileProject({
-            projectDir: params.storeDir,
-            files,
-            compilerOptions: EMIT_OPTIONS,
-            label: `the generated ${params.packageName} store`,
-        });
-    } finally {
-        removeEnvReference();
-    }
+    emitModules({
+        projectDir: params.storeDir,
+        files: params.files,
+        label: `the generated ${params.packageName} store`,
+    });
 
     for (const file of params.files) {
         rmSync(join(params.storeDir, file.fileName), { force: true });

package/src/store/gi/callables.ts

@@ -7,7 +7,7 @@ import { renderBlock } from "../../writer/emit.js";
 import { matchAsyncFinish } from "./async.js";
 import { callableDoc, callableSpec } from "./callable-doc.js";
 import { renderFnExpression } from "./function.js";
-import { gtypeMemberDeclaration } from "./gtype-binding.js";
+import { gtypeMemberDeclaration, gtypeStaticMember } from "./gtype-binding.js";
 import {
     finishCallExpression,
     memberName,
@@ -66,9 +66,18 @@ type PlainTypeMembersOptions = {
     context: ModuleContext;
     className: string;
     callables: Callables;
-    hasGtype: boolean;
+    gtypeExpr: string | undefined;
 };
 
+const RUNTIME_OWNED_LIFETIME_METHODS: Set<string> = new Set([
+    "force_floating",
+    "free",
+    "ref",
+    "ref_sink",
+    "take_ref",
+    "unref",
+]);
+
 const renderInstanceMethodSignature: InstanceMemberRenderer = instanceMemberRenderer(
     (context, callable, { name, finishFn }) =>
         `${memberDoc(context, callable, finishFn)}${memberSignatureText(context, callable, name, { finishFn })};`,
@@ -373,6 +382,7 @@ const isEmittableCallable = (context: ModuleContext, callable: GirFunction): boo
     callable.introspectable &&
     callable.shadowedBy === undefined &&
     callable.cIdentifier !== undefined &&
+    !RUNTIME_OWNED_LIFETIME_METHODS.has(callable.name) &&
     !hasUnmarshalableParam(context, callable);
 
 const constructorMemberName = (girName: string): string | undefined => {
@@ -408,6 +418,20 @@ const renderStaticSignature = (
     };
 };
 
+const staticMemberName = (
+    context: ModuleContext,
+    callable: GirFunction,
+    resolveName: (girName: string) => string | undefined,
+): string | undefined => {
+    if (!isEmittableCallable(context, callable)) {
+        return undefined;
+    }
+
+    const name = resolveName(callable.name);
+
+    return name !== undefined && isEmittableMemberName(name) ? name : undefined;
+};
+
 const collectStaticMembers = (
     context: ModuleContext,
     group: GirFunction[],
@@ -416,7 +440,7 @@ const collectStaticMembers = (
     const members: StaticMember[] = [];
 
     for (const callable of group) {
-        const name = isEmittableCallable(context, callable) ? resolveName(callable.name) : undefined;
+        const name = staticMemberName(context, callable, resolveName);
 
         if (name !== undefined) {
             members.push({ callable, name });
@@ -427,13 +451,10 @@ const collectStaticMembers = (
 };
 
 const staticMembers = (context: ModuleContext, callables: Callables): StaticMember[] => [
-    ...collectStaticMembers(context, callables.constructors, constructorMemberName),
+    ...collectStaticMembers(context, callables.constructors, memberName),
     ...collectStaticMembers(context, callables.functions, memberName),
 ];
 
-const constructorMemberNames = (context: ModuleContext, constructors: GirFunction[]): string[] =>
-    collectStaticMembers(context, constructors, constructorMemberName).map((member) => member.name);
-
 const collectStaticEntries = (
     context: ModuleContext,
     group: GirFunction[],
@@ -493,11 +514,11 @@ const renderPlainInstanceMethods = (
 const renderPlainTypeMembers = (
     options: PlainTypeMembersOptions,
 ): { members: string[]; claimedNames: Set<string> } => {
-    const { context, className, callables, hasGtype } = options;
+    const { context, className, callables, gtypeExpr } = options;
     const claimedNames: Set<string> = new Set();
 
     const members: string[] = [
-        ...(hasGtype ? [gtypeMemberDeclaration(context)] : []),
+        ...(gtypeExpr === undefined ? [] : [gtypeMemberDeclaration(context), gtypeStaticMember(context)]),
         ...renderStaticHead(context, callables, className),
         ...renderPlainInstanceMethods(context, callables.methods, claimedNames),
     ];
@@ -513,10 +534,8 @@ export {
     dedupeCallables,
     generateBindings,
     matchStaticFinishFunction,
-    indexMethodsByName,
     isEmittableCallable,
     renderStaticSignature,
-    constructorMemberNames,
     renderStaticHead,
     renderPlainTypeMembers,
     staticMembers,

package/src/store/gi/class.ts

@@ -11,10 +11,12 @@ import {
     type InheritedMethods,
 } from "../../analysis/inheritance.js";
 import {
+    areCallablesAssignable,
     type ClaimedMembers,
     claimInterfaceMembers,
     inheritedMembers,
     interfaceConflicts,
+    omittedKeys,
     omittedTypeRef,
 } from "../../analysis/interface-conflicts.js";
 import { ancestorChain, getParentRef, type ResolvedAncestor } from "../../gir/ancestry.js";
@@ -22,17 +24,17 @@ import { isEmittableEntity } from "../../gir/emittable.js";
 import { indentMembers } from "../../writer/emit.js";
 import {
     type Callables,
-    constructorMemberNames,
     dedupeCallables,
     generateBindings,
     type InstanceScope,
     instanceScope,
     renderClassInstanceMember,
     renderStaticHead,
+    staticMembers,
 } from "./callables.js";
 import { renderClassConstructor, renderConstructorPropsInterface } from "./constructor-props.js";
 import { getDoc } from "./doc-spec.js";
-import { gtypeMemberDeclaration, renderSourceGtype } from "./gtype-binding.js";
+import { gtypeMemberDeclaration, gtypeStaticMember, renderSourceGtype } from "./gtype-binding.js";
 import { methodExportName } from "./method.js";
 import { renderPropertyDeclarations } from "./properties.js";
 import { renderResolvedPropertyAccessor, resolveAccessor, type ResolvedAccessor } from "./property-accessor.js";
@@ -58,6 +60,14 @@ type MemberDeclarationsOptions = {
 
 type ClassMembers = { members: string[]; accessors: ResolvedAccessor[] };
 
+type ClassMembersOptions = {
+    context: ModuleContext;
+    klass: GirClass;
+    callables: Callables;
+    gtypeExpr: string | undefined;
+    hasParent: boolean;
+};
+
 type ImplementedRefOptions = {
     context: ModuleContext;
     klass: GirClass;
@@ -91,11 +101,20 @@ const generateClass = (context: ModuleContext, klass: GirClass): void => {
 
     generateBindings(context, callables);
     const parentExpression = resolveParent(context, klass);
-    const extendsClause = renderExtendsClause(context, parentExpression, callables);
+    const extendsClause = renderExtendsClause(context, parentExpression, klass, callables);
     const implemented = resolveImplementedRefs(context, klass);
     const typeRefs = implemented.map((ref) => omittedTypeRef(ref.typeRef, ref.conflicts));
     const implementsClause = typeRefs.length === 0 ? "" : ` implements ${typeRefs.join(", ")}`;
-    const { members, accessors } = renderClassMembers(context, klass, callables, parentExpression !== undefined);
+    const gtypeExpr = renderSourceGtype(context, klass);
+
+    const { members, accessors } = renderClassMembers({
+        context,
+        klass,
+        callables,
+        gtypeExpr,
+        hasParent: parentExpression !== undefined,
+    });
+
     const body = indentMembers(members);
     const doc = getDoc(klass);
     const modifier = klass.isAbstract ? "abstract " : "";
@@ -113,7 +132,7 @@ const generateClass = (context: ModuleContext, klass: GirClass): void => {
 
     appendMemberDeclarations({ context, klass, className, accessors, implemented });
     appendInstallMixins(context, className, implemented);
-    appendClassRegistrations(context, klass, className);
+    appendClassRegistrations(context, klass, className, gtypeExpr);
 };
 
 const appendMemberDeclarations = (options: MemberDeclarationsOptions): void => {
@@ -148,15 +167,14 @@ const appendInterfaceMerge = (
     });
 };
 
-const renderClassMembers = (
-    context: ModuleContext,
-    klass: GirClass,
-    callables: Callables,
-    hasParent: boolean,
-): ClassMembers => {
+const renderClassMembers = (options: ClassMembersOptions): ClassMembers => {
+    const { context, klass, callables, gtypeExpr } = options;
     const className = sanitizeTypeIdentifier(klass.name);
-    const members: string[] = [gtypeMemberDeclaration(context)];
-    const constructorBlock = renderClassConstructor(context, klass, className, hasParent);
+
+    const members: string[] =
+        gtypeExpr === undefined ? [] : [gtypeMemberDeclaration(context), gtypeStaticMember(context)];
+
+    const constructorBlock = renderClassConstructor(context, klass, className, options.hasParent);
 
     if (constructorBlock !== undefined) {
         members.push(constructorBlock);
@@ -189,7 +207,6 @@ const renderClassMembers = (
             context,
             property,
             claimedNames,
-            methodByName: scope.methodByName,
             inheritedTypes,
             inheritedNames,
         });
@@ -238,9 +255,12 @@ const appendInstallMixins = (context: ModuleContext, className: string, implemen
     ]);
 };
 
-const appendClassRegistrations = (context: ModuleContext, klass: GirClass, className: string): void => {
-    const gtypeExpr = renderSourceGtype(context, klass);
-
+const appendClassRegistrations = (
+    context: ModuleContext,
+    klass: GirClass,
+    className: string,
+    gtypeExpr: string | undefined,
+): void => {
     appendWrapperClassRegistration(context, {
         className,
         gtypeExpr,
@@ -336,25 +356,80 @@ const resolveImplementedRefs = (context: ModuleContext, klass: GirClass): Implem
     return refs;
 };
 
+const classCallables = (klass: GirClass): Callables => ({
+    constructors: klass.constructors,
+    functions: klass.functions,
+    methods: klass.methods,
+});
+
+const resolveParentClass = (context: ModuleContext, klass: GirClass): ResolvedAncestor | undefined => {
+    const parent = getParentRef(klass);
+
+    if (parent === undefined) {
+        return undefined;
+    }
+
+    const resolved = context.library.resolveType(parent.namespaceName ?? context.namespace.name, parent.typeName);
+
+    return resolved?.kind === "class" ? { klass: resolved.value, namespaceName: resolved.namespace.name } : undefined;
+};
+
+const addAncestorStatics = (context: ModuleContext, klass: GirClass, table: Map<string, GirFunction>): void => {
+    const members = staticMembers(context, classCallables(klass));
+
+    for (const member of members) {
+        if (!table.has(member.name)) {
+            table.set(member.name, member.callable);
+        }
+    }
+};
+
+const inheritedStatics = (context: ModuleContext, klass: GirClass): Map<string, GirFunction> => {
+    const table: Map<string, GirFunction> = new Map();
+    const parent = resolveParentClass(context, klass);
+
+    if (parent === undefined) {
+        return table;
+    }
+
+    for (const ancestor of ancestorChain(context.library, parent.klass, parent.namespaceName)) {
+        addAncestorStatics(context, ancestor.klass, table);
+    }
+
+    return table;
+};
+
+const shadowedStaticNames = (context: ModuleContext, klass: GirClass, callables: Callables): string[] => {
+    const inherited = inheritedStatics(context, klass);
+
+    return staticMembers(context, callables)
+        .filter((member) => {
+            const shadowed = inherited.get(member.name);
+
+            return shadowed !== undefined && !areCallablesAssignable(context.library, member.callable, shadowed);
+        })
+        .map((member) => member.name);
+};
+
 const renderExtendsClause = (
     context: ModuleContext,
     parentExpression: string | undefined,
+    klass: GirClass,
     callables: Callables,
 ): string => {
     if (parentExpression === undefined) {
         return "";
     }
 
-    const constructorNames = constructorMemberNames(context, callables.constructors);
+    const staticNames = shadowedStaticNames(context, klass, callables);
 
-    if (constructorNames.length === 0) {
+    if (staticNames.length === 0) {
         return ` extends ${parentExpression}`;
     }
 
     context.addRuntimeTypeImport("StaticBase");
-    const omitted = constructorNames.map((name) => JSON.stringify(name)).join(" | ");
 
-    return ` extends (${parentExpression} as StaticBase<typeof ${parentExpression}, ${omitted}>)`;
+    return ` extends (${parentExpression} as StaticBase<typeof ${parentExpression}, ${omittedKeys(staticNames)}>)`;
 };
 
 const resolveParent = (context: ModuleContext, klass: GirClass): string | undefined => {

package/src/store/gi/constant.ts

@@ -7,7 +7,7 @@ import { isEmittableEntity } from "../../gir/emittable.js";
 import { getDoc } from "./doc-spec.js";
 
 const TRUE_VALUES: Set<string> = new Set(["true", "1"]);
-const BIGINT_CATEGORIES: Set<PrimitiveCategory> = new Set(["bigint64", "biguint64", "gtype"]);
+const BIGINT_CATEGORIES: Set<PrimitiveCategory> = new Set(["bigint64", "biguint64", "gtype", "pointer"]);
 
 const generateConstant = (context: ModuleContext, constant: GirConstant): void => {
     if (!isEmittableEntity(constant)) {