@ts-for-gir/lib 4.0.0-rc.1 → 4.0.0-rc.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ts-for-gir/lib",
-  "version": "4.0.0-rc.1",
+  "version": "4.0.0-rc.12",
   "description": "Typescript .d.ts generator from GIR for gjs",
   "main": "src/index.ts",
   "module": "src/index.ts",
@@ -41,19 +41,19 @@
     "type definitions"
   ],
   "devDependencies": {
-    "@ts-for-gir/tsconfig": "^4.0.0-rc.1",
+    "@ts-for-gir/tsconfig": "^4.0.0-rc.12",
     "@types/ejs": "^3.1.5",
     "@types/lodash": "^4.17.24",
-    "@types/node": "^24.12.2",
+    "@types/node": "^25.6.0",
     "rimraf": "^6.1.3",
-    "typescript": "^6.0.2"
+    "typescript": "^6.0.3"
   },
   "dependencies": {
-    "@gi.ts/parser": "^4.0.0-rc.1",
-    "@ts-for-gir/reporter": "^4.0.0-rc.1",
-    "@ts-for-gir/templates": "^4.0.0-rc.1",
+    "@gi.ts/parser": "^4.0.0-rc.12",
+    "@ts-for-gir/reporter": "^4.0.0-rc.12",
+    "@ts-for-gir/templates": "^4.0.0-rc.12",
     "colorette": "^2.0.20",
-    "ejs": "^5.0.1",
+    "ejs": "^5.0.2",
     "glob": "^13.0.6",
     "lodash": "4.18.1"
   }

package/src/constants.ts

@@ -18,11 +18,18 @@ function getPackageVersion(): string {
 	if (typeof __TS_FOR_GIR_VERSION__ !== "undefined") {
 		return __TS_FOR_GIR_VERSION__;
 	}
-	const currentModulePath = fileURLToPath(import.meta.url);
-	const currentDir = dirname(currentModulePath);
-	const packageJsonPath = join(currentDir, "..", "package.json");
-	const content = readFileSync(packageJsonPath, "utf-8");
-	return (JSON.parse(content) as { version: string }).version;
+	// Dev mode reads the sibling package.json relative to this source file.
+	// Wrapped in try/catch so a bundle missing the __TS_FOR_GIR_VERSION__ define
+	// degrades to a fallback string instead of throwing at module load.
+	try {
+		const currentModulePath = fileURLToPath(import.meta.url);
+		const currentDir = dirname(currentModulePath);
+		const packageJsonPath = join(currentDir, "..", "package.json");
+		const content = readFileSync(packageJsonPath, "utf-8");
+		return (JSON.parse(content) as { version: string }).version;
+	} catch {
+		return "0.0.0-unknown";
+	}
 }
 
 export const APP_NAME = "ts-for-gir";

package/src/dependency-manager.ts

@@ -132,6 +132,15 @@ export class DependencyManager {
 	}
 
 	createImportPath(packageName: string, namespace: string, version: string): string {
+		// In external-deps mode every dep import is resolved against an installed npm package
+		// (e.g. `@girs/glib-2.0`), regardless of `package` mode. User-supplied overrides win
+		// for namespaces with non-default scopes/versions (e.g. `Soup → @girs/soup-3.0`).
+		if (this.config.externalDeps) {
+			const override = this.config.externalPackages?.[namespace];
+			if (override) return override;
+			const importName = transformImportName(packageName);
+			return `${this.config.npmScope}/${importName}`;
+		}
 		if (!this.config.package) {
 			return `gi://${namespace}?version=${version}`;
 		}
@@ -147,13 +156,22 @@ export class DependencyManager {
 	}
 
 	createPackageJsonImport(importPath: string, libraryVersion?: LibraryVersion): string {
+		const pinnedVersion = libraryVersion ? `${libraryVersion.toString()}-${APP_VERSION}` : APP_VERSION;
+		const format = this.config.depVersionFormat ?? (this.config.workspace ? "workspace" : "exact");
 		let depVersion: string;
-		if (this.config.workspace) {
-			depVersion = "workspace:^";
-		} else if (libraryVersion) {
-			depVersion = `${libraryVersion.toString()}-${APP_VERSION}`;
-		} else {
-			depVersion = APP_VERSION;
+		switch (format) {
+			case "workspace":
+				depVersion = "workspace:^";
+				break;
+			case "caret":
+				depVersion = `^${pinnedVersion}`;
+				break;
+			case "any":
+				depVersion = "*";
+				break;
+			default:
+				depVersion = pinnedVersion;
+				break;
 		}
 		return `"${importPath}": "${depVersion}"`;
 	}

package/src/gir/function.ts

@@ -4,7 +4,7 @@ import {
 	ArrayType,
 	ClosureType,
 	type Generic,
-	NullableType,
+	makeNullable,
 	type TypeExpression,
 	TypeIdentifier,
 	UnknownType,
@@ -235,7 +235,10 @@ export class IntrospectedFunction extends IntrospectedNamespaceMember {
 	): IntrospectedFunctionParameter[] {
 		return parameters
 			.filter((_, i) => !length_params.includes(i) && !user_data_params.includes(i))
-			.filter((v) => !(v.type instanceof TypeIdentifier && v.type.is("GLib", "DestroyNotify")));
+			.filter((v) => {
+				const unwrapped = v.type.unwrap();
+				return !(unwrapped instanceof TypeIdentifier && unwrapped.is("GLib", "DestroyNotify"));
+			});
 	}
 
 	private static processOptionalParameters(
@@ -248,9 +251,7 @@ export class IntrospectedFunction extends IntrospectedNamespaceMember {
 					const { type, isOptional } = p;
 
 					if (allowOptions) {
-						if (type instanceof NullableType) {
-							params.push(p.copy({ isOptional: true }));
-						} else if (!isOptional) {
+						if (!isOptional) {
 							params.push(p);
 							return { allowOptions: false, params };
 						} else {
@@ -258,7 +259,7 @@ export class IntrospectedFunction extends IntrospectedNamespaceMember {
 						}
 					} else {
 						if (isOptional) {
-							params.push(p.copy({ type: new NullableType(type), isOptional: false }));
+							params.push(p.copy({ type: makeNullable(type), isOptional: false }));
 						} else {
 							params.push(p);
 						}

package/src/gir/introspected-classes.ts

@@ -5,6 +5,8 @@ import {
 	Generic,
 	GenericType,
 	GenerifiedTypeIdentifier,
+	makeNullable,
+	NullableType,
 	type TypeExpression,
 	TypeIdentifier,
 	UnknownType,
@@ -47,6 +49,40 @@ import { IntrospectedSignal } from "./signal.ts";
 
 const log = new ConsoleReporter(true, "gir/introspected-classes", true);
 
+/**
+ * Walks the implementing class's `extends` chain (skipping the prerequisite class
+ * itself) and reports whether any ancestor *shadows* a member by declaring its
+ * own member of the given name. A shadow indicates the parent chain has
+ * overridden the prerequisite's member with a possibly incompatible type, which
+ * would otherwise leave the implementing class unable to satisfy the
+ * interface's contract.
+ */
+function hasExtendsShadowOf(cls: IntrospectedBaseClass, prerequisite: IntrospectedBaseClass, name: string): boolean {
+	let current = cls.resolveParents().extends();
+	while (current) {
+		const node = current.node;
+		if (node !== prerequisite) {
+			const hasOwn = [...node.props, ...node.fields, ...node.members].some((m) => m.name === name);
+			if (hasOwn) return true;
+		}
+		current = current.extends();
+	}
+	return false;
+}
+
+function resolveNullableProperties(cls: IntrospectedBaseClass): void {
+	for (const prop of cls.props) {
+		if (prop.type instanceof NullableType) continue;
+
+		const getterName = prop.getter ?? `get_${prop.name}`;
+		const getter = cls.members.find((m) => m.name === getterName && !(m instanceof IntrospectedStaticClassFunction));
+
+		if (getter instanceof IntrospectedClassFunction && getter.return() instanceof NullableType) {
+			prop.type = makeNullable(prop.type);
+		}
+	}
+}
+
 /**
  * Represents a signal with metadata
  */
@@ -75,6 +111,8 @@ export class IntrospectedClassFunction<
 	returnTypeDoc?: string | null;
 	/** If this function was generated from a signal, stores the signal name. */
 	signalOrigin?: string;
+	/** GIR glib:finish-func attribute: name of the function that finishes this async operation. */
+	finishFuncName?: string;
 
 	generics: Generic[] = [];
 
@@ -143,6 +181,7 @@ export class IntrospectedClassFunction<
 
 		fn.generics = [...this.generics];
 		fn.returnTypeDoc = this.returnTypeDoc;
+		fn.finishFuncName = this.finishFuncName;
 
 		if (interfaceParent) {
 			fn.interfaceParent = interfaceParent;
@@ -177,6 +216,10 @@ export class IntrospectedClassFunction<
 		// Convert the function to a class function
 		const { raw_name: name, output_parameters, parameters, return_type, doc, isIntrospectable } = fn;
 
+		// A function with shadowed-by is superseded by the shadowing function (which uses `shadows`)
+		// and takes the original name. Do not emit the shadowed function to avoid duplicate declarations.
+		const isShadowedBy = element.$["shadowed-by"] != null;
+
 		const classFn = new IntrospectedClassFunction({
 			parent,
 			name,
@@ -184,11 +227,12 @@ export class IntrospectedClassFunction<
 			parameters,
 			return_type,
 			doc,
-			isIntrospectable,
+			isIntrospectable: isIntrospectable && !isShadowedBy,
 		});
 
 		classFn.returnTypeDoc = fn.returnTypeDoc;
 		classFn.generics = [...fn.generics];
+		classFn.finishFuncName = element.$["glib:finish-func"];
 
 		return classFn;
 	}
@@ -396,6 +440,8 @@ export class IntrospectedStaticClassFunction extends IntrospectedClassFunction {
 		// Convert the function to a static class function
 		const { raw_name: name, output_parameters, parameters, return_type, doc, isIntrospectable } = fn;
 
+		const isShadowedBy = m.$["shadowed-by"] != null;
+
 		return new IntrospectedStaticClassFunction({
 			parent,
 			name,
@@ -403,7 +449,7 @@ export class IntrospectedStaticClassFunction extends IntrospectedClassFunction {
 			parameters,
 			return_type,
 			doc,
-			isIntrospectable,
+			isIntrospectable: isIntrospectable && !isShadowedBy,
 		});
 	}
 }
@@ -853,13 +899,19 @@ export class IntrospectedClass extends IntrospectedBaseClass {
 			});
 		}
 
-		// If an interface inherits from a class (such as Gtk.Widget)
-		// we need to pull in every item from that class...
+		// An interface's <prerequisite> of class type is always satisfied by the
+		// implementing class's actual parent chain — those members are already
+		// inherited via TS class inheritance, so we don't re-emit them. The one
+		// case we still need to handle: when the parent chain has a same-named
+		// member with an incompatible signature/type, we re-emit the interface's
+		// version so `filterConflicts` / `filterFunctionConflict` can broaden or
+		// override it to satisfy both `extends` and `implements` simultaneously.
 		for (const implemented of resolution.implements()) {
 			const extended = implemented.extends();
 			if (extended?.node instanceof IntrospectedClass) {
 				for (const item of getItems(extended.node)) {
 					if (items.has(item.name) || !validate(item)) continue;
+					if (!hasExtendsShadowOf(this, extended.node, item.name)) continue;
 					items.set(item.name, item);
 				}
 			}
@@ -1036,6 +1088,7 @@ export class IntrospectedClass extends IntrospectedBaseClass {
 		IntrospectedClass.parseBasicProperties(element, clazz, ns, options);
 		IntrospectedClass.parseResolveNames(element, clazz, ns, name);
 		IntrospectedClass.parseInheritanceAndMembers(element, clazz, ns, options);
+		resolveNullableProperties(clazz);
 
 		return clazz;
 	}
@@ -1342,6 +1395,7 @@ export class IntrospectedInterface extends IntrospectedBaseClass {
 		IntrospectedInterface.parseInterfaceBasicProperties(element, iface, namespace, options);
 		IntrospectedInterface.parseInterfaceResolveNames(element, iface, namespace, name);
 		IntrospectedInterface.parseInterfaceMembers(element, iface, namespace, options);
+		resolveNullableProperties(iface);
 
 		return iface;
 	}

package/src/gir/promisify.ts

@@ -62,6 +62,11 @@ function findFinishMethodInClass(cls: IntrospectedBaseClass, node: IntrospectedC
 			? [...cls.constructors, ...cls.members.filter((m) => m instanceof IntrospectedStaticClassFunction)]
 			: [...cls.members.filter((m) => !(m instanceof IntrospectedStaticClassFunction))];
 
+	// Prefer the GIR-specified finish function name over name heuristics
+	if (node.finishFuncName) {
+		return members.find((m) => m.name === node.finishFuncName);
+	}
+
 	return members.find(
 		(m) => m.name === `${node.name.replace(/_async$/, "")}_finish` || m.name === `${node.name}_finish`,
 	);

package/src/gir/property.ts

@@ -1,5 +1,5 @@
 import type { FormatGenerator } from "../generators/generator.ts";
-import type { TypeExpression } from "../gir.ts";
+import { makeNullable, type TypeExpression } from "../gir.ts";
 import type { GirFieldElement, GirPropertyElement } from "../index.ts";
 import type { OptionsLoad } from "../types/index.ts";
 import type { Options } from "../types/introspected.ts";
@@ -98,6 +98,10 @@ export class IntrospectedProperty extends IntrospectedBase<IntrospectedEnum | In
 	readonly writable: boolean = false;
 	readonly readable: boolean = true;
 	readonly constructOnly: boolean;
+	/** GIR default-value attribute: the default value of the property as a string. */
+	defaultValue?: string;
+	/** GIR getter attribute: name of the getter method for this property (used for nullable inference). */
+	getter?: string;
 
 	get namespace() {
 		return this.parent.namespace;
@@ -110,7 +114,7 @@ export class IntrospectedProperty extends IntrospectedBase<IntrospectedEnum | In
 	}): IntrospectedProperty {
 		const { name, writable, readable, type, constructOnly, parent } = this;
 
-		return new IntrospectedProperty({
+		const prop = new IntrospectedProperty({
 			name: options?.name ?? name,
 			writable,
 			readable,
@@ -118,6 +122,9 @@ export class IntrospectedProperty extends IntrospectedBase<IntrospectedEnum | In
 			constructOnly,
 			parent: options?.parent ?? parent,
 		})._copyBaseProperties(this);
+		prop.defaultValue = this.defaultValue;
+		prop.getter = this.getter;
+		return prop;
 	}
 
 	accept(visitor: GirVisitor): IntrospectedProperty {
@@ -198,6 +205,14 @@ export class IntrospectedProperty extends IntrospectedBase<IntrospectedEnum | In
 			property.metadata = parseMetadata(element);
 		}
 
+		property.defaultValue = element.$["default-value"];
+
+		property.getter = element.$.getter;
+
+		if (element.$.nullable === "1" || element.$["allow-none"] === "1") {
+			property.type = makeNullable(property.type);
+		}
+
 		return property;
 	}
 }

package/src/gir/registry.ts

@@ -8,7 +8,6 @@ import { inject } from "../injections/inject.ts";
 import type { GeneratorConstructor, OptionsGeneration, OptionsTransform } from "../types/index.ts";
 import { TwoKeyMap } from "../util.ts";
 import { ClassVisitor } from "../validators/class.ts";
-import { FunctionParametersVisitor } from "../validators/function-parameters.ts";
 import { InterfaceVisitor } from "../validators/interface.ts";
 import type { GirVisitor } from "../visitor.ts";
 import type { IntrospectedNamespace } from "./namespace.ts";
@@ -104,28 +103,33 @@ export class NSRegistry {
 	}
 
 	transform(options: OptionsTransform) {
-		const GLib = this.assertNamespace("GLib", "2.0");
-		const Gio = this.assertNamespace("Gio", "2.0");
-		const GObject = this.assertNamespace("GObject", "2.0");
+		// In tolerant external-deps mode (with --allow-missing-deps) the core namespaces
+		// may not be loaded. Sync their package_version only when actually present;
+		// generify/inject still run on whatever IS loaded (other modules' transformations
+		// don't depend on GLib being in the registry).
+		const GLib = this.namespace("GLib", "2.0");
+		const Gio = this.namespace("Gio", "2.0");
+		const GObject = this.namespace("GObject", "2.0");
 
 		// These follow the GLib version.
-		Gio.package_version = [...GLib.package_version];
-		GObject.package_version = [...GLib.package_version];
+		if (GLib && Gio) Gio.package_version = [...GLib.package_version];
+		if (GLib && GObject) GObject.package_version = [...GLib.package_version];
 
 		const interfaceVisitor = new InterfaceVisitor();
+
 		this.registerTransformation(interfaceVisitor);
 
 		const classVisitor = new ClassVisitor();
-		this.registerTransformation(classVisitor);
 
-		const enumParamsVisitor = new FunctionParametersVisitor();
-		this.registerTransformation(enumParamsVisitor);
+		this.registerTransformation(classVisitor);
 
-		console.log("Adding generics...");
-		generify(this, options.inferGenerics);
+		if (GLib && Gio) {
+			console.log("Adding generics...");
+			generify(this, options.inferGenerics);
 
-		console.log("Injecting types...");
-		inject(this);
+			console.log("Injecting types...");
+			inject(this);
+		}
 	}
 
 	defaultVersionOf(name: string): string | null {

package/src/gir/signal.ts

@@ -3,6 +3,7 @@ import { GirDirection } from "@gi.ts/parser";
 import type { FormatGenerator } from "../generators/generator.ts";
 import {
 	ArrayType,
+	makeNullable,
 	NativeType,
 	NullableType,
 	NumberType,
@@ -171,7 +172,7 @@ export class IntrospectedSignal extends IntrospectedClassMember<IntrospectedClas
 						}
 					} else {
 						if (isOptional) {
-							params.push(p.copy({ type: new NullableType(type), isOptional: false }));
+							params.push(p.copy({ type: makeNullable(type), isOptional: false }));
 						} else {
 							params.push(p);
 						}

package/src/gir.ts

@@ -23,7 +23,7 @@ export enum ConflictType {
 
 import { type ConsoleReporter, LazyReporter } from "@ts-for-gir/reporter";
 import type { IntrospectedField, IntrospectedProperty } from "./gir/property.ts";
-import type { OptionsBase } from "./types/index.ts";
+import type { OptionsGeneration } from "./types/index.ts";
 import { isInvalid, sanitizeIdentifierName, sanitizeNamespace } from "./utils/naming.ts";
 
 export abstract class TypeExpression {
@@ -37,10 +37,10 @@ export abstract class TypeExpression {
 	}
 
 	abstract rewrap(type: TypeExpression): TypeExpression;
-	abstract resolve(namespace: IntrospectedNamespace, options: OptionsBase): TypeExpression;
+	abstract resolve(namespace: IntrospectedNamespace, options: OptionsGeneration): TypeExpression;
 
-	abstract print(namespace: IntrospectedNamespace, options: OptionsBase): string;
-	rootPrint(namespace: IntrospectedNamespace, options: OptionsBase): string {
+	abstract print(namespace: IntrospectedNamespace, options: OptionsGeneration): string;
+	rootPrint(namespace: IntrospectedNamespace, options: OptionsGeneration): string {
 		return this.print(namespace, options);
 	}
 }
@@ -89,7 +89,7 @@ export class TypeIdentifier extends TypeExpression {
 		return new TypeIdentifier(sanitizeIdentifierName(this.namespace, this.name), sanitizeNamespace(this.namespace));
 	}
 
-	protected _resolve(namespace: IntrospectedNamespace, options: OptionsBase): TypeIdentifier | null {
+	protected _resolve(namespace: IntrospectedNamespace, options: OptionsGeneration): TypeIdentifier | null {
 		const name: string = sanitizeIdentifierName(null, this.name);
 		const unresolvedNamespaceName = this.namespace;
 
@@ -183,11 +183,11 @@ export class TypeIdentifier extends TypeExpression {
 		return null;
 	}
 
-	resolveIdentifier(namespace: IntrospectedNamespace, options: OptionsBase): TypeIdentifier | null {
+	resolveIdentifier(namespace: IntrospectedNamespace, options: OptionsGeneration): TypeIdentifier | null {
 		return this._resolve(namespace, options);
 	}
 
-	resolve(namespace: IntrospectedNamespace, options: OptionsBase): TypeExpression {
+	resolve(namespace: IntrospectedNamespace, options: OptionsGeneration): TypeExpression {
 		const resolved = this._resolve(namespace, options);
 
 		// Generally if we can't resolve a type it is not introspectable,
@@ -199,7 +199,7 @@ export class TypeIdentifier extends TypeExpression {
 		return new TypeIdentifier(name, namespace);
 	}
 
-	print(namespace: IntrospectedNamespace, _options: OptionsBase): string {
+	print(namespace: IntrospectedNamespace, _options: OptionsGeneration): string {
 		if (namespace.hasSymbol(this.namespace) && this.namespace !== namespace.namespace) {
 			// TODO: Move to TypeScript generator...
 			// Libraries like zbar have classes named things like "Gtk"
@@ -248,11 +248,11 @@ export class ModuleTypeIdentifier extends TypeIdentifier {
 		);
 	}
 
-	protected _resolve(_namespace: IntrospectedNamespace, _options: OptionsBase): ModuleTypeIdentifier | null {
+	protected _resolve(_namespace: IntrospectedNamespace, _options: OptionsGeneration): ModuleTypeIdentifier | null {
 		return this;
 	}
 
-	print(namespace: IntrospectedNamespace, _options: OptionsBase): string {
+	print(namespace: IntrospectedNamespace, _options: OptionsGeneration): string {
 		if (namespace.namespace === this.namespace) {
 			return `${this.moduleName}.${this.name}`;
 		} else {
@@ -269,7 +269,7 @@ export class ClassStructTypeIdentifier extends TypeIdentifier {
 		return type instanceof ClassStructTypeIdentifier && super.equals(type);
 	}
 
-	print(namespace: IntrospectedNamespace, _options: OptionsBase): string {
+	print(namespace: IntrospectedNamespace, _options: OptionsGeneration): string {
 		if (namespace.namespace === this.namespace) {
 			// TODO: Mapping to invalid names should happen at the generator level...
 			return `typeof ${isInvalid(this.name) ? `__${this.name}` : this.name}`;
@@ -287,7 +287,7 @@ export class GenerifiedTypeIdentifier extends TypeIdentifier {
 		this.generics = generics;
 	}
 
-	print(namespace: IntrospectedNamespace, options: OptionsBase): string {
+	print(namespace: IntrospectedNamespace, options: OptionsGeneration): string {
 		const Generics = this.generics.map((generic) => generic.print(namespace, options)).join(", ");
 
 		if (namespace.namespace === this.namespace) {
@@ -297,7 +297,7 @@ export class GenerifiedTypeIdentifier extends TypeIdentifier {
 		}
 	}
 
-	_resolve(namespace: IntrospectedNamespace, options: OptionsBase): TypeIdentifier | null {
+	_resolve(namespace: IntrospectedNamespace, options: OptionsGeneration): TypeIdentifier | null {
 		const iden = super._resolve(namespace, options);
 
 		if (iden) {
@@ -309,9 +309,9 @@ export class GenerifiedTypeIdentifier extends TypeIdentifier {
 }
 
 export class NativeType extends TypeExpression {
-	readonly expression: (options?: OptionsBase) => string;
+	readonly expression: (options?: OptionsGeneration) => string;
 
-	constructor(expression: ((options?: OptionsBase) => string) | string) {
+	constructor(expression: ((options?: OptionsGeneration) => string) | string) {
 		super();
 		this.expression = typeof expression === "string" ? () => expression : expression;
 	}
@@ -324,11 +324,11 @@ export class NativeType extends TypeExpression {
 		return this;
 	}
 
-	print(_namespace: IntrospectedNamespace, options: OptionsBase): string {
+	print(_namespace: IntrospectedNamespace, options: OptionsGeneration): string {
 		return this.expression(options);
 	}
 
-	equals(type: TypeExpression, options?: OptionsBase): boolean {
+	equals(type: TypeExpression, options?: OptionsGeneration): boolean {
 		return type instanceof NativeType && this.expression(options) === type.expression(options);
 	}
 
@@ -336,7 +336,7 @@ export class NativeType extends TypeExpression {
 		return this;
 	}
 
-	static withGenerator(generator: (options?: OptionsBase) => string): TypeExpression {
+	static withGenerator(generator: (options?: OptionsGeneration) => string): TypeExpression {
 		return new NativeType(generator);
 	}
 
@@ -361,17 +361,17 @@ export class OrType extends TypeExpression {
 		return this;
 	}
 
-	resolve(namespace: IntrospectedNamespace, options: OptionsBase): TypeExpression {
+	resolve(namespace: IntrospectedNamespace, options: OptionsGeneration): TypeExpression {
 		const [type, ...types] = this.types;
 
 		return new OrType(type.resolve(namespace, options), ...types.map((t) => t.resolve(namespace, options)));
 	}
 
-	print(namespace: IntrospectedNamespace, options: OptionsBase): string {
+	print(namespace: IntrospectedNamespace, options: OptionsGeneration): string {
 		return `(${this.types.map((t) => t.print(namespace, options)).join(" | ")})`;
 	}
 
-	rootPrint(namespace: IntrospectedNamespace, options: OptionsBase): string {
+	rootPrint(namespace: IntrospectedNamespace, options: OptionsGeneration): string {
 		return `${this.types.map((t) => t.print(namespace, options)).join(" | ")}`;
 	}
 
@@ -385,15 +385,15 @@ export class OrType extends TypeExpression {
 }
 
 export class TupleType extends OrType {
-	print(namespace: IntrospectedNamespace, options: OptionsBase): string {
+	print(namespace: IntrospectedNamespace, options: OptionsGeneration): string {
 		return `[${this.types.map((t) => t.print(namespace, options)).join(", ")}]`;
 	}
 
-	rootPrint(namespace: IntrospectedNamespace, options: OptionsBase): string {
+	rootPrint(namespace: IntrospectedNamespace, options: OptionsGeneration): string {
 		return this.print(namespace, options);
 	}
 
-	resolve(namespace: IntrospectedNamespace, options: OptionsBase): TypeExpression {
+	resolve(namespace: IntrospectedNamespace, options: OptionsGeneration): TypeExpression {
 		const [type, ...types] = this.types;
 
 		return new TupleType(type.resolve(namespace, options), ...types.map((t) => t.resolve(namespace, options)));
@@ -413,7 +413,7 @@ export class BinaryType extends OrType {
 		return this;
 	}
 
-	resolve(namespace: IntrospectedNamespace, options: OptionsBase) {
+	resolve(namespace: IntrospectedNamespace, options: OptionsGeneration) {
 		return new BinaryType(this.a.resolve(namespace, options), this.b.resolve(namespace, options));
 	}
 
@@ -465,7 +465,7 @@ export class FunctionType extends TypeExpression {
 		return this;
 	}
 
-	resolve(namespace: IntrospectedNamespace, options: OptionsBase): TypeExpression {
+	resolve(namespace: IntrospectedNamespace, options: OptionsGeneration): TypeExpression {
 		return new FunctionType(
 			Object.fromEntries(
 				Object.entries(this.parameterTypes).map(([k, p]) => {
@@ -476,7 +476,7 @@ export class FunctionType extends TypeExpression {
 		);
 	}
 
-	rootPrint(namespace: IntrospectedNamespace, options: OptionsBase): string {
+	rootPrint(namespace: IntrospectedNamespace, options: OptionsGeneration): string {
 		const Parameters = Object.entries(this.parameterTypes)
 			.map(([k, v]) => {
 				return `${k}: ${v.rootPrint(namespace, options)}`;
@@ -486,7 +486,7 @@ export class FunctionType extends TypeExpression {
 		return `(${Parameters}) => ${this.returnType.print(namespace, options)}`;
 	}
 
-	print(namespace: IntrospectedNamespace, options: OptionsBase): string {
+	print(namespace: IntrospectedNamespace, options: OptionsGeneration): string {
 		return `(${this.rootPrint(namespace, options)})`;
 	}
 }
@@ -548,7 +548,7 @@ export class GenerifiedType extends TypeExpression {
 		this.generic = generic;
 	}
 
-	resolve(namespace: IntrospectedNamespace, options: OptionsBase) {
+	resolve(namespace: IntrospectedNamespace, options: OptionsGeneration) {
 		return new GenerifiedType(this.type.resolve(namespace, options), this.generic);
 	}
 
@@ -556,11 +556,11 @@ export class GenerifiedType extends TypeExpression {
 		return this.type;
 	}
 
-	rootPrint(namespace: IntrospectedNamespace, options: OptionsBase) {
+	rootPrint(namespace: IntrospectedNamespace, options: OptionsGeneration) {
 		return this.type.rootPrint(namespace, options);
 	}
 
-	print(namespace: IntrospectedNamespace, options: OptionsBase) {
+	print(namespace: IntrospectedNamespace, options: OptionsGeneration) {
 		return `${this.type.print(namespace, options)}<${this.generic.print()}>`;
 	}
 
@@ -624,7 +624,7 @@ export class NullableType extends BinaryType {
 	}
 
 	rewrap(type: TypeExpression): TypeExpression {
-		return new NullableType(this.a.rewrap(type));
+		return makeNullable(this.a.rewrap(type));
 	}
 
 	get type() {
@@ -632,6 +632,12 @@ export class NullableType extends BinaryType {
 	}
 }
 
+export function makeNullable(type: TypeExpression) {
+	if (type === RawPointerType) return NullType;
+	if (type === AnyType) return AnyType;
+	return new NullableType(type);
+}
+
 export class PromiseType extends TypeExpression {
 	type: TypeExpression;
 
@@ -652,11 +658,11 @@ export class PromiseType extends TypeExpression {
 		return new PromiseType(this.type.rewrap(type));
 	}
 
-	resolve(namespace: IntrospectedNamespace, options: OptionsBase): TypeExpression {
+	resolve(namespace: IntrospectedNamespace, options: OptionsGeneration): TypeExpression {
 		return new PromiseType(this.type.resolve(namespace, options));
 	}
 
-	print(namespace: IntrospectedNamespace, options: OptionsBase): string {
+	print(namespace: IntrospectedNamespace, options: OptionsGeneration): string {
 		if (this.type.equals(VoidType)) {
 			return "globalThis.Promise<void>";
 		}
@@ -664,7 +670,7 @@ export class PromiseType extends TypeExpression {
 		return `globalThis.Promise<${this.type.print(namespace, options)}>`;
 	}
 
-	rootPrint(namespace: IntrospectedNamespace, options: OptionsBase): string {
+	rootPrint(namespace: IntrospectedNamespace, options: OptionsGeneration): string {
 		return this.print(namespace, options);
 	}
 }
@@ -703,13 +709,13 @@ export class TypeConflict extends TypeExpression {
 		return true;
 	}
 
-	resolve(namespace: IntrospectedNamespace, options: OptionsBase): TypeExpression {
+	resolve(namespace: IntrospectedNamespace, options: OptionsGeneration): TypeExpression {
 		const resolvedType = this.type.resolve(namespace, options);
 		const typeString = resolvedType.print(namespace, options);
 		throw new Error(`Type conflict was not resolved for ${typeString} in ${namespace.namespace}`);
 	}
 
-	print(namespace: IntrospectedNamespace, options: OptionsBase): string {
+	print(namespace: IntrospectedNamespace, options: OptionsGeneration): string {
 		const resolvedType = this.type.resolve(namespace, options);
 		const typeString = resolvedType.print(namespace, options);
 		throw new Error(`Type conflict was not resolved for ${typeString} in ${namespace.namespace}`);
@@ -750,7 +756,7 @@ export class ClosureType extends TypeExpression {
 		return this;
 	}
 
-	resolve(namespace: IntrospectedNamespace, options: OptionsBase) {
+	resolve(namespace: IntrospectedNamespace, options: OptionsGeneration) {
 		const { user_data, type } = this;
 
 		return ClosureType.new({
@@ -759,7 +765,7 @@ export class ClosureType extends TypeExpression {
 		});
 	}
 
-	print(namespace: IntrospectedNamespace, options: OptionsBase): string {
+	print(namespace: IntrospectedNamespace, options: OptionsGeneration): string {
 		return this.type.print(namespace, options);
 	}
 
@@ -807,7 +813,7 @@ export class ArrayType extends TypeExpression {
 		return false;
 	}
 
-	resolve(namespace: IntrospectedNamespace, options: OptionsBase): TypeExpression {
+	resolve(namespace: IntrospectedNamespace, options: OptionsGeneration): TypeExpression {
 		const { type, arrayDepth, length } = this;
 		return ArrayType.new({
 			type: type.resolve(namespace, options),
@@ -816,7 +822,7 @@ export class ArrayType extends TypeExpression {
 		});
 	}
 
-	print(namespace: IntrospectedNamespace, options: OptionsBase): string {
+	print(namespace: IntrospectedNamespace, options: OptionsGeneration): string {
 		const depth = this.arrayDepth;
 		let typeSuffix: string = "";
 
@@ -861,9 +867,13 @@ export const Uint8ArrayType = new NativeType("Uint8Array");
 export const BooleanType = new NativeType("boolean");
 export const StringType = new NativeType("string");
 export const NumberType = new NativeType("number");
+export const BigintOrNumberType = new BinaryType(new NativeType("bigint"), NumberType);
 export const NullType = new NativeType("null");
 export const VoidType = new NativeType("void");
 export const UnknownType = new NativeType("unknown");
 export const AnyFunctionType = new NativeType("(...args: any[]) => any");
+// Distinct from NeverType, so that we can transform it into NullType when
+// marshalled from C to JS
+export const RawPointerType = new NativeType("never");
 
 export type GirClassField = IntrospectedProperty | IntrospectedField;

package/src/types/options-generation.ts

@@ -23,6 +23,8 @@ export interface OptionsGeneration extends OptionsBase {
 	npmScope: string;
 	/** Uses the workspace protocol for the generated packages which can be used with package managers like Yarn and PNPM */
 	workspace: boolean;
+	/** Format used for dependency version specifiers in generated package.json files */
+	depVersionFormat?: "workspace" | "caret" | "any" | "exact";
 	/** Disable GLib.Variant class with string parsing */
 	noAdvancedVariants: boolean;
 	/**
@@ -62,4 +64,25 @@ export interface OptionsGeneration extends OptionsBase {
 	merge?: boolean;
 	/** Directory containing pre-generated TypeDoc JSON files for merge mode (from 'ts-for-gir json') */
 	jsonDir?: string;
+	/**
+	 * External-deps mode: emit `import` statements that reference dependency types from
+	 * already-installed npm packages (e.g. `@girs/glib-2.0`) instead of regenerating them.
+	 * Designed for project-local GIRs (Vala bridges etc.) where the surrounding `@girs/*`
+	 * ecosystem is already in node_modules. No GJS supporting files, no index aggregator.
+	 */
+	externalDeps: boolean;
+	/**
+	 * In `externalDeps` mode, allow generation to proceed even when some transitive dep GIRs
+	 * cannot be found. Default is strict: missing deps abort the run, since divergent dep
+	 * availability between environments (dev with -devel packages vs CI without) would
+	 * silently produce inconsistent generated `.d.ts` output.
+	 */
+	allowMissingDeps: boolean;
+	/**
+	 * Override the default `<npmScope>/<importName>` mapping for individual namespaces when
+	 * resolving external dependency imports in `externalDeps` mode.
+	 *
+	 * Example: `{ Soup: '@girs/soup-3.0', GLib: '@girs/glib-2.0' }`
+	 */
+	externalPackages?: Record<string, string>;
 }

package/src/types/user-config.ts

@@ -28,6 +28,16 @@ export interface UserConfig {
 	npmScope: string;
 	/** Uses the workspace protocol for the generated packages which can be used with package managers like Yarn and PNPM */
 	workspace: boolean;
+	/**
+	 * Format used for dependency version specifiers in generated package.json files.
+	 * - `workspace`: emit `workspace:^` (yarn/pnpm; npm only when the ref matches a registered workspace)
+	 * - `caret`: emit `^<version>` (all managers, falls back to registry for dangling refs)
+	 * - `any`: emit `*` (all managers, most permissive)
+	 * - `exact`: emit `<version>` (all managers, no range)
+	 *
+	 * If unset, defaults to `workspace` when `workspace: true`, else `caret`.
+	 */
+	depVersionFormat?: "workspace" | "caret" | "any" | "exact";
 	/**
 	 * Only use the version prefix for the ambient module exports.
 	 * This is useful if, for whatever reason, you want to use different library versions of the same library in your project.
@@ -67,4 +77,24 @@ export interface UserConfig {
 	merge?: boolean;
 	/** Directory containing pre-generated TypeDoc JSON files for merge mode (from 'ts-for-gir json') */
 	jsonDir?: string;
+	/**
+	 * External-deps mode: emit `import` statements that reference dependency types from
+	 * already-installed npm packages (e.g. `@girs/glib-2.0`) instead of regenerating them.
+	 * Designed for project-local GIRs (Vala bridges etc.) where the surrounding `@girs/*`
+	 * ecosystem is already in node_modules.
+	 */
+	externalDeps: boolean;
+	/**
+	 * Allow `externalDeps` generation to proceed when some transitive dep GIRs are missing.
+	 * Default is strict: missing deps cause an error to prevent silent type-quality drift
+	 * between environments with and without system GIR -devel packages installed.
+	 */
+	allowMissingDeps: boolean;
+	/**
+	 * Override the default `<npmScope>/<importName>` mapping for individual namespaces when
+	 * resolving external dependency imports in `externalDeps` mode.
+	 *
+	 * Example: `{ Soup: '@girs/soup-3.0', GLib: '@girs/glib-2.0' }`
+	 */
+	externalPackages?: Record<string, string>;
 }

package/src/utils/conflicts.ts

@@ -261,8 +261,13 @@ function checkFunctionConflicts<T extends IntrospectedClassFunction | Introspect
 		});
 	});
 
-	// Check field/property conflicts
-	const hasFieldConflicts = checkFieldPropertyConflicts(base, functionElement.name);
+	// Static methods can coexist with instance fields/properties of the same name
+	// in TypeScript (e.g. `static map(...)` alongside `map: T[]`), so skip the check
+	// for them. The conflict only applies to instance methods.
+	const hasFieldConflicts =
+		functionElement instanceof IntrospectedStaticClassFunction
+			? false
+			: checkFieldPropertyConflicts(base, functionElement.name);
 
 	// Check GObject reserved methods
 	const hasGObjectConflicts = checkGObjectConflicts(base, functionElement.name);

package/src/utils/generation.ts

@@ -37,7 +37,9 @@ export function addTSDocCommentLines(lines: string[], indentCount = 0): string[]
 }
 
 /**
- * Adds an info comment, is used for debugging the generated types
+ * Adds an info comment, is used for debugging the generated types.
+ * One blank line before the comment, one after — readers see a single
+ * blank-line separator on each side without a double-blank gap.
  */
 export function addInfoComment(comment?: string, indentCount = 0): string[] {
 	const def: string[] = [];
@@ -45,7 +47,6 @@ export function addInfoComment(comment?: string, indentCount = 0): string[] {
 	if (comment) {
 		def.push("");
 		def.push(`${indent}// ${comment}`);
-		def.push("");
 	}
 	return def;
 }
@@ -58,7 +59,8 @@ export function mergeDescs(descs: string[], comment?: string, indentCount = 1):
 	const indent = generateIndent(indentCount);
 
 	for (const desc of descs) {
-		def.push(`${indent}${desc}`);
+		// Empty separator strings stay empty; only real content gets indented.
+		def.push(desc.length === 0 ? desc : `${indent}${desc}`);
 	}
 
 	if (def.length > 0) {

package/src/utils/gir-defaults.ts

@@ -0,0 +1,66 @@
+import type { GirModule } from "../gir-module.ts";
+
+/**
+ * Resolves a single C enum/bitfield constant to its GJS-qualified path by searching
+ * the module's own enum_constants map and then all direct and transitive dependencies.
+ * Returns [namespaceName, enumTypeName, memberName] or null if not found.
+ *
+ * Called during the generation phase (after all modules have been parsed), so all
+ * dependency enum_constants maps are fully populated. Each GirModule.enum_constants
+ * is an O(1) Map; the total cost per call is O(deps) — negligible given the small
+ * fraction of properties that carry a default-value attribute.
+ */
+function resolveCEnumConstant(cIdentifier: string, ns: GirModule): readonly [string, string, string] | null {
+	// Check own namespace first
+	const own = ns.enum_constants.get(cIdentifier);
+	if (own) return [ns.namespace, own[0], own[1]] as const;
+
+	// Check all direct and transitive dependencies
+	for (const dep of ns.allDependencies) {
+		const depModule = ns.getInstalledImport(dep.namespace);
+		if (!depModule) continue;
+		const entry = depModule.enum_constants.get(cIdentifier);
+		if (entry) return [depModule.namespace, entry[0], entry[1]] as const;
+	}
+
+	return null;
+}
+
+function convertSingleCValue(value: string, ns: GirModule): string {
+	const trimmed = value.trim();
+
+	if (trimmed === "NULL") return "null";
+	if (trimmed === "TRUE") return "true";
+	if (trimmed === "FALSE") return "false";
+
+	// Normalize C floats: "0.000000" → "0", "1.500000" → "1.5"
+	if (/^-?\d+\.\d+$/.test(trimmed)) {
+		const n = parseFloat(trimmed);
+		if (!Number.isNaN(n)) return String(n);
+	}
+
+	// Resolve C enum/bitfield constant (own namespace + all dependencies)
+	// e.g. "GTK_ALIGN_FILL"         → "Gtk.Align.FILL"
+	// e.g. "GDK_NO_MODIFIER_MASK"   → "Gdk.ModifierType.NO_MODIFIER_MASK"
+	// e.g. "PANGO_ALIGN_LEFT"       → "Pango.Alignment.LEFT"
+	const entry = resolveCEnumConstant(trimmed, ns);
+	if (entry) return `${entry[0]}.${entry[1]}.${entry[2]}`;
+
+	return trimmed;
+}
+
+/**
+ * Converts a raw C default-value string from GIR XML to its JavaScript equivalent.
+ * Handles NULL/TRUE/FALSE, C float literals, C enum/bitfield constants (including
+ * cross-namespace lookups), and bitmask combinations (A | B | C).
+ */
+export function convertCDefaultValue(rawValue: string, ns: GirModule): string {
+	// Handle bitmask combinations: "A | B | C"
+	if (rawValue.includes("|")) {
+		return rawValue
+			.split("|")
+			.map((part) => convertSingleCValue(part, ns))
+			.join(" | ");
+	}
+	return convertSingleCValue(rawValue, ns);
+}

package/src/utils/gir-parsing.ts

@@ -14,10 +14,11 @@ import { LazyReporter } from "@ts-for-gir/reporter";
 import type { IntrospectedNamespace } from "../gir/namespace.ts";
 import {
 	ArrayType,
+	BigintOrNumberType,
 	ClosureType,
 	GenerifiedTypeIdentifier,
+	makeNullable,
 	NativeType,
-	NullableType,
 	type TypeExpression,
 	TypeIdentifier,
 	VoidType,
@@ -238,13 +239,14 @@ export function getType(
 		parameter.$ &&
 		(parameter.$.direction === GirDirection.Inout || parameter.$.direction === GirDirection.Out) &&
 		(nullable || allowNone) &&
-		!(variableType instanceof NativeType)
+		!(variableType instanceof NativeType) &&
+		variableType !== BigintOrNumberType
 	) {
-		return new NullableType(variableType);
+		return makeNullable(variableType);
 	}
 
 	if ((!parameter.$?.direction || parameter.$.direction === GirDirection.In) && nullable) {
-		return new NullableType(variableType);
+		return makeNullable(variableType);
 	}
 
 	variableType.isPointer = isPointer;

package/src/utils/index.ts

@@ -2,6 +2,7 @@ export * from "./conflicts.ts";
 export * from "./documentation.ts";
 export * from "./files.ts";
 export * from "./generation.ts";
+export * from "./gir-defaults.ts";
 export * from "./gir-parsing.ts";
 export * from "./girs.ts";
 export * from "./naming.ts";

package/src/utils/path.ts

@@ -1,7 +1,15 @@
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
-// Get __filename on ESM
-const __filename = fileURLToPath(import.meta.url);
-// Get __dirname on ESM, resolve to the root directory of this package
-export const __dirname = resolve(dirname(__filename), "../.."); // TODO: Bundled this must be '..' but unbundled it must be '../..'
+// Resolves to the root directory of this package in dev mode.
+// Wrapped in try/catch so a bundled consumer that lacks `import.meta.url`
+// support degrades to "" instead of crashing at module load.
+function resolvePackageDir(): string {
+	try {
+		return resolve(dirname(fileURLToPath(import.meta.url)), "../..");
+	} catch {
+		return "";
+	}
+}
+
+export const __dirname = resolvePackageDir();

package/src/utils/types.ts

@@ -4,14 +4,21 @@ import type { IntrospectedNamespace } from "../gir/namespace.ts";
 import {
 	AnyType,
 	ArrayType,
+	BigintOrNumberType,
 	BinaryType,
 	BooleanType,
 	NativeType,
 	NeverType,
+	NullableType,
+	NullType,
 	NumberType,
 	ObjectType,
+	OrType,
+	PromiseType,
+	RawPointerType,
 	StringType,
 	ThisType,
+	TupleType,
 	type TypeExpression,
 	TypeIdentifier,
 	Uint8ArrayType,
@@ -167,28 +174,33 @@ export function resolvePrimitiveType(name: string): TypeExpression | null {
 		case "gfloat":
 		case "gchar":
 		case "guint":
-		case "glong":
-		case "gulong":
 		case "gint":
 		case "guint8":
+		case "gdouble":
+			return NumberType;
+		case "glong":
+		case "gulong":
 		case "guint64":
 		case "gint64":
-		case "gdouble":
 		case "gssize":
 		case "gsize":
+		case "guintptr": // Integer of the same width as a pointer
 		case "time_t": // C standard library time type (seconds since Unix epoch)
 		case "ulong": // C standard library unsigned long type
-			return NumberType;
+			return BigintOrNumberType;
 		case "gboolean":
 			return BooleanType;
-		case "gpointer": // This is typically used in callbacks to pass data, so we'll allow anything.
-			return AnyType;
+		case "gpointer":
+			// You can't use pointers. Pointer arguments are mostly not exposed
+			// in GJS, but any exposed pointer arguments are always marshalled
+			// as null pointers. If the argument is nullable, this will combine
+			// with `null` to produce `null`, but if the argument isn't nullable
+			// it's impossible to pass a valid parameter to the function.
+			return RawPointerType;
 		case "object": // Support TS "object"
 			return ObjectType;
 		case "va_list":
 			return AnyType;
-		case "guintptr": // You can't use pointers in GJS! (at least that I'm aware of)
-			return NeverType;
 		case "never": // Support TS "never"
 			return NeverType;
 		case "unknown": // Support TS "unknown"
@@ -243,6 +255,30 @@ export function resolveDirectedType(type: TypeExpression, direction: GirDirectio
 				return type;
 			}
 		}
+	} else if (type === BigintOrNumberType && direction === GirDirection.Out) {
+		// 64-bit integers accept number or bigint, but only return number to JS
+		return NumberType;
+	} else if (type === RawPointerType && direction === GirDirection.Out) {
+		// Raw pointers are always marshalled as JS null.
+		return NullType;
+	} else if (type instanceof PromiseType) {
+		// Propagate direction into the Promise's inner type so e.g. async
+		// functions returning 64-bit ints resolve to `Promise<number>` rather
+		// than `Promise<bigint | number>`.
+		const resolvedInner = resolveDirectedType(type.type, direction);
+		if (resolvedInner) return new PromiseType(resolvedInner);
+	} else if (type instanceof BinaryType && !(type instanceof NullableType)) {
+		// Walk through binary unions like `Promise<T> | void` (the dual-call
+		// async overload) so the inner types still get direction propagation.
+		// NullableType is skipped to preserve its subclass behaviour.
+		const a = resolveDirectedType(type.a, direction) ?? type.a;
+		const b = resolveDirectedType(type.b, direction) ?? type.b;
+		if (a !== type.a || b !== type.b) return new BinaryType(a, b);
+	} else if (type instanceof OrType && !(type instanceof BinaryType || type instanceof TupleType)) {
+		// flatten "bigint | number" out of another OR-type
+		const types = type.types.map((t) => resolveDirectedType(t, direction) ?? t);
+		if (types.length === 1) return types[0];
+		return new OrType(types[0], ...types.slice(1));
 	}
 
 	return null;

package/src/validators/class.ts

@@ -3,7 +3,7 @@ import { IntrospectedError } from "../gir/error.ts";
 import type { IntrospectedBaseClass, IntrospectedClass, IntrospectedInterface } from "../gir/introspected-classes.ts";
 import { IntrospectedClassFunction, IntrospectedStaticClassFunction } from "../gir/introspected-classes.ts";
 import { IntrospectedRecord } from "../gir/record.ts";
-import { AnyType, NativeType, TypeIdentifier } from "../gir.ts";
+import { AnyType, ArrayType, NativeType, TypeIdentifier } from "../gir.ts";
 import { resolveTypeIdentifier } from "../utils/type-resolution.ts";
 import { GirVisitor } from "../visitor.ts";
 
@@ -125,9 +125,10 @@ const fixMissingParent = <T extends IntrospectedBaseClass>(node: T): T => {
 };
 
 /**
- * Fields cannot be array types, error types,
- * or class-like types in GJS. This strips
- * fields which have these "complex" types.
+ * Removes fields with types that GJS cannot directly expose on a struct instance.
+ * Error types and non-simple non-pointer struct fields are removed.
+ * Array fields (zero-terminated pointer arrays, T**) are always safe in GJS and are only
+ * rejected if the element type is private or disguised.
  *
  * @param node
  */
@@ -135,6 +136,17 @@ const removeComplexFields = <T extends IntrospectedBaseClass>(node: T): T => {
 	const { namespace } = node;
 
 	node.fields = node.fields.filter((f) => {
+		// Array fields (T**) are marshalled by GJS for any GBoxed element type.
+		// Only reject arrays of private/disguised element types.
+		if (f.type instanceof ArrayType) {
+			const elementType = f.type.deepUnwrap();
+			if (elementType instanceof TypeIdentifier) {
+				const classNode = resolveTypeIdentifier(namespace, elementType);
+				return !classNode?.isPrivate;
+			}
+			return true;
+		}
+
 		const type = f.type.deepUnwrap();
 
 		if (type instanceof NativeType) {

package/src/validators/function-parameters.ts

@@ -1,52 +0,0 @@
-import type { IntrospectedEnum } from "../gir/enum.ts";
-import type { IntrospectedFunction } from "../gir/function.ts";
-import type { IntrospectedBaseClass, IntrospectedClassFunction } from "../gir/introspected-classes.ts";
-
-import { NullableType, TypeIdentifier } from "../gir.ts";
-import { GirVisitor } from "../visitor.ts";
-
-export class FunctionParametersVisitor extends GirVisitor {
-	/**
-	 * Marks all enum parameters of a function as nullable,
-	 * because GJS allows null values for enum parameters and treats them as a 0 value.
-	 * See issue [#207](https://github.com/gjsify/ts-for-gir/issues/207).
-	 */
-	private makeEnumParamsNullable(node: IntrospectedFunction): IntrospectedFunction;
-	private makeEnumParamsNullable<T extends IntrospectedBaseClass | IntrospectedEnum>(
-		node: IntrospectedClassFunction<T>,
-	): IntrospectedClassFunction<T>;
-	private makeEnumParamsNullable(
-		node: IntrospectedFunction | IntrospectedClassFunction,
-	): IntrospectedFunction | IntrospectedClassFunction {
-		return node.copy({
-			parameters: node.parameters.map((param) => {
-				const type = param.type.deepUnwrap();
-				if (type instanceof TypeIdentifier) {
-					// Get the namespace where this type should be defined
-					const ns = node.namespace.assertInstalledImport(type.namespace);
-
-					// Check if the type is an enum
-					const isEnumType = !!ns.getEnum(type.name);
-
-					// If it is, make the parameter nullable
-					if (isEnumType) {
-						return param.copy({
-							type: new NullableType(param.type),
-						});
-					}
-				}
-				return param;
-			}),
-		});
-	}
-
-	visitFunction = (node: IntrospectedFunction): IntrospectedFunction => {
-		return this.makeEnumParamsNullable(node);
-	};
-
-	visitClassFunction = <T extends IntrospectedBaseClass | IntrospectedEnum>(
-		node: IntrospectedClassFunction<T>,
-	): IntrospectedClassFunction<T> => {
-		return this.makeEnumParamsNullable(node);
-	};
-}