@gtkx/ffi 0.9.0 → 0.9.2

package/dist/codegen/ffi-generator.js

@@ -1,4 +1,4 @@
-import { TypeMapper, toCamelCase, toPascalCase } from "@gtkx/gir";
+import { formatDoc as formatDocBase, formatMethodDoc as formatMethodDocBase, sanitizeDoc as sanitizeDocBase, TypeMapper, toCamelCase, toPascalCase, } from "@gtkx/gir";
 import { format } from "prettier";
 const RESERVED_WORDS = new Set([
     "break",
@@ -72,55 +72,6 @@ const toKebabCase = (str) => str
     .replace(/_/g, "-")
     .toLowerCase();
 const toConstantCase = (str) => str.replace(/-/g, "_").toUpperCase();
-const sanitizeDoc = (doc) => {
-    let result = doc;
-    result = result.replace(/<picture>[\s\S]*?<\/picture>/gi, "");
-    result = result.replace(/<img[^>]*>/gi, "");
-    result = result.replace(/<source[^>]*>/gi, "");
-    result = result.replace(/!\[[^\]]*\]\([^)]+\.png\)/gi, "");
-    result = result.replace(/<kbd>([^<]*)<\/kbd>/gi, "`$1`");
-    result = result.replace(/<kbd>/gi, "`");
-    result = result.replace(/<\/kbd>/gi, "`");
-    result = result.replace(/\[([^\]]+)\]\([^)]+\.html[^)]*\)/gi, "$1");
-    result = result.replace(/@(\w+)\s/g, "`$1` ");
-    return result.trim();
-};
-const formatDoc = (doc, indent = "") => {
-    if (!doc)
-        return "";
-    const sanitized = sanitizeDoc(doc);
-    if (!sanitized)
-        return "";
-    const lines = sanitized.split("\n").map((line) => line.trim());
-    const firstLine = lines[0] ?? "";
-    if (lines.length === 1 && firstLine.length < 80) {
-        return `${indent}/** ${firstLine} */\n`;
-    }
-    const formattedLines = lines.map((line) => `${indent} * ${line}`);
-    return `${indent}/**\n${formattedLines.join("\n")}\n${indent} */\n`;
-};
-const formatMethodDoc = (doc, params, indent = "  ") => {
-    const sanitizedDoc = doc ? sanitizeDoc(doc) : undefined;
-    if (!sanitizedDoc && params.every((p) => !p.doc))
-        return "";
-    const lines = [];
-    if (sanitizedDoc) {
-        for (const line of sanitizedDoc.split("\n")) {
-            lines.push(` * ${line.trim()}`);
-        }
-    }
-    for (const param of params) {
-        if (param.doc && param.name && param.name !== "..." && param.name !== "") {
-            const paramName = toValidIdentifier(toCamelCase(param.name));
-            const sanitizedParamDoc = sanitizeDoc(param.doc);
-            const paramDoc = sanitizedParamDoc.split("\n")[0]?.trim() ?? "";
-            lines.push(` * @param ${paramName} - ${paramDoc}`);
-        }
-    }
-    if (lines.length === 0)
-        return "";
-    return `${indent}/**\n${indent}${lines.join(`\n${indent}`)}\n${indent} */\n`;
-};
 const toValidIdentifier = (str) => {
     let result = str.replace(/[^a-zA-Z0-9_$]/g, "_");
     if (RESERVED_WORDS.has(result))
@@ -141,7 +92,7 @@ const normalizeClassName = (name, namespace) => {
 };
 const parseParentReference = (parent, classMap, currentNamespace) => {
     if (!parent) {
-        return { hasParent: false, isCrossNamespace: false, className: "", extendsClause: "" };
+        return { hasParent: false, isCrossNamespace: false, className: "", extendsClause: " extends NativeObject" };
     }
     if (parent.includes(".")) {
         const [ns, className] = parent.split(".", 2);
@@ -190,11 +141,6 @@ const isVararg = (param) => param.name === "..." || param.name === "";
 const hasUnsupportedCallbacks = (params, typeMapper) => {
     return params.some((p) => typeMapper.hasUnsupportedCallback(p));
 };
-/**
- * Generates TypeScript FFI bindings from GIR namespace definitions.
- * Creates classes, methods, properties, and signal handlers that call
- * native GTK functions through the FFI bridge.
- */
 export class CodeGenerator {
     options;
     typeMapper;
@@ -207,10 +153,10 @@ export class CodeGenerator {
     usesWrite = false;
     usesAlloc = false;
     usesNativeError = false;
-    usesGetObject = false;
-    usesGetBoxed = false;
-    usesGetInterface = false;
-    usesRegisterType = false;
+    usesNativeObject = false;
+    usesGetNativeObject = false;
+    usesRegisterNativeClass = false;
+    usesGetClassByTypeName = false;
     usesSignalMeta = false;
     usedEnums = new Set();
     usedRecords = new Set();
@@ -223,10 +169,6 @@ export class CodeGenerator {
     currentSharedLibrary = "";
     cyclicReturnTypes = new Set();
     methodRenames = new Map();
-    /**
-     * Creates a new code generator with the given options.
-     * @param options - Generator configuration
-     */
     constructor(options) {
         this.options = options;
         this.typeMapper = new TypeMapper();
@@ -234,11 +176,21 @@ export class CodeGenerator {
             this.typeMapper.setTypeRegistry(options.typeRegistry, options.namespace);
         }
     }
-    /**
-     * Generates TypeScript files for all types in a GIR namespace.
-     * @param namespace - The parsed GIR namespace
-     * @returns Map of filename to generated TypeScript code
-     */
+    sanitizeDoc(doc) {
+        return sanitizeDocBase(doc, { namespace: this.options.namespace });
+    }
+    formatDoc(doc, indent = "") {
+        return formatDocBase(doc, indent, { namespace: this.options.namespace });
+    }
+    formatMethodDoc(doc, params, indent = "  ") {
+        const formattedParams = params
+            .filter((p) => p.doc && p.name && p.name !== "..." && p.name !== "")
+            .map((p) => ({
+            name: toValidIdentifier(toCamelCase(p.name)),
+            doc: p.doc,
+        }));
+        return formatMethodDocBase(doc, formattedParams, indent, { namespace: this.options.namespace });
+    }
     async generateNamespace(namespace) {
         const files = new Map();
         this.currentSharedLibrary = namespace.sharedLibrary;
@@ -343,10 +295,10 @@ export class CodeGenerator {
         this.usesWrite = false;
         this.usesAlloc = false;
         this.usesNativeError = false;
-        this.usesGetObject = false;
-        this.usesGetBoxed = false;
-        this.usesGetInterface = false;
-        this.usesRegisterType = false;
+        this.usesNativeObject = false;
+        this.usesGetNativeObject = false;
+        this.usesRegisterNativeClass = false;
+        this.usesGetClassByTypeName = false;
         this.usesSignalMeta = false;
         this.usedEnums.clear();
         this.usedRecords.clear();
@@ -454,15 +406,16 @@ export class CodeGenerator {
         }
         sections.push("");
         if (cls.doc) {
-            sections.push(formatDoc(cls.doc));
+            sections.push(this.formatDoc(cls.doc));
         }
         sections.push(`export class ${className}${parentInfo.extendsClause}${implementsClause} {`);
         if (cls.glibTypeName) {
             const override = parentInfo.hasParent ? "override " : "";
-            sections.push(`  static ${override}readonly glibTypeName: string = "${cls.glibTypeName}";\n`);
+            sections.push(`  static ${override}readonly glibTypeName: string = "${cls.glibTypeName}";`);
+            sections.push(`  static ${override}readonly objectType = "gobject" as const;\n`);
         }
         if (!parentInfo.hasParent) {
-            sections.push(`  id: unknown;\n`);
+            this.usesNativeObject = true;
         }
         sections.push(this.generateConstructors(cls, sharedLibrary, parentInfo.hasParent));
         sections.push(this.generateStaticFunctions(cls.functions, sharedLibrary, className));
@@ -479,8 +432,8 @@ export class CodeGenerator {
         }
         sections.push("}");
         if (cls.glibTypeName) {
-            this.usesRegisterType = true;
-            sections.push(`\nregisterType(${className});`);
+            this.usesRegisterNativeClass = true;
+            sections.push(`\nregisterNativeClass(${className});`);
         }
         if (signalMetaConstant) {
             const classDefIndex = sections.findIndex((s) => s.startsWith("export class "));
@@ -682,7 +635,7 @@ export class CodeGenerator {
                 sections.push(`  constructor() {\n    super();\n  }\n`);
             }
             else {
-                sections.push(`  constructor() {\n    this.create();\n  }\n`);
+                sections.push(`  constructor() {\n    super();\n    this.create();\n  }\n`);
                 sections.push(`  protected create() {}\n`);
             }
         }
@@ -690,7 +643,7 @@ export class CodeGenerator {
     }
     generateConstructorWithFlag(ctor, sharedLibrary) {
         this.usesInstantiating = true;
-        const ctorDoc = formatMethodDoc(ctor.doc, ctor.parameters);
+        const ctorDoc = this.formatMethodDoc(ctor.doc, ctor.parameters);
         const params = this.generateParameterList(ctor.parameters);
         const args = this.generateCallArguments(ctor.parameters);
         const docComment = ctorDoc ? `${ctorDoc.trimEnd()}\n` : "";
@@ -756,11 +709,11 @@ ${args ? `${args},` : ""}
         }
         const params = this.generateParameterList(ctor.parameters);
         const args = this.generateCallArguments(ctor.parameters);
-        const ctorDoc = formatMethodDoc(ctor.doc, ctor.parameters);
+        const ctorDoc = this.formatMethodDoc(ctor.doc, ctor.parameters);
         const borrowed = ctor.returnType.transferOwnership !== "full";
         const errorArg = ctor.throws ? this.generateErrorArgument() : "";
         const allArgs = errorArg ? args + (args ? ",\n" : "") + errorArg : args;
-        this.usesGetObject = true;
+        this.usesGetNativeObject = true;
         const lines = [];
         lines.push(`${ctorDoc}  static ${methodName}(${params}): ${className} {`);
         if (ctor.throws) {
@@ -777,7 +730,7 @@ ${allArgs}
         if (ctor.throws) {
             lines.push(this.generateErrorCheck());
         }
-        lines.push(`    return getObject(ptr) as ${className};`);
+        lines.push(`    return getNativeObject(ptr) as ${className};`);
         lines.push(`  }`);
         return `${lines.join("\n")}\n`;
     }
@@ -802,7 +755,7 @@ ${allArgs}
         const hasReturnValue = rawReturnType !== "void";
         const gtkAllocatesRefs = this.identifyGtkAllocatesRefs(func.parameters);
         const lines = [];
-        const funcDoc = formatMethodDoc(func.doc, func.parameters);
+        const funcDoc = this.formatMethodDoc(func.doc, func.parameters);
         if (funcDoc) {
             lines.push(funcDoc.trimEnd());
         }
@@ -814,7 +767,7 @@ ${allArgs}
         const errorArg = func.throws ? this.generateErrorArgument() : "";
         const allArgs = errorArg ? args + (args ? ",\n" : "") + errorArg : args;
         if (returnsOwnClass) {
-            this.usesGetObject = true;
+            this.usesGetNativeObject = true;
             lines.push(`    const ptr = call(
       "${sharedLibrary}",
       "${func.cIdentifier}",
@@ -827,7 +780,7 @@ ${allArgs ? `${allArgs},` : ""}
                 lines.push(this.generateErrorCheck());
             }
             lines.push(...this.generateRefRewrapCode(gtkAllocatesRefs));
-            lines.push(`    return getObject(ptr) as ${className};`);
+            lines.push(`    return getNativeObject(ptr) as ${className};`);
         }
         else {
             const hasRefRewrap = gtkAllocatesRefs.length > 0;
@@ -942,7 +895,7 @@ ${allArgs ? `${allArgs},` : ""}
         lines.push(`  /**`);
         lines.push(`   * Promise-based version of ${methodName}.`);
         if (method.doc) {
-            const docLines = sanitizeDoc(method.doc).split("\n").slice(0, 3);
+            const docLines = this.sanitizeDoc(method.doc).split("\n").slice(0, 3);
             for (const line of docLines) {
                 lines.push(`   * ${line.trim()}`);
             }
@@ -1045,26 +998,19 @@ ${allArgs ? `${allArgs},` : ""}
         }
         if (outputParams.length === 0) {
             if (hasMainReturn) {
-                if (needsBoxedWrap) {
-                    this.usesGetBoxed = true;
+                if (needsBoxedWrap || needsInterfaceWrap) {
+                    this.usesGetNativeObject = true;
                     if (isNullable) {
                         lines.push(`          if (ptr === null) { resolve(null); return; }`);
                     }
-                    lines.push(`          resolve(getBoxed(ptr, ${finishReturnType.ts}));`);
-                }
-                else if (needsInterfaceWrap) {
-                    this.usesGetInterface = true;
-                    if (isNullable) {
-                        lines.push(`          if (ptr === null) { resolve(null); return; }`);
-                    }
-                    lines.push(`          resolve(getInterface(ptr, ${finishReturnType.ts})!);`);
+                    lines.push(`          resolve(getNativeObject(ptr, ${finishReturnType.ts})!);`);
                 }
                 else if (needsGObjectWrap) {
-                    this.usesGetObject = true;
+                    this.usesGetNativeObject = true;
                     if (isNullable) {
                         lines.push(`          if (ptr === null) { resolve(null); return; }`);
                     }
-                    lines.push(`          resolve(getObject(ptr) as ${finishReturnType.ts});`);
+                    lines.push(`          resolve(getNativeObject(ptr) as ${finishReturnType.ts});`);
                 }
                 else {
                     lines.push(`          resolve(result);`);
@@ -1077,31 +1023,22 @@ ${allArgs ? `${allArgs},` : ""}
         else {
             const resolveFields = [];
             if (hasMainReturn) {
-                if (needsBoxedWrap) {
-                    this.usesGetBoxed = true;
+                if (needsBoxedWrap || needsInterfaceWrap) {
+                    this.usesGetNativeObject = true;
                     if (isNullable) {
-                        lines.push(`          const result = ptr === null ? null : getBoxed(ptr, ${finishReturnType.ts});`);
+                        lines.push(`          const result = ptr === null ? null : getNativeObject(ptr, ${finishReturnType.ts})!;`);
                     }
                     else {
-                        lines.push(`          const result = getBoxed(ptr, ${finishReturnType.ts});`);
-                    }
-                }
-                else if (needsInterfaceWrap) {
-                    this.usesGetInterface = true;
-                    if (isNullable) {
-                        lines.push(`          const result = ptr === null ? null : getInterface(ptr, ${finishReturnType.ts});`);
-                    }
-                    else {
-                        lines.push(`          const result = getInterface(ptr, ${finishReturnType.ts})!;`);
+                        lines.push(`          const result = getNativeObject(ptr, ${finishReturnType.ts})!;`);
                     }
                 }
                 else if (needsGObjectWrap) {
-                    this.usesGetObject = true;
+                    this.usesGetNativeObject = true;
                     if (isNullable) {
-                        lines.push(`          const result = (ptr === null ? null : getObject(ptr)) as ${finishReturnType.ts} | null;`);
+                        lines.push(`          const result = (ptr === null ? null : getNativeObject(ptr)) as ${finishReturnType.ts} | null;`);
                     }
                     else {
-                        lines.push(`          const result = getObject(ptr) as ${finishReturnType.ts};`);
+                        lines.push(`          const result = getNativeObject(ptr) as ${finishReturnType.ts};`);
                     }
                 }
                 resolveFields.push("result");
@@ -1191,7 +1128,7 @@ ${allArgs ? `${allArgs},` : ""}
             ? `{ type: "boxed", borrowed: true, innerType: "${className}", lib: "${sharedLibrary}" }`
             : `{ type: "gobject" }`;
         const lines = [];
-        const methodDoc = formatMethodDoc(method.doc, method.parameters);
+        const methodDoc = this.formatMethodDoc(method.doc, method.parameters);
         if (methodDoc) {
             lines.push(methodDoc.trimEnd());
         }
@@ -1226,22 +1163,18 @@ ${allArgs ? `${allArgs},` : ""}
             if (isCyclic) {
                 lines.push(this.generateCyclicTypeReturn(baseReturnType));
             }
-            else if (needsBoxedWrap) {
-                this.usesGetBoxed = true;
-                lines.push(`    return getBoxed(ptr, ${baseReturnType});`);
-            }
-            else if (needsInterfaceWrap) {
-                this.usesGetInterface = true;
-                lines.push(`    return getInterface(ptr, ${baseReturnType})!;`);
+            else if (needsBoxedWrap || needsInterfaceWrap) {
+                this.usesGetNativeObject = true;
+                lines.push(`    return getNativeObject(ptr, ${baseReturnType})!;`);
             }
             else {
-                this.usesGetObject = true;
-                lines.push(`    return getObject(ptr) as ${baseReturnType};`);
+                this.usesGetNativeObject = true;
+                lines.push(`    return getNativeObject(ptr) as ${baseReturnType};`);
             }
         }
         else if (needsArrayWrap && hasReturnValue) {
             const elementType = baseReturnType.slice(0, -2);
-            this.usesGetObject = true;
+            this.usesGetNativeObject = true;
             lines.push(`    const ptrs = call(
       "${sharedLibrary}",
       "${method.cIdentifier}",
@@ -1258,7 +1191,7 @@ ${allArgs ? `${allArgs},` : ""}
                 lines.push(this.generateErrorCheck());
             }
             lines.push(...this.generateRefRewrapCode(gtkAllocatesRefs));
-            lines.push(`    return ptrs.map(ptr => getObject(ptr) as ${elementType});`);
+            lines.push(`    return ptrs.map(ptr => getNativeObject(ptr) as ${elementType});`);
         }
         else {
             const hasRefRewrap = gtkAllocatesRefs.length > 0;
@@ -1328,29 +1261,14 @@ ${allArgs ? `${allArgs},` : ""}
         this.typeMapper.setRecordUsageCallback(null);
         this.typeMapper.setExternalTypeUsageCallback(null);
         this.typeMapper.setSameNamespaceClassUsageCallback(null);
+        let hasBoxedSignalParams = false;
         const signalMetadata = signals.map((signal) => {
             const paramEntries = (signal.parameters ?? []).map((param) => {
-                const ffiType = JSON.stringify(this.typeMapper.mapParameter(param).ffi);
-                const signalParamClass = this.extractSignalParamClass(param, classMap);
-                if (signalParamClass) {
-                    const { transformedName, originalName } = signalParamClass;
-                    const dotIndex = transformedName.indexOf(".");
-                    if (dotIndex !== -1) {
-                        const ns = transformedName.slice(0, dotIndex);
-                        const clsName = transformedName.slice(dotIndex + 1);
-                        this.usedExternalTypes.set(transformedName, {
-                            namespace: ns,
-                            name: originalName,
-                            transformedName: clsName,
-                            kind: "class",
-                        });
-                    }
-                    else {
-                        this.signalClasses.set(transformedName, originalName);
-                    }
-                    return `{ type: ${ffiType}, getCls: () => ${transformedName} }`;
+                const ffiType = this.typeMapper.mapParameter(param).ffi;
+                if (ffiType.type === "boxed") {
+                    hasBoxedSignalParams = true;
                 }
-                return `{ type: ${ffiType} }`;
+                return JSON.stringify(ffiType);
             });
             const returnTypeFfi = signal.returnType
                 ? JSON.stringify(this.typeMapper.mapType(signal.returnType).ffi)
@@ -1373,6 +1291,23 @@ ${allArgs ? `${allArgs},` : ""}
             for (const param of signalParams) {
                 const paramName = toValidIdentifier(toCamelCase(param.name));
                 const signalParamClass = this.extractSignalParamClass(param, classMap);
+                if (signalParamClass) {
+                    const { transformedName, originalName } = signalParamClass;
+                    const dotIndex = transformedName.indexOf(".");
+                    if (dotIndex !== -1) {
+                        const ns = transformedName.slice(0, dotIndex);
+                        const clsName = transformedName.slice(dotIndex + 1);
+                        this.usedExternalTypes.set(transformedName, {
+                            namespace: ns,
+                            name: originalName,
+                            transformedName: clsName,
+                            kind: "class",
+                        });
+                    }
+                    else {
+                        this.signalClasses.set(transformedName, originalName);
+                    }
+                }
                 const paramType = signalParamClass?.transformedName ?? this.typeMapper.mapType(param.type).ts;
                 handlerParams.push(`${paramName}: ${paramType}`);
             }
@@ -1391,32 +1326,42 @@ ${allArgs ? `${allArgs},` : ""}
         }
         this.addSignalCatchAllOverload(signalOverloads, methodName);
         this.usesType = true;
-        this.usesGetObject = true;
+        this.usesGetNativeObject = true;
         if (signalMetadata.length > 0) {
             this.usesSignalMeta = true;
         }
+        if (hasBoxedSignalParams) {
+            this.usesGetClassByTypeName = true;
+        }
         const moduleLevel = signalMetadata.length > 0 ? `const SIGNAL_META: SignalMeta = {\n${signalMetadata.join(",\n")}\n};\n` : "";
         const signalMapCode = signalMetadata.length > 0
             ? `const meta = SIGNAL_META[signal];
     const selfType: Type = { type: "gobject", borrowed: true };
-    const argTypes = meta ? [selfType, ...meta.params.map((m) => m.type)] : [selfType];
+    const argTypes = meta ? [selfType, ...meta.params] : [selfType];
     const returnType = meta?.returnType;`
             : `const selfType: Type = { type: "gobject", borrowed: true };\n    const argTypes = [selfType];\n    const returnType = undefined;`;
+        const boxedHandling = hasBoxedSignalParams
+            ? `
+        if (m.type === "boxed" && signalArgs[i] != null) {
+          const cls = getNativeClass(m.innerType);
+          return cls ? getNativeObject(signalArgs[i], cls) : signalArgs[i];
+        }`
+            : "";
         const wrapperCode = signalMetadata.length > 0
             ? `const wrappedHandler = (...args: unknown[]) => {
-      const self = getObject(args[0]);
+      const self = getNativeObject(args[0]);
       const signalArgs = args.slice(1);
       if (!meta) return handler(self, ...signalArgs);
       const wrapped = meta.params.map((m, i) => {
-        if (m.getCls && signalArgs[i] != null) {
-          return getObject(signalArgs[i]);
-        }
+        if (m.type === "gobject" && signalArgs[i] != null) {
+          return getNativeObject(signalArgs[i]);
+        }${boxedHandling}
         return signalArgs[i];
       });
       return handler(self, ...wrapped);
     };`
             : `const wrappedHandler = (...args: unknown[]) => {
-      const self = getObject(args[0]);
+      const self = getNativeObject(args[0]);
       return handler(self, ...args.slice(1));
     };`;
         const overloadsSection = signalOverloads.length > 0 ? `${signalOverloads.join("\n")}\n` : "";
@@ -1449,21 +1394,14 @@ ${allArgs ? `${allArgs},` : ""}
         this.usesCall = iface.methods.length > 0;
         this.usesRef = iface.methods.some((m) => hasRefParameter(m.parameters, this.typeMapper));
         if (iface.doc) {
-            sections.push(formatDoc(iface.doc));
+            sections.push(this.formatDoc(iface.doc));
         }
-        sections.push(`export class ${interfaceName} {`);
+        this.usesNativeObject = true;
+        sections.push(`export class ${interfaceName} extends NativeObject {`);
         if (iface.glibTypeName) {
-            sections.push(`  static readonly glibTypeName: string = "${iface.glibTypeName}";\n`);
-        }
-        sections.push(`  id: unknown;`);
-        sections.push(``);
-        sections.push(`  protected constructor(id: unknown) {`);
-        sections.push(`    this.id = id;`);
-        sections.push(`  }`);
-        sections.push(``);
-        sections.push(`  static fromPtr(id: unknown): ${interfaceName} {`);
-        sections.push(`    return new ${interfaceName}(id);`);
-        sections.push(`  }`);
+            sections.push(`  static readonly glibTypeName: string = "${iface.glibTypeName}";`);
+            sections.push(`  static readonly objectType = "interface" as const;\n`);
+        }
         if (iface.methods.length > 0) {
             sections.push(this.generateMethods(iface.methods, sharedLibrary, interfaceName));
         }
@@ -1489,13 +1427,14 @@ ${allArgs ? `${allArgs},` : ""}
             sections.push(initInterface);
         }
         if (record.doc) {
-            sections.push(formatDoc(record.doc));
+            sections.push(this.formatDoc(record.doc));
         }
-        sections.push(`export class ${recordName} {`);
+        this.usesNativeObject = true;
+        sections.push(`export class ${recordName} extends NativeObject {`);
         if (record.glibTypeName) {
-            sections.push(`  static readonly glibTypeName: string = "${record.glibTypeName}";\n`);
+            sections.push(`  static readonly glibTypeName: string = "${record.glibTypeName}";`);
+            sections.push(`  static readonly objectType = "boxed" as const;\n`);
         }
-        sections.push(`  id: unknown;\n`);
         sections.push(this.generateRecordConstructors(record, sharedLibrary));
         sections.push(this.generateRecordFromPtr(recordName));
         sections.push(this.generateRecordStaticFunctions(record.functions, sharedLibrary, recordName));
@@ -1503,8 +1442,8 @@ ${allArgs ? `${allArgs},` : ""}
         sections.push(this.generateRecordFields(record.fields, record.methods));
         sections.push("}");
         if (record.glibTypeName) {
-            this.usesRegisterType = true;
-            sections.push(`\nregisterType(${recordName});`);
+            this.usesRegisterNativeClass = true;
+            sections.push(`\nregisterNativeClass(${recordName});`);
         }
         const imports = this.generateImports(recordName);
         return this.formatCode(imports + sections.join("\n"));
@@ -1526,10 +1465,10 @@ ${allArgs ? `${allArgs},` : ""}
         const supportedConstructors = record.constructors.filter((c) => !hasUnsupportedCallbacks(c.parameters, this.typeMapper));
         const mainConstructor = supportedConstructors.find((c) => !c.parameters.some(isVararg));
         if (mainConstructor) {
-            const ctorDoc = formatMethodDoc(mainConstructor.doc, mainConstructor.parameters);
+            const ctorDoc = this.formatMethodDoc(mainConstructor.doc, mainConstructor.parameters);
             const filteredParams = mainConstructor.parameters.filter((p) => !isVararg(p));
             if (filteredParams.length === 0) {
-                sections.push(`${ctorDoc}  constructor() {\n    this.id = this.createPtr([]);\n  }\n`);
+                sections.push(`${ctorDoc}  constructor() {\n    super();\n    this.id = this.createPtr([]);\n  }\n`);
             }
             else {
                 const typedParams = this.generateParameterList(mainConstructor.parameters, false);
@@ -1538,6 +1477,7 @@ ${allArgs ? `${allArgs},` : ""}
                 const isFirstParamArray = firstParamType.endsWith("[]") || firstParamType.startsWith("Array<");
                 if (isFirstParamArray) {
                     sections.push(`${ctorDoc}  constructor(${typedParams}) {
+    super();
     const _args = [${paramNames.join(", ")}];
     this.id = this.createPtr(_args);
   }
@@ -1547,6 +1487,7 @@ ${allArgs ? `${allArgs},` : ""}
                     sections.push(`${ctorDoc}  constructor(${typedParams});
   constructor(_args: unknown[]);
   constructor(...args: unknown[]) {
+    super();
     const _args = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
     this.id = this.createPtr(_args);
   }
@@ -1562,10 +1503,10 @@ ${allArgs ? `${allArgs},` : ""}
         else {
             const initFields = this.getWritableFields(record.fields);
             if (initFields.length > 0) {
-                sections.push(`  constructor(init: ${recordName}Init = {}) {\n    this.id = this.createPtr(init);\n  }\n`);
+                sections.push(`  constructor(init: ${recordName}Init = {}) {\n    super();\n    this.id = this.createPtr(init);\n  }\n`);
             }
             else {
-                sections.push(`  constructor() {\n    this.id = this.createPtr({});\n  }\n`);
+                sections.push(`  constructor() {\n    super();\n    this.id = this.createPtr({});\n  }\n`);
             }
         }
         sections.push(this.generateRecordCreatePtr(record, sharedLibrary));
@@ -1680,8 +1621,8 @@ ${args}
         }
         const params = this.generateParameterList(ctor.parameters);
         const args = this.generateCallArguments(ctor.parameters);
-        const ctorDoc = formatMethodDoc(ctor.doc, ctor.parameters);
-        this.usesGetObject = true;
+        const ctorDoc = this.formatMethodDoc(ctor.doc, ctor.parameters);
+        this.usesGetNativeObject = true;
         return `${ctorDoc}  static ${methodName}(${params}): ${recordName} {
     const ptr = call(
       "${sharedLibrary}",
@@ -1691,7 +1632,7 @@ ${args}
       ],
       { type: "boxed", borrowed: true, innerType: "${recordName}" }
     );
-    return getObject(ptr) as ${recordName};
+    return getNativeObject(ptr) as ${recordName};
   }
 `;
     }
@@ -1727,7 +1668,7 @@ ${args}
                 fieldName = "id_";
             const typeMapping = this.typeMapper.mapType(field.type);
             if (field.doc) {
-                sections.push(formatDoc(field.doc, "  ").trimEnd());
+                sections.push(this.formatDoc(field.doc, "  ").trimEnd());
             }
             if (isReadable) {
                 sections.push(`  get ${fieldName}(): ${typeMapping.ts} {
@@ -1846,7 +1787,7 @@ ${args}
         const hasReturnValue = returnTypeMapping.ts !== "void";
         const gtkAllocatesRefs = this.identifyGtkAllocatesRefs(func.parameters);
         const lines = [];
-        const funcDoc = formatMethodDoc(func.doc, func.parameters, "");
+        const funcDoc = this.formatMethodDoc(func.doc, func.parameters, "");
         if (funcDoc) {
             lines.push(funcDoc.trimEnd());
         }
@@ -1869,17 +1810,13 @@ ${allArgs ? `${allArgs},` : ""}
             if (isNullable) {
                 lines.push(`  if (ptr === null) return null;`);
             }
-            if (needsBoxedWrap) {
-                this.usesGetBoxed = true;
-                lines.push(`  return getBoxed(ptr, ${baseReturnType});`);
-            }
-            else if (needsInterfaceWrap) {
-                this.usesGetInterface = true;
-                lines.push(`  return getInterface(ptr, ${baseReturnType})!;`);
+            if (needsBoxedWrap || needsInterfaceWrap) {
+                this.usesGetNativeObject = true;
+                lines.push(`  return getNativeObject(ptr, ${baseReturnType})!;`);
             }
             else {
-                this.usesGetObject = true;
-                lines.push(`  return getObject(ptr) as ${baseReturnType};`);
+                this.usesGetNativeObject = true;
+                lines.push(`  return getNativeObject(ptr) as ${baseReturnType};`);
             }
         }
         else {
@@ -1914,10 +1851,10 @@ ${allArgs ? `${allArgs},` : ""}
                 let memberName = toConstantCase(member.name);
                 if (/^\d/.test(memberName))
                     memberName = `_${memberName}`;
-                const memberDoc = member.doc ? `${formatDoc(member.doc, "  ").trimEnd()}\n` : "";
+                const memberDoc = member.doc ? `${this.formatDoc(member.doc, "  ").trimEnd()}\n` : "";
                 return `${memberDoc}  ${memberName} = ${member.value},`;
             });
-            const enumDoc = enumeration.doc ? formatDoc(enumeration.doc) : "";
+            const enumDoc = enumeration.doc ? this.formatDoc(enumeration.doc) : "";
             return `${enumDoc}export enum ${enumName} {\n${members.join("\n")}\n}`;
         });
         return this.formatCode(`${sections.join("\n\n")}\n`);
@@ -1933,7 +1870,7 @@ ${allArgs ? `${allArgs},` : ""}
             seen.add(constName);
             const isStringType = constant.type.name === "utf8" || constant.type.name === "filename";
             const constValue = isStringType ? `"${constant.value}"` : constant.value;
-            const constDoc = constant.doc ? formatDoc(constant.doc) : "";
+            const constDoc = constant.doc ? this.formatDoc(constant.doc) : "";
             sections.push(`${constDoc}export const ${constName} = ${constValue};`);
         }
         return this.formatCode(`${sections.join("\n\n")}\n`);
@@ -1952,7 +1889,7 @@ ${allArgs ? `${allArgs},` : ""}
             const mapped = this.typeMapper.mapParameter(param);
             const paramName = toValidIdentifier(toCamelCase(param.name));
             const isOptional = makeAllOptional || this.typeMapper.isNullable(param);
-            const typeStr = isOptional ? `${mapped.ts} | null` : mapped.ts;
+            const typeStr = mapped.ts;
             const paramStr = `${paramName}${isOptional ? "?" : ""}: ${typeStr}`;
             (isOptional ? optional : required).push(paramStr);
         }
@@ -2003,15 +1940,15 @@ ${allArgs ? `${allArgs},` : ""}
         }
         return gtkAllocatesRefs.map((ref) => {
             if (ref.isBoxed) {
-                this.usesGetBoxed = true;
+                this.usesGetNativeObject = true;
                 return ref.nullable
-                    ? `    if (${ref.paramName}) ${ref.paramName}.value = getBoxed(${ref.paramName}.value, ${ref.innerType});`
-                    : `    ${ref.paramName}.value = getBoxed(${ref.paramName}.value, ${ref.innerType});`;
+                    ? `    if (${ref.paramName}) ${ref.paramName}.value = getNativeObject(${ref.paramName}.value, ${ref.innerType})!;`
+                    : `    ${ref.paramName}.value = getNativeObject(${ref.paramName}.value, ${ref.innerType})!;`;
             }
-            this.usesGetObject = true;
+            this.usesGetNativeObject = true;
             return ref.nullable
-                ? `    if (${ref.paramName}) ${ref.paramName}.value = getObject(${ref.paramName}.value) as ${ref.innerType};`
-                : `    ${ref.paramName}.value = getObject(${ref.paramName}.value) as ${ref.innerType};`;
+                ? `    if (${ref.paramName}) ${ref.paramName}.value = getNativeObject(${ref.paramName}.value)! as ${ref.innerType};`
+                : `    ${ref.paramName}.value = getNativeObject(${ref.paramName}.value)! as ${ref.innerType};`;
         });
     }
     generateErrorArgument(indent = "      ") {
@@ -2038,10 +1975,15 @@ ${indent}  }`;
         }
         if (type.type === "boxed") {
             const innerType = typeof type.innerType === "string" ? type.innerType : "";
-            const lib = this.currentSharedLibrary;
-            return type.borrowed
-                ? `{ type: "boxed", borrowed: true, innerType: "${innerType}", lib: "${lib}" }`
-                : `{ type: "boxed", innerType: "${innerType}", lib: "${lib}" }`;
+            const lib = type.lib ?? this.currentSharedLibrary;
+            const parts = [`type: "boxed"`, `innerType: "${innerType}"`, `lib: "${lib}"`];
+            if (type.borrowed) {
+                parts.splice(1, 0, `borrowed: true`);
+            }
+            if (type.getTypeFn) {
+                parts.push(`getTypeFn: "${type.getTypeFn}"`);
+            }
+            return `{ ${parts.join(", ")} }`;
         }
         if (type.type === "ref" && type.innerType && typeof type.innerType !== "string") {
             return `{ type: "ref", innerType: ${this.generateTypeDescriptor(type.innerType)} }`;
@@ -2095,22 +2037,26 @@ ${indent}  }`;
             lines.push(`import { call } from "../../batch.js";`);
         }
         if (this.usesNativeError) {
-            lines.push(`import { NativeError } from "../../native-error.js";`);
-        }
-        const nativeJsImports = [];
-        if (this.usesGetObject)
-            nativeJsImports.push("getObject");
-        if (this.usesGetBoxed)
-            nativeJsImports.push("getBoxed");
-        if (this.usesGetInterface)
-            nativeJsImports.push("getInterface");
-        if (this.usesInstantiating)
-            nativeJsImports.push("isInstantiating", "setInstantiating");
-        if (nativeJsImports.length > 0) {
-            lines.push(`import { ${nativeJsImports.join(", ")} } from "../../native.js";`);
+            lines.push(`import { NativeError } from "../../native/error.js";`);
         }
-        if (this.usesRegisterType) {
-            lines.push(`import { registerType } from "../../registry.js";`);
+        if (this.usesGetNativeObject) {
+            lines.push(`import { getNativeObject } from "../../native/object.js";`);
+        }
+        const baseImports = [];
+        if (this.usesInstantiating)
+            baseImports.push("isInstantiating", "setInstantiating");
+        if (this.usesNativeObject)
+            baseImports.push("NativeObject");
+        if (baseImports.length > 0) {
+            lines.push(`import { ${baseImports.join(", ")} } from "../../native/base.js";`);
+        }
+        const registryImports = [];
+        if (this.usesRegisterNativeClass)
+            registryImports.push("registerNativeClass");
+        if (this.usesGetClassByTypeName)
+            registryImports.push("getNativeClass");
+        if (registryImports.length > 0) {
+            lines.push(`import { ${registryImports.join(", ")} } from "../../registry.js";`);
         }
         if (this.usesSignalMeta) {
             lines.push(`import type { SignalMeta } from "../../types.js";`);
@@ -2196,13 +2142,6 @@ ${indent}  }`;
     generateCyclicTypeReturn(baseReturnType) {
         return `    return { id: ptr } as unknown as ${baseReturnType};`;
     }
-    /**
-     * Adds a catch-all signal handler overload for unknown signal types.
-     *
-     * Uses `any` because TypeScript overload resolution requires the catch-all
-     * signature to be compatible with all typed overloads. Using `unknown` would
-     * prevent passing typed handlers to this overload.
-     */
     addSignalCatchAllOverload(signalOverloads, methodName) {
         signalOverloads.push(`  ${methodName}(signal: string, handler: (...args: any[]) => any, after?: boolean): number;`);
     }