@ts-for-gir/cli 4.0.0-rc.6 → 4.0.0-rc.8

package/bin/ts-for-gir

@@ -7268,7 +7268,7 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 function getPackageVersion() {
   if (true) {
-    return "4.0.0-rc.6";
+    return "4.0.0-rc.8";
   }
   const currentModulePath = fileURLToPath(import.meta.url);
   const currentDir = dirname(currentModulePath);
@@ -8165,13 +8165,17 @@ import { fileURLToPath as fileURLToPath2 } from "node:url";
 var NEW_LINE_REG_EXP = /[\n\r]+/g;
 function getPackageVersion2() {
   if (true) {
-    return "4.0.0-rc.6";
+    return "4.0.0-rc.8";
+  }
+  try {
+    const currentModulePath = fileURLToPath2(import.meta.url);
+    const currentDir = dirname2(currentModulePath);
+    const packageJsonPath = join2(currentDir, "..", "package.json");
+    const content = readFileSync2(packageJsonPath, "utf-8");
+    return JSON.parse(content).version;
+  } catch {
+    return "0.0.0-unknown";
   }
-  const currentModulePath = fileURLToPath2(import.meta.url);
-  const currentDir = dirname2(currentModulePath);
-  const packageJsonPath = join2(currentDir, "..", "package.json");
-  const content = readFileSync2(packageJsonPath, "utf-8");
-  return JSON.parse(content).version;
 }
 var APP_NAME = "ts-for-gir";
 var APP_USAGE = "TypeScript type definition generator for GObject introspection GIR files";
@@ -14393,12 +14397,16 @@ var IntrospectedProperty = class _IntrospectedProperty extends IntrospectedBase
   writable = false;
   readable = true;
   constructOnly;
+  /** GIR default-value attribute: the default value of the property as a string. */
+  defaultValue;
+  /** GIR getter attribute: name of the getter method for this property (used for nullable inference). */
+  getter;
   get namespace() {
     return this.parent.namespace;
   }
   copy(options2) {
     const { name, writable, readable, type, constructOnly, parent } = this;
-    return new _IntrospectedProperty({
+    const prop = new _IntrospectedProperty({
       name: options2?.name ?? name,
       writable,
       readable,
@@ -14406,6 +14414,9 @@ var IntrospectedProperty = class _IntrospectedProperty extends IntrospectedBase
       constructOnly,
       parent: options2?.parent ?? parent
     })._copyBaseProperties(this);
+    prop.defaultValue = this.defaultValue;
+    prop.getter = this.getter;
+    return prop;
   }
   accept(visitor) {
     const node = this.copy({
@@ -14463,6 +14474,11 @@ var IntrospectedProperty = class _IntrospectedProperty extends IntrospectedBase
       property.doc = parseDoc(element);
       property.metadata = parseMetadata(element);
     }
+    property.defaultValue = element.$["default-value"];
+    property.getter = element.$.getter;
+    if (element.$.nullable === "1" || element.$["allow-none"] === "1") {
+      property.type = new NullableType(property.type);
+    }
     return property;
   }
 };
@@ -14655,6 +14671,28 @@ var IntrospectedSignal = class _IntrospectedSignal extends IntrospectedClassMemb
 
 // ../lib/src/gir/introspected-classes.ts
 var log = new ConsoleReporter(true, "gir/introspected-classes", true);
+function hasExtendsShadowOf(cls, prerequisite, name) {
+  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) {
+  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 = new NullableType(prop.type);
+    }
+  }
+}
 var IntrospectedClassFunction = class _IntrospectedClassFunction extends IntrospectedBase {
   parameters;
   return_type;
@@ -14665,6 +14703,8 @@ var IntrospectedClassFunction = class _IntrospectedClassFunction extends Introsp
   returnTypeDoc;
   /** If this function was generated from a signal, stores the signal name. */
   signalOrigin;
+  /** GIR glib:finish-func attribute: name of the function that finishes this async operation. */
+  finishFuncName;
   generics = [];
   constructor({
     name,
@@ -14711,6 +14751,7 @@ var IntrospectedClassFunction = class _IntrospectedClassFunction extends Introsp
     });
     fn.generics = [...this.generics];
     fn.returnTypeDoc = this.returnTypeDoc;
+    fn.finishFuncName = this.finishFuncName;
     if (interfaceParent) {
       fn.interfaceParent = interfaceParent;
     }
@@ -14732,6 +14773,7 @@ var IntrospectedClassFunction = class _IntrospectedClassFunction extends Introsp
   static fromXML(element, parent, options2) {
     const fn = IntrospectedFunction.fromXML(element, parent.namespace, options2);
     const { raw_name: name, output_parameters, parameters, return_type, doc: doc2, isIntrospectable: isIntrospectable2 } = fn;
+    const isShadowedBy = element.$["shadowed-by"] != null;
     const classFn = new _IntrospectedClassFunction({
       parent,
       name,
@@ -14739,10 +14781,11 @@ var IntrospectedClassFunction = class _IntrospectedClassFunction extends Introsp
       parameters,
       return_type,
       doc: doc2,
-      isIntrospectable: isIntrospectable2
+      isIntrospectable: isIntrospectable2 && !isShadowedBy
     });
     classFn.returnTypeDoc = fn.returnTypeDoc;
     classFn.generics = [...fn.generics];
+    classFn.finishFuncName = element.$["glib:finish-func"];
     return classFn;
   }
   anyify() {
@@ -14885,6 +14928,7 @@ var IntrospectedStaticClassFunction = class _IntrospectedStaticClassFunction ext
   static fromXML(m, parent, options2) {
     const fn = IntrospectedFunction.fromXML(m, parent.namespace, options2);
     const { raw_name: name, output_parameters, parameters, return_type, doc: doc2, isIntrospectable: isIntrospectable2 } = fn;
+    const isShadowedBy = m.$["shadowed-by"] != null;
     return new _IntrospectedStaticClassFunction({
       parent,
       name,
@@ -14892,7 +14936,7 @@ var IntrospectedStaticClassFunction = class _IntrospectedStaticClassFunction ext
       parameters,
       return_type,
       doc: doc2,
-      isIntrospectable: isIntrospectable2
+      isIntrospectable: isIntrospectable2 && !isShadowedBy
     });
   }
 };
@@ -15211,6 +15255,7 @@ var IntrospectedClass = class _IntrospectedClass extends IntrospectedBaseClass {
       if (extended?.node instanceof _IntrospectedClass) {
         for (const item of getItems(extended.node)) {
           if (items.has(item.name) || !validate3(item)) continue;
+          if (!hasExtendsShadowOf(this, extended.node, item.name)) continue;
           items.set(item.name, item);
         }
       }
@@ -15348,6 +15393,7 @@ var IntrospectedClass = class _IntrospectedClass extends IntrospectedBaseClass {
     _IntrospectedClass.parseBasicProperties(element, clazz, ns, options2);
     _IntrospectedClass.parseResolveNames(element, clazz, ns, name);
     _IntrospectedClass.parseInheritanceAndMembers(element, clazz, ns, options2);
+    resolveNullableProperties(clazz);
     return clazz;
   }
   static parseBasicProperties(element, clazz, ns, options2) {
@@ -15578,6 +15624,7 @@ var IntrospectedInterface = class _IntrospectedInterface extends IntrospectedBas
     _IntrospectedInterface.parseInterfaceBasicProperties(element, iface, namespace, options2);
     _IntrospectedInterface.parseInterfaceResolveNames(element, iface, namespace, name);
     _IntrospectedInterface.parseInterfaceMembers(element, iface, namespace, options2);
+    resolveNullableProperties(iface);
     return iface;
   }
   static parseInterfaceBasicProperties(element, iface, namespace, options2) {
@@ -15948,9 +15995,7 @@ var IntrospectedFunction = class _IntrospectedFunction extends IntrospectedNames
       ({ allowOptions, params }, p) => {
         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 {
@@ -17461,6 +17506,9 @@ function generatePromisifyOverloadedSignatures(node, async_parameters, sync_para
 }
 function findFinishMethodInClass(cls, node) {
   const members = node instanceof IntrospectedStaticClassFunction ? [...cls.constructors, ...cls.members.filter((m) => m instanceof IntrospectedStaticClassFunction)] : [...cls.members.filter((m) => !(m instanceof IntrospectedStaticClassFunction))];
+  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`
   );
@@ -20172,6 +20220,14 @@ var fixMissingParent = (node) => {
 var removeComplexFields = (node) => {
   const { namespace } = node;
   node.fields = node.fields.filter((f) => {
+    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) {
       return true;
@@ -20716,7 +20772,7 @@ function checkFunctionConflicts(ns, base, functionElement, conflict_ids, nextTyp
       return false;
     });
   });
-  const hasFieldConflicts = checkFieldPropertyConflicts(base, functionElement.name);
+  const hasFieldConflicts = functionElement instanceof IntrospectedStaticClassFunction ? false : checkFieldPropertyConflicts(base, functionElement.name);
   const hasGObjectConflicts = checkGObjectConflicts(base, functionElement.name);
   const hasConflict = hasParentConflict || hasGObjectConflicts;
   return {
@@ -20934,7 +20990,6 @@ function addInfoComment(comment, indentCount = 0) {
   if (comment) {
     def.push("");
     def.push(`${indent}// ${comment}`);
-    def.push("");
   }
   return def;
 }
@@ -20942,7 +20997,7 @@ function mergeDescs(descs, comment, indentCount = 1) {
   const def = [];
   const indent = generateIndent(indentCount);
   for (const desc of descs) {
-    def.push(`${indent}${desc}`);
+    def.push(desc.length === 0 ? desc : `${indent}${desc}`);
   }
   if (def.length > 0) {
     def.unshift(...addInfoComment(comment, indentCount));
@@ -20950,11 +21005,49 @@ function mergeDescs(descs, comment, indentCount = 1) {
   return def;
 }
 
+// ../lib/src/utils/gir-defaults.ts
+function resolveCEnumConstant(cIdentifier, ns) {
+  const own = ns.enum_constants.get(cIdentifier);
+  if (own) return [ns.namespace, own[0], own[1]];
+  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]];
+  }
+  return null;
+}
+function convertSingleCValue(value, ns) {
+  const trimmed = value.trim();
+  if (trimmed === "NULL") return "null";
+  if (trimmed === "TRUE") return "true";
+  if (trimmed === "FALSE") return "false";
+  if (/^-?\d+\.\d+$/.test(trimmed)) {
+    const n = parseFloat(trimmed);
+    if (!Number.isNaN(n)) return String(n);
+  }
+  const entry = resolveCEnumConstant(trimmed, ns);
+  if (entry) return `${entry[0]}.${entry[1]}.${entry[2]}`;
+  return trimmed;
+}
+function convertCDefaultValue(rawValue, ns) {
+  if (rawValue.includes("|")) {
+    return rawValue.split("|").map((part) => convertSingleCValue(part, ns)).join(" | ");
+  }
+  return convertSingleCValue(rawValue, ns);
+}
+
 // ../lib/src/utils/path.ts
 import { dirname as dirname4, resolve as resolve3 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
-var __filename = fileURLToPath3(import.meta.url);
-var __dirname = resolve3(dirname4(__filename), "../..");
+function resolvePackageDir() {
+  try {
+    return resolve3(dirname4(fileURLToPath3(import.meta.url)), "../..");
+  } catch {
+    return "";
+  }
+}
+var __dirname = resolvePackageDir();
 
 // src/start.ts
 import yargs from "yargs";
@@ -21736,7 +21829,7 @@ var formatAsCsv = (problems) => {
   ]);
   return [headers.join(","), ...rows.map((row) => row.join(","))].join("\n");
 };
-var exportResults = (problems, filePath, format, logger6) => {
+var exportResults = (problems, filePath, format, logger5) => {
   let content;
   switch (format) {
     case "json": {
@@ -21756,14 +21849,14 @@ var exportResults = (problems, filePath, format, logger6) => {
     }
   }
   writeFileSync(filePath, content, "utf-8");
-  logger6.success(`Results exported to: ${filePath}`);
+  logger5.success(`Results exported to: ${filePath}`);
 };
 var handler = async (args) => {
-  const logger6 = new Logger(args.verbose ?? false, "AnalyzeCommand");
+  const logger5 = new Logger(args.verbose ?? false, "AnalyzeCommand");
   try {
     const report = loadReportFile(args.reportFile);
     if (args.verbose) {
-      logger6.info(`Loaded report with ${report.problems.length} problems`);
+      logger5.info(`Loaded report with ${report.problems.length} problems`);
     }
     const hasFilters = Boolean(args.severity || args.category || args.namespace || args.type || args.search);
     if (args.summary || !hasFilters) {
@@ -21778,7 +21871,7 @@ var handler = async (args) => {
     }
     if (args.export) {
       const format = args.format ?? "json";
-      exportResults(filteredProblems, args.export, format, logger6);
+      exportResults(filteredProblems, args.export, format, logger5);
     }
     if (hasFilters && !args.summary) {
       console.log(
@@ -21788,7 +21881,7 @@ var handler = async (args) => {
     }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : "Unknown error";
-    logger6.error(`Analysis failed: ${errorMessage}`);
+    logger5.error(`Analysis failed: ${errorMessage}`);
     process.exit(1);
   }
 };
@@ -22417,8 +22510,8 @@ var PROJECT_NAME_PLACEHOLDER = "__PROJECT_NAME__";
 var TEXT_FILE_EXT = /* @__PURE__ */ new Set([".json", ".md", ".ts", ".tsx", ".js", ".mjs", ".cjs"]);
 var builder3 = createBuilder(createOptions, examples3);
 function findTemplatesRoot() {
-  const __filename2 = fileURLToPath4(import.meta.url);
-  const __dirname3 = dirname6(__filename2);
+  const __filename = fileURLToPath4(import.meta.url);
+  const __dirname3 = dirname6(__filename);
   const candidates = [
     // Bundled production binary (bin/ts-for-gir): ../dist-templates
     resolve5(__dirname3, "..", "dist-templates"),
@@ -22920,7 +23013,6 @@ var SignalGenerator = class {
     const def = [];
     const indent = generateIndent(indentCount);
     def.push(`${indent}// Signal signatures`);
-    def.push(`${indent}interface SignalSignatures`);
     const parentSignatures = [];
     const parentResolution = girClass.resolveParents().extends();
     if (parentResolution && parentResolution.node instanceof IntrospectedClass) {
@@ -22940,20 +23032,22 @@ var SignalGenerator = class {
       return interfaceTypeIdentifier ? `${interfaceTypeIdentifier}.SignalSignatures` : null;
     }).filter((sig) => !!sig);
     parentSignatures.push(...interfaceSignatures);
+    let signatureHead;
     if (parentSignatures.length > 0) {
-      def.push(` extends ${parentSignatures.join(", ")} {`);
+      signatureHead = `${indent}interface SignalSignatures extends ${parentSignatures.join(", ")} {`;
     } else {
       const isGObjectObject = girClass.name === "Object" && girClass.namespace.namespace === "GObject";
       if (isGObjectObject) {
-        def.push(" {");
+        signatureHead = `${indent}interface SignalSignatures {`;
       } else {
         const gobjectNamespace = this.namespace.assertInstalledImport("GObject");
         const gobjectObjectClass = gobjectNamespace.assertClass("Object");
         const gobjectRef = gobjectObjectClass.getType().resolveIdentifier(this.namespace, this.config)?.print(this.namespace, this.config);
         const fallbackRef = gobjectRef ? `${gobjectRef}.SignalSignatures` : "GObject.Object.SignalSignatures";
-        def.push(` extends ${fallbackRef} {`);
+        signatureHead = `${indent}interface SignalSignatures extends ${fallbackRef} {`;
       }
     }
+    def.push(signatureHead);
     const allSignals = girClass.getAllSignals();
     allSignals.forEach((signalInfo) => {
       let cbType;
@@ -22999,7 +23093,6 @@ var SignalGenerator = class {
       def.push(`${indent}    ${signalKey}: ${cbType};`);
     });
     def.push(`${indent}}`);
-    def.push("");
     return def;
   }
   /**
@@ -23025,8 +23118,7 @@ var SignalGenerator = class {
       `${indent} * It is not defined at runtime and should not be accessed in JS code.`,
       `${indent} * @internal`,
       `${indent} */`,
-      `${indent}$signals: ${girClass.name}.SignalSignatures;`,
-      ""
+      `${indent}$signals: ${girClass.name}.SignalSignatures;`
     ];
   }
   /**
@@ -23056,27 +23148,32 @@ var SignalGenerator = class {
     const filteredFunctions = filterConflicts(girClass.namespace, girClass, signalFunctions, 0 /* DELETE */);
     const allowedNames = new Set(filteredFunctions.map((f) => f.name));
     const gobjectRef = this.namespace.namespace === "GObject" ? "" : "GObject.";
-    const methods = [];
+    const groups = [];
     if (allowedNames.has("connect")) {
-      methods.push(
+      groups.push([
         SIGNAL_JSDOC,
         `connect<K extends keyof ${girClass.name}.SignalSignatures>(signal: K, callback: ${gobjectRef}SignalCallback<this, ${girClass.name}.SignalSignatures[K]>): number;`,
         "connect(signal: string, callback: (...args: any[]) => any): number;"
-      );
+      ]);
     }
     if (allowedNames.has("connect_after")) {
-      methods.push(
+      groups.push([
         SIGNAL_JSDOC,
         `connect_after<K extends keyof ${girClass.name}.SignalSignatures>(signal: K, callback: ${gobjectRef}SignalCallback<this, ${girClass.name}.SignalSignatures[K]>): number;`,
         "connect_after(signal: string, callback: (...args: any[]) => any): number;"
-      );
+      ]);
     }
     if (allowedNames.has("emit")) {
-      methods.push(
+      groups.push([
         SIGNAL_JSDOC,
         `emit<K extends keyof ${girClass.name}.SignalSignatures>(signal: K, ...args: ${gobjectRef}GjsParameters<${girClass.name}.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;`,
         "emit(signal: string, ...args: any[]): void;"
-      );
+      ]);
+    }
+    const methods = [];
+    for (const group of groups) {
+      if (methods.length > 0) methods.push("");
+      methods.push(...group);
     }
     return methods;
   }
@@ -23285,37 +23382,37 @@ var ModuleGenerator = class _ModuleGenerator extends FormatGenerator {
   generateClassCallback(node) {
     return this.generateCallback(node);
   }
-  generateConstructor(node) {
+  generateConstructor(node, indentCount = 0) {
     const Parameters = this.generateParameters(node.parameters);
-    return [`constructor(${Parameters});`];
+    const indent = generateIndent(indentCount);
+    return [`${indent}constructor(${Parameters});`];
   }
-  generateDirectAllocationConstructor(node) {
-    const ConstructorFields = node.parameters.map((param) => param.asField().asString(this)).join("\n");
-    return [
-      `
-    constructor(properties?: Partial<{
-      ${ConstructorFields}
-    }>);`
-    ];
+  generateDirectAllocationConstructor(node, indentCount = 1) {
+    const indent = generateIndent(indentCount);
+    const fieldIndent = generateIndent(indentCount + 1);
+    const constructorFields = node.parameters.flatMap((param) => param.asField().asString(this)).flatMap((line) => line.split("\n")).map((line) => line.replace(/^\s+/, "")).filter((line) => line.length > 0).map((line) => `${fieldIndent}${line}`).join("\n");
+    return ["", `${indent}constructor(properties?: Partial<{`, constructorFields, `${indent}}>);`];
   }
   generateParameters(parameters) {
     return parameters.flatMap((p) => {
       return p.asString(this);
     }).join(", ");
   }
-  generateConstructorFunction(node) {
+  generateConstructorFunction(node, indentCount = 0) {
     const { namespace, options: options2 } = this;
     const Parameters = this.generateParameters(node.parameters);
+    const indent = generateIndent(indentCount);
     const invalid = isInvalid(node.name);
     const name = invalid ? `["${node.name}"]` : node.name;
     const warning = node.getWarning();
     const genericTypes = this.generateGenericParameters(node.generics);
-    return [
-      `${warning ? `${warning}
-` : ""}`,
-      ...this.addGirDocComment(node.doc),
-      `static ${name}${genericTypes}(${Parameters}): ${node.return().resolve(namespace, options2).rootPrint(namespace, options2)};`
-    ];
+    const lines = [];
+    if (warning) lines.push(`${indent}${warning}`);
+    lines.push(...this.addGirDocComment(node.doc, [], indentCount));
+    lines.push(
+      `${indent}static ${name}${genericTypes}(${Parameters}): ${node.return().resolve(namespace, options2).rootPrint(namespace, options2)};`
+    );
+    return lines;
   }
   generateRecord(node) {
     const structFor = node.structFor;
@@ -23360,25 +23457,30 @@ var ModuleGenerator = class _ModuleGenerator extends FormatGenerator {
       })
     );
     const gtypeNamespace = namespace.namespace === "GObject" ? "" : "GObject.";
-    return [
-      `export interface ${node.name}Namespace {
-      ${isGObject ? `$gtype: ${gtypeNamespace}GType<${node.name}>;` : ""}
-      prototype: ${node.name};
-      ${staticFields.length > 0 ? staticFields.flatMap((sf) => sf.asString(this)).join("\n") : ""}
-      ${staticFunctions.length > 0 ? staticFunctions.flatMap((sf) => {
-        return sf.asClassFunction(node).asString(this);
-      }).join("\n") : ""}    
-      }`
-    ];
+    const bodyIndent = generateIndent(1);
+    const bodyLines = [];
+    if (isGObject) bodyLines.push(`${bodyIndent}$gtype: ${gtypeNamespace}GType<${node.name}>;`);
+    bodyLines.push(`${bodyIndent}prototype: ${node.name};`);
+    for (const sf of staticFields) {
+      for (const line of sf.asString(this)) {
+        if (line.length === 0) continue;
+        bodyLines.push(`${bodyIndent}${line.replace(/^\s+/, "")}`);
+      }
+    }
+    for (const sf of staticFunctions) {
+      for (const line of sf.asClassFunction(node).asString(this)) {
+        if (line.length === 0) continue;
+        bodyLines.push(`${bodyIndent}${line.replace(/^\s+/, "")}`);
+      }
+    }
+    return [`export interface ${node.name}Namespace {`, ...bodyLines, "}"];
   }
   generateInterfaceDeclaration(node) {
     return [
-      `
-
-export const ${node.name}: ${node.name}Namespace & {
-        new (): ${node.name} // This allows \`obj instanceof ${node.name}\`
-    }
-`
+      "",
+      `export const ${node.name}: ${node.name}Namespace & {`,
+      `    new (): ${node.name}; // This allows \`obj instanceof ${node.name}\``,
+      "};"
     ];
   }
   generateError(node) {
@@ -23441,6 +23543,12 @@ export const ${node.name}: ${node.name}Namespace & {
     if (tsProp.constructOnly) propTags.push({ tagName: "construct-only", paramName: "", text: "" });
     else if (tsProp.readable && !tsProp.writable) propTags.push({ tagName: "read-only", paramName: "", text: "" });
     else if (tsProp.writable && !tsProp.readable) propTags.push({ tagName: "write-only", paramName: "", text: "" });
+    if (tsProp.defaultValue !== void 0)
+      propTags.push({
+        tagName: "default",
+        paramName: "",
+        text: convertCDefaultValue(tsProp.defaultValue, this.namespace)
+      });
     desc.push(...this.addGirDocComment(tsProp.doc, propTags, indentCount));
     const indent = generateIndent(indentCount);
     const name = generateMemberName(tsProp);
@@ -23527,13 +23635,16 @@ export const ${node.name}: ${node.name}Namespace & {
       }
     }
     const typeStr = this.generateDirectedType(type, "out" /* Out */);
-    desc.push(`${indent}${commentOut}${staticStr}${readonly}${name}${affix}: ${typeStr}`);
+    desc.push(`${indent}${commentOut}${staticStr}${readonly}${name}${affix}: ${typeStr};`);
     return desc;
   }
   generateProperties(tsProps, comment, indentCount = 0) {
     const def = [];
     for (const tsProp of tsProps) {
-      def.push(...this.generateProperty(tsProp, false, indentCount));
+      const propLines = this.generateProperty(tsProp, false, indentCount);
+      if (propLines.length === 0) continue;
+      if (def.length > 0) def.push("");
+      def.push(...propLines);
     }
     if (def.length > 0) {
       def.unshift(...addInfoComment(comment, indentCount));
@@ -23543,7 +23654,10 @@ export const ${node.name}: ${node.name}Namespace & {
   generateFields(tsProps, comment, indentCount = 0) {
     const def = [];
     for (const tsProp of tsProps) {
-      def.push(...this.generateField(tsProp));
+      const fieldLines = this.generateField(tsProp, indentCount);
+      if (fieldLines.length === 0) continue;
+      if (def.length > 0) def.push("");
+      def.push(...fieldLines);
     }
     if (def.length > 0) {
       def.unshift(...addInfoComment(comment, indentCount));
@@ -23723,8 +23837,8 @@ export const ${node.name}: ${node.name}Namespace & {
     }
     return typeStr;
   }
-  generateClassFunction(node) {
-    return this.generateFunction(node);
+  generateClassFunction(node, indentCount = 0) {
+    return this.generateFunction(node, indentCount);
   }
   generateFunction(tsFunction, indentCount = 0) {
     const def = [];
@@ -23780,14 +23894,17 @@ export const ${node.name}: ${node.name}Namespace & {
     def.push(
       `${indent}${commentOut}${exportStr}${staticStr}${globalStr}${name}${genericStr}(${inParamsDef.join(
         ", "
-      )})${retSep} ${returnType}`
+      )})${retSep} ${returnType};`
     );
     return def;
   }
   generateFunctions(tsFunctions, indentCount = 1, comment) {
     const def = [];
     for (const girFunction of tsFunctions) {
-      def.push(...this.generateFunction(girFunction, indentCount));
+      const fnLines = this.generateFunction(girFunction, indentCount);
+      if (fnLines.length === 0) continue;
+      if (def.length > 0) def.push("");
+      def.push(...fnLines);
     }
     if (def.length > 0) {
       def.unshift(...addInfoComment(comment, indentCount));
@@ -23813,7 +23930,7 @@ export const ${node.name}: ${node.name}Namespace & {
     }
     const interfaceHead = `${name}${genericParameters}`;
     def.push(this.generateExport("interface", `${interfaceHead}`, "{", indentCount));
-    def.push(`${indentBody}(${inParamsDef.join(", ")}): ${returnTypeStr}`);
+    def.push(`${indentBody}(${inParamsDef.join(", ")}): ${returnTypeStr};`);
     def.push(`${indent}}`);
     return def;
   }
@@ -23883,7 +24000,7 @@ export const ${node.name}: ${node.name}Namespace & {
     const exp = !this.config.noNamespace ? "" : "export ";
     const ComputedName = generateMemberName(tsConst);
     const typeStr = this.generateType(resolveDirectedType(tsConst.type, "out" /* Out */) ?? tsConst.type);
-    desc.push(`${indent}${exp}const ${ComputedName}: ${typeStr}`);
+    desc.push(`${indent}${exp}const ${ComputedName}: ${typeStr};`);
     return desc;
   }
   generateAlias(girAlias, indentCount = 0) {
@@ -23905,7 +24022,7 @@ export const ${node.name}: ${node.name}Namespace & {
     }).join(", ");
     const generics = genericList ? `<${genericList}>` : "";
     const exp = !this.config.noNamespace ? "" : "export ";
-    desc.push(`${indent}${exp}type ${girAlias.name}${generics} = ${girAlias.type.print(this.namespace, this.config)}`);
+    desc.push(`${indent}${exp}type ${girAlias.name}${generics} = ${girAlias.type.print(this.namespace, this.config)};`);
     return desc;
   }
   generateConstructPropsInterface(girClass, indentCount = 0) {
@@ -23937,10 +24054,11 @@ export const ${node.name}: ${node.name}Namespace & {
     }
     def.push(...addInfoComment("Constructor properties interface", indentCount));
     const { props } = girClass;
-    const ConstructorProps = filterConflicts(girClass.namespace, girClass, props, 1 /* PRESERVE */).flatMap((v) => v.asString(this, true)).join("\n    ");
+    const memberIndent = generateIndent(indentCount + 1);
+    const constructorPropMembers = filterConflicts(girClass.namespace, girClass, props, 1 /* PRESERVE */).flatMap((v) => v.asString(this, true)).map((m) => `${memberIndent}${m}`).join("\n");
     def.push(`${indent}${exp}interface ${constructPropInterfaceName}${genericTypes} ${ext} {`);
-    def.push(ConstructorProps);
-    def.push(`${indent}}`, "");
+    def.push(constructorPropMembers);
+    def.push(`${indent}}`);
     return def;
   }
   generateClassStaticFields(girClass, indentCount = 1) {
@@ -24031,22 +24149,23 @@ export const ${node.name}: ${node.name}Namespace & {
   }
   generateClassConstructors(girClass, indentCount = 1) {
     const def = [];
+    const indent = generateIndent(indentCount);
     if (girClass.mainConstructor instanceof IntrospectedDirectAllocationConstructor)
-      def.push(...this.generateDirectAllocationConstructor(girClass.mainConstructor));
+      def.push(...this.generateDirectAllocationConstructor(girClass.mainConstructor, indentCount));
     else if (girClass.mainConstructor instanceof IntrospectedConstructor)
-      def.push(...this.generateConstructor(girClass.mainConstructor));
-    else if (girClass.namespace.namespace === "GObject" && girClass.name === "Object" || girClass.someParent((p) => p.namespace.namespace === "GObject" && p.name === "Object"))
-      def.push(`
-constructor(properties?: Partial<${girClass.name}.ConstructorProps>, ...args: any[]);
-`);
-    if (girClass instanceof IntrospectedClass && (!girClass.__ts__indexSignature || girClass.__ts__indexSignature.includes("[key: string]: any"))) {
-      def.push("_init(...args: any[]): void;\n");
+      def.push(...this.generateConstructor(girClass.mainConstructor, indentCount));
+    else if (girClass.namespace.namespace === "GObject" && girClass.name === "Object" || girClass.someParent((p) => p.namespace.namespace === "GObject" && p.name === "Object")) {
+      def.push(`${indent}constructor(properties?: Partial<${girClass.name}.ConstructorProps>, ...args: any[]);`);
+    }
+    const hasInit = girClass instanceof IntrospectedClass && (!girClass.__ts__indexSignature || girClass.__ts__indexSignature.includes("[key: string]: any"));
+    if (hasInit) {
+      if (def.length > 0) def.push("");
+      def.push(`${indent}_init(...args: any[]): void;`);
+    }
+    for (const constructorFunction of filterFunctionConflict(girClass.parent, girClass, girClass.constructors, [])) {
+      if (def.length > 0) def.push("");
+      def.push(...this.generateConstructorFunction(constructorFunction, indentCount));
     }
-    def.push(
-      ...filterFunctionConflict(girClass.parent, girClass, girClass.constructors, []).flatMap(
-        (constructorFunction) => this.generateConstructorFunction(constructorFunction)
-      )
-    );
     if (def.length) {
       def.unshift(...addInfoComment("Constructors", indentCount));
     }
@@ -24342,7 +24461,8 @@ ${girClass.__ts__indexSignature}
         def.push(this.generateExport("class", classHead, "{"));
       }
       const gtypeNamespace = this.namespace.namespace === "GObject" ? "" : "GObject.";
-      def.push(`static $gtype: ${gtypeNamespace}GType<${girClass.gtype}>;`);
+      const classBodyIndent = generateIndent(1);
+      def.push(`${classBodyIndent}static $gtype: ${gtypeNamespace}GType<${girClass.gtype}>;`);
       if (girClass.__ts__indexSignature) {
         def.push(`
 ${girClass.__ts__indexSignature}
@@ -24362,6 +24482,8 @@ ${girClass.__ts__indexSignature}
         const rawProperties = girClass.implementedProperties();
         const rawMethods = girClass.implementedMethods(rawProperties);
         const selfName = `${girClass.namespace.namespace}.${girClass.name}`;
+        const memberIndent = generateIndent(1);
+        const indentMember = (lines) => lines.map((line) => line.length === 0 ? line : `${memberIndent}${line}`);
         const propsBySource = groupBySource(rawProperties);
         for (const [source, props] of propsBySource) {
           const copied = props.map((p) => p.copy({ parent: girClass }));
@@ -24371,7 +24493,8 @@ ${girClass.__ts__indexSignature}
               if (source !== selfName) {
                 injectInheritedTags(memberLines, source);
               }
-              def.push(...memberLines);
+              def.push("");
+              def.push(...indentMember(memberLines));
             }
           }
         }
@@ -24388,7 +24511,8 @@ ${girClass.__ts__indexSignature}
               if (source !== selfName) {
                 injectInheritedTags(memberLines, source);
               }
-              def.push(...memberLines);
+              def.push("");
+              def.push(...indentMember(memberLines));
             }
           }
         }
@@ -24473,11 +24597,13 @@ ${girClass.__ts__indexSignature}
     }
     if (girModule.members) {
       for (const m of girModule.members.values()) {
-        out.push(
-          ...(Array.isArray(m) ? m : [m]).flatMap((m2) => m2 ?? []).filter((m2) => m2.emit).flatMap((m2) => m2.asString(this) ?? "")
-        );
+        const memberLines = (Array.isArray(m) ? m : [m]).flatMap((m2) => m2 ?? []).filter((m2) => m2.emit).flatMap((m2) => m2.asString(this) ?? "");
+        if (memberLines.length === 0) continue;
+        if (out.length > 0) out.push("");
+        out.push(...memberLines);
       }
     }
+    if (out.length > 0) out.push("");
     out.push(
       ...this.generateConst(
         new IntrospectedConstant({
@@ -24505,6 +24631,7 @@ ${girClass.__ts__indexSignature}
         }),
         0
       ),
+      "",
       ...this.generateConst(
         new IntrospectedConstant({
           doc: printGirDocComment(
@@ -24531,6 +24658,12 @@ ${girClass.__ts__indexSignature}
     if (overrideSuffix) {
       out.push("", overrideSuffix);
     }
+    if (!this.config.noNamespace) {
+      const indent = generateIndent(1);
+      for (let i = 0; i < out.length; i++) {
+        out[i] = out[i].split("\n").map((line) => line.length === 0 ? line : `${indent}${line}`).join("\n");
+      }
+    }
     return Promise.resolve(out);
   }
   /**
@@ -25871,6 +26004,7 @@ import {
   normalizePath,
   ReferenceReflection,
   ReflectionCategory,
+  ReflectionKind,
   Serializer,
   TSConfigReader
 } from "typedoc";
@@ -26468,19 +26602,59 @@ var TypeDocPipeline = class {
   }
   /**
    * Extract a human-readable source name from an inherited member's `inheritedFrom`.
-   * e.g. `"Window.accessible_role"` → looks up parent to get `"Gtk.Window"`.
+   *
+   * Two TypeDoc quirks are handled:
+   *
+   * 1. Per-class phantom inheritance chain. For `Window extends Widget extends
+   *    InitiallyUnowned extends Object`, Window's `bind_property.inheritedFrom`
+   *    points to `Widget.bind_property` (itself inherited from
+   *    `InitiallyUnowned.bind_property`), not directly to the original definer.
+   *    Walking the chain transitively yields the most-original visible source,
+   *    matching gi-docgen's upstream documentation convention. When the chain
+   *    crosses a package boundary the reference can't be resolved at runtime
+   *    (target=-1), but the reference's `name` field still records the
+   *    qualified original definer.
+   *
+   * 2. Accessor signatures. For an inherited accessor like Widget.cursor,
+   *    `inheritedFrom.reflection` may be the get/set signature whose `parent`
+   *    is the Accessor reflection (`Gtk.Widget.cursor`), not the class. Using
+   *    that name verbatim creates a per-property "Inherited from
+   *    Widget.cursor" section instead of a single "Inherited from Gtk.Widget"
+   *    section. Walking up to the nearest containing class/interface fixes it.
    */
   extractInheritedSourceName(child) {
     if (!child.inheritedFrom) return null;
-    const target = child.inheritedFrom.reflection;
-    if (target?.parent) {
-      const parent = target.parent;
-      const fullName = parent.getFullName();
+    let target = child.inheritedFrom.reflection;
+    let unresolvedBoundaryName = target ? void 0 : child.inheritedFrom.name;
+    const seen = /* @__PURE__ */ new Set();
+    while (target?.isDeclaration() && target.inheritedFrom) {
+      if (!target.inheritedFrom.reflection) {
+        unresolvedBoundaryName = target.inheritedFrom.name;
+        break;
+      }
+      if (seen.has(target.id)) break;
+      seen.add(target.id);
+      target = target.inheritedFrom.reflection;
+    }
+    if (unresolvedBoundaryName) {
+      const lastDot2 = unresolvedBoundaryName.lastIndexOf(".");
+      if (lastDot2 > 0) return unresolvedBoundaryName.slice(0, lastDot2);
+    }
+    if (target) {
+      let owner = target.parent;
+      while (owner && !owner.kindOf(ReflectionKind.ClassOrInterface)) {
+        owner = owner.parent;
+      }
+      const fullName = owner?.getFullName();
       if (fullName) return fullName;
+      if (target.parent) {
+        const parentName = target.parent.getFullName();
+        if (parentName) return parentName;
+      }
     }
     const name = child.inheritedFrom.name;
-    const dotIdx = name.indexOf(".");
-    return dotIdx > 0 ? name.slice(0, dotIdx) : name;
+    const lastDot = name.lastIndexOf(".");
+    return lastDot > 0 ? name.slice(0, lastDot) : name;
   }
   /**
    * Fix ReferenceReflection targets broken by TypeDoc's handling of
@@ -26705,10 +26879,10 @@ import { JSX } from "typedoc";
 var giDocgenFooter = (_context) => JSX.createElement(JSX.Fragment, null);
 
 // ../typedoc-theme/src/partials/header.ts
-import { JSX as JSX2, ReflectionKind as ReflectionKind2 } from "typedoc";
+import { JSX as JSX2, ReflectionKind as ReflectionKind3 } from "typedoc";
 
 // ../typedoc-theme/src/utils.ts
-import { ReflectionKind } from "typedoc";
+import { ReflectionKind as ReflectionKind2 } from "typedoc";
 function getGirTypeFromComment(refl) {
   const comment = refl.comment;
   if (!comment) return void 0;
@@ -26813,17 +26987,17 @@ function getGirNamespaceMetadata(reflection) {
   const mod = findOwningModule(reflection) ?? reflection;
   return mod.girNamespaceMetadata;
 }
-var COMPANION_OWNER_KINDS = ReflectionKind.Class | ReflectionKind.Interface | ReflectionKind.Enum;
+var COMPANION_OWNER_KINDS = ReflectionKind2.Class | ReflectionKind2.Interface | ReflectionKind2.Enum;
 function findCompanionNamespace(refl) {
   if (!refl.kindOf(COMPANION_OWNER_KINDS)) return void 0;
   const parent = refl.parent;
   if (!parent || !("children" in parent)) return void 0;
   const siblings = parent.children;
   if (!siblings) return void 0;
-  return siblings.find((child) => child !== refl && child.kindOf(ReflectionKind.Namespace) && child.name === refl.name);
+  return siblings.find((child) => child !== refl && child.kindOf(ReflectionKind2.Namespace) && child.name === refl.name);
 }
 function isCompanionNamespace(nsRefl) {
-  if (!nsRefl.kindOf(ReflectionKind.Namespace)) return false;
+  if (!nsRefl.kindOf(ReflectionKind2.Namespace)) return false;
   const parent = nsRefl.parent;
   if (!parent || !("children" in parent)) return false;
   const siblings = parent.children;
@@ -26840,7 +27014,7 @@ function getHierarchyRoots(project) {
   const queue = [project];
   for (let i = 0; i < queue.length; i++) {
     const refl = queue[i];
-    if (refl.kindOf(ReflectionKind.Class)) {
+    if (refl.kindOf(ReflectionKind2.Class)) {
       const decl = refl;
       if (decl.typeHierarchy) {
         roots.push(decl);
@@ -26915,7 +27089,7 @@ var giDocgenHeader = (context, props) => {
   } else if (props.model.isDocument()) {
     renderTitle = headings.document;
   } else {
-    kindString = ReflectionKind2.singularString(props.model.kind);
+    kindString = ReflectionKind3.singularString(props.model.kind);
   }
   if (kindString) {
     const girType = getGirTypeFromComment(props.model);
@@ -26933,7 +27107,7 @@ var giDocgenHeader = (context, props) => {
     refl = refl.parent;
   }
   path.reverse();
-  const isModulePage = !props.model.isProject() && props.model.kindOf(ReflectionKind2.Module) && !props.model.parent?.parent;
+  const isModulePage = !props.model.isProject() && props.model.kindOf(ReflectionKind3.Module) && !props.model.parent?.parent;
   const nsMeta = isModulePage ? getGirNamespaceMetadata(props.model) : void 0;
   return JSX2.createElement(
     "div",
@@ -27166,7 +27340,7 @@ var giDocgenLayout = (context, template2, props) => JSX3.createElement(
 import {
   JSX as JSX4,
   ReferenceReflection as ReferenceReflection2,
-  ReflectionKind as ReflectionKind3
+  ReflectionKind as ReflectionKind4
 } from "typedoc";
 function isNoneSection(section) {
   return section.title.toLocaleLowerCase() === "none";
@@ -27274,11 +27448,11 @@ function giDocgenModuleReflection(context, mod) {
     const parent = mod.parent;
     const siblings = parent && "children" in parent ? parent.children : void 0;
     const companionOwner = siblings?.find(
-      (child) => child !== mod && child.kindOf(ReflectionKind3.Class | ReflectionKind3.Interface | ReflectionKind3.Enum) && child.name === mod.name
+      (child) => child !== mod && child.kindOf(ReflectionKind4.Class | ReflectionKind4.Interface | ReflectionKind4.Enum) && child.name === mod.name
     );
     if (companionOwner) {
       const ownerUrl = context.urlTo(companionOwner);
-      const kindName = companionOwner.kindOf(ReflectionKind3.Enum) ? "enum" : companionOwner.kindOf(ReflectionKind3.Interface) ? "interface" : "class";
+      const kindName = companionOwner.kindOf(ReflectionKind4.Enum) ? "enum" : companionOwner.kindOf(ReflectionKind4.Interface) ? "interface" : "class";
       return JSX4.createElement(
         JSX4.Fragment,
         null,
@@ -27351,7 +27525,7 @@ function giDocgenModuleReflection(context, mod) {
       );
     }),
     // 3. README content — rendered at the bottom in a collapsible section
-    mod.isDeclaration() && mod.kind === ReflectionKind3.Module && !!mod.readme?.length && (() => {
+    mod.isDeclaration() && mod.kind === ReflectionKind4.Module && !!mod.readme?.length && (() => {
       const readmeTitle = "Readme";
       context.page.startNewSection(readmeTitle);
       return JSX4.createElement(
@@ -27573,10 +27747,10 @@ var giDocgenPageSidebar = (context, props) => JSX7.createElement(JSX7.Fragment,
 import { readFileSync as readFileSync7 } from "node:fs";
 import { dirname as dirname8, join as join14 } from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
-import { i18n, JSX as JSX8, ReflectionKind as ReflectionKind4 } from "typedoc";
+import { i18n, JSX as JSX8, ReflectionKind as ReflectionKind5 } from "typedoc";
 function getTsForGirVersion() {
   if (true) {
-    return "4.0.0-rc.6";
+    return "4.0.0-rc.8";
   }
   const __dirname3 = dirname8(fileURLToPath5(import.meta.url));
   return JSON.parse(readFileSync7(join14(__dirname3, "..", "..", "package.json"), "utf8")).version;
@@ -27597,9 +27771,9 @@ function giDocgenModuleInfo(context, mod, nsMeta) {
     );
   });
   const childNamespaces = mod.children?.filter(
-    (child) => child.kindOf(ReflectionKind4.Namespace) && child.name !== "default" && !isCompanionNamespace(child)
+    (child) => child.kindOf(ReflectionKind5.Namespace) && child.name !== "default" && !isCompanionNamespace(child)
   );
-  const childModules = mod.children?.filter((child) => child.kindOf(ReflectionKind4.Module) && child.name !== "default");
+  const childModules = mod.children?.filter((child) => child.kindOf(ReflectionKind5.Module) && child.name !== "default");
   const packageVersion = mod.packageVersion || nsMeta.packageVersion;
   const pageModel = context.page.model;
   const isChildActive = (child) => {
@@ -27809,7 +27983,7 @@ var giDocgenToolbar = (context, _props) => {
 import {
   DeclarationReflection as DeclarationReflection3,
   JSX as JSX10,
-  ReflectionKind as ReflectionKind5,
+  ReflectionKind as ReflectionKind6,
   i18n as i18n2
 } from "typedoc";
 function hasTypeParameters(reflection) {
@@ -27882,10 +28056,10 @@ function renderCompanionNamespaceSection(context, companionNs) {
   );
 }
 function giDocgenReflectionTemplate(context, props) {
-  if (props.model.kindOf(ReflectionKind5.TypeAlias | ReflectionKind5.Variable) && props.model instanceof DeclarationReflection3 && props.model.type) {
+  if (props.model.kindOf(ReflectionKind6.TypeAlias | ReflectionKind6.Variable) && props.model instanceof DeclarationReflection3 && props.model.type) {
     return context.memberDeclaration(props.model);
   }
-  if (props.model.kindOf(ReflectionKind5.ExportContainer) && (props.model.isDeclaration() || props.model.isProject())) {
+  if (props.model.kindOf(ReflectionKind6.ExportContainer) && (props.model.isDeclaration() || props.model.isProject())) {
     return context.moduleReflection(props.model);
   }
   const companionNs = props.model instanceof DeclarationReflection3 ? findCompanionNamespace(props.model) : void 0;
@@ -28161,21 +28335,9 @@ var HtmlDocGenerator = class _HtmlDocGenerator {
 };
 
 // src/formatters/typescript-formatter.ts
-import prettier from "prettier";
-var logger4 = new Logger(false, "TypeScriptFormatter");
 var TypeScriptFormatter = class extends Formatter {
   format(input2) {
-    try {
-      return prettier.format(input2, {
-        singleQuote: true,
-        parser: "typescript",
-        printWidth: 120,
-        tabWidth: 4
-      });
-    } catch (error) {
-      logger4.warn("Failed to format with prettier, returning original input", error);
-      return Promise.resolve(input2);
-    }
+    return Promise.resolve(input2);
   }
 };
 
@@ -28265,7 +28427,7 @@ var GenerationHandler = class {
 async function runGenerationCommand(args, options2) {
   const config = await load(args);
   const generateConfig = getOptionsGeneration(config);
-  const logger6 = new Logger(true, options2.loggerName);
+  const logger5 = new Logger(true, options2.loggerName);
   const registry = new NSRegistry();
   options2.configureRegistry?.(registry);
   const moduleLoader = new ModuleLoader(generateConfig, registry);
@@ -28277,7 +28439,7 @@ async function runGenerationCommand(args, options2) {
       config.ignoreVersionConflicts
     );
     if (keep.length === 0) {
-      logger6.error(ERROR_NO_MODULES_FOUND(config.girDirectories));
+      logger5.error(ERROR_NO_MODULES_FOUND(config.girDirectories));
       return;
     }
     tsForGir = new GenerationHandler(generateConfig, options2.generatorType, registry);
@@ -28403,7 +28565,7 @@ var json2 = {
 // src/commands/list.ts
 var command7 = "list [modules..]";
 var description7 = "Lists all available GIR modules";
-var logger5 = new Logger(true, "ListCommand");
+var logger4 = new Logger(true, "ListCommand");
 var examples7 = [
   [`${APP_NAME} list -g ./vala-girs/gir-1.0`, "Lists all available GIR modules in ./vala-girs/gir-1.0"],
   [
@@ -28420,35 +28582,35 @@ var handler7 = async (args) => {
   const { grouped, failed } = await moduleLoader.getModules(config.modules, config.ignore);
   const moduleGroups = Object.values(grouped);
   if (Object.keys(grouped).length === 0) {
-    return logger5.error(ERROR_NO_MODULES_FOUND(config.girDirectories));
+    return logger4.error(ERROR_NO_MODULES_FOUND(config.girDirectories));
   }
   const conflictModules = moduleGroups.filter((moduleGroup) => moduleGroup.hasConflict);
   const allModules = moduleGroups.filter((moduleGroup) => !moduleGroup.hasConflict);
-  logger5.info("\nSearch for gir files in:");
+  logger4.info("\nSearch for gir files in:");
   for (const dir of config.girDirectories) {
-    logger5.white(`- ${dir}`);
+    logger4.white(`- ${dir}`);
   }
-  logger5.info("\nAvailable Modules:");
+  logger4.info("\nAvailable Modules:");
   for (const moduleGroup of allModules) {
     for (const module of moduleGroup.modules) {
-      logger5.white(`- ${module.packageName}`);
-      logger5.gray(`  - ${module.path}`);
+      logger4.white(`- ${module.packageName}`);
+      logger4.gray(`  - ${module.path}`);
     }
   }
   if (conflictModules.length > 0) {
-    logger5.danger("\nConflicts:");
+    logger4.danger("\nConflicts:");
     for (const moduleGroup of conflictModules) {
-      logger5.white(`- ${moduleGroup.namespace}`);
+      logger4.white(`- ${moduleGroup.namespace}`);
       for (const conflictModule of moduleGroup.modules) {
-        logger5.white(`  - ${conflictModule.packageName}`);
-        logger5.gray(`  - ${conflictModule.path}`);
+        logger4.white(`  - ${conflictModule.packageName}`);
+        logger4.gray(`  - ${conflictModule.path}`);
       }
     }
   }
   if (failed.length > 0) {
-    logger5.danger("\nDependencies not found:");
+    logger4.danger("\nDependencies not found:");
     for (const fail of failed) {
-      logger5.white(`- ${fail}`);
+      logger4.white(`- ${fail}`);
     }
   }
 };
@@ -28461,7 +28623,14 @@ var list = {
 };
 
 // src/start.ts
-void yargs(hideBin(process.argv)).scriptName(APP_NAME).strict().usage(APP_USAGE).version(APP_VERSION).command(analyze).command(create).command(generate).command(json2).command(list).command(copy).command(doc).demandCommand(1).help().argv;
+try {
+  await yargs(hideBin(process.argv)).scriptName(APP_NAME).strict().usage(APP_USAGE).version(APP_VERSION).exitProcess(false).fail(false).command(analyze).command(create).command(generate).command(json2).command(list).command(copy).command(doc).demandCommand(1).help().parseAsync();
+} catch (err) {
+  const message = err instanceof Error ? err.message : String(err);
+  process.stderr.write(`${message}
+`);
+  process.exitCode = 1;
+}
 /*! Bundled license information:
 
 lodash/lodash.js:

package/dist-templates/types-locally/package.json

@@ -11,7 +11,7 @@
 		"clear": "rm -rf dist @types"
 	},
 	"devDependencies": {
-		"@ts-for-gir/cli": "^4.0.0-rc.6",
+		"@ts-for-gir/cli": "^4.0.0-rc.8",
 		"esbuild": "^0.28.0",
 		"typescript": "^6.0.2"
 	}

package/dist-templates/types-npm/package.json

@@ -14,10 +14,10 @@
 		"typescript": "^6.0.2"
 	},
 	"dependencies": {
-		"@girs/adw-1": "^1.10.0-4.0.0-rc.5",
-		"@girs/gio-2.0": "^2.88.0-4.0.0-rc.5",
-		"@girs/gjs": "^4.0.0-rc.5",
-		"@girs/glib-2.0": "^2.88.0-4.0.0-rc.5",
-		"@girs/gtk-4.0": "^4.23.0-4.0.0-rc.5"
+		"@girs/adw-1": "^1.10.0-4.0.0-rc.7",
+		"@girs/gio-2.0": "^2.88.0-4.0.0-rc.7",
+		"@girs/gjs": "^4.0.0-rc.7",
+		"@girs/glib-2.0": "^2.88.0-4.0.0-rc.7",
+		"@girs/gtk-4.0": "^4.23.0-4.0.0-rc.7"
 	}
 }

package/dist-templates/types-workspace/package.json

@@ -16,7 +16,7 @@
 		"clear": "rm -rf @girs packages/*/dist"
 	},
 	"devDependencies": {
-		"@ts-for-gir/cli": "^4.0.0-rc.6",
+		"@ts-for-gir/cli": "^4.0.0-rc.8",
 		"typescript": "^6.0.2"
 	}
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ts-for-gir/cli",
-  "version": "4.0.0-rc.6",
+  "version": "4.0.0-rc.8",
   "description": "TypeScript type definition generator for GObject introspection GIR files",
   "main": "src/index.ts",
   "module": "src/index.ts",
@@ -55,14 +55,14 @@
     ".": "./src/index.ts"
   },
   "devDependencies": {
-    "@gi.ts/parser": "^4.0.0-rc.6",
-    "@ts-for-gir/generator-base": "^4.0.0-rc.6",
-    "@ts-for-gir/generator-html-doc": "^4.0.0-rc.6",
-    "@ts-for-gir/generator-json": "^4.0.0-rc.6",
-    "@ts-for-gir/generator-typescript": "^4.0.0-rc.6",
-    "@ts-for-gir/lib": "^4.0.0-rc.6",
-    "@ts-for-gir/reporter": "^4.0.0-rc.6",
-    "@ts-for-gir/tsconfig": "^4.0.0-rc.6",
+    "@gi.ts/parser": "^4.0.0-rc.8",
+    "@ts-for-gir/generator-base": "^4.0.0-rc.8",
+    "@ts-for-gir/generator-html-doc": "^4.0.0-rc.8",
+    "@ts-for-gir/generator-json": "^4.0.0-rc.8",
+    "@ts-for-gir/generator-typescript": "^4.0.0-rc.8",
+    "@ts-for-gir/lib": "^4.0.0-rc.8",
+    "@ts-for-gir/reporter": "^4.0.0-rc.8",
+    "@ts-for-gir/tsconfig": "^4.0.0-rc.8",
     "@types/ejs": "^3.1.5",
     "@types/inquirer": "^9.0.9",
     "@types/node": "^25.6.0",
@@ -72,13 +72,12 @@
   },
   "dependencies": {
     "@inquirer/prompts": "^8.4.2",
-    "@ts-for-gir/templates": "^4.0.0-rc.6",
+    "@ts-for-gir/templates": "^4.0.0-rc.8",
     "colorette": "^2.0.20",
     "cosmiconfig": "^9.0.1",
     "ejs": "^5.0.2",
     "glob": "^13.0.6",
     "inquirer": "^13.4.2",
-    "prettier": "^3.8.3",
     "typedoc": "^0.28.19",
     "yargs": "^18.0.0"
   }

package/src/formatters/typescript-formatter.ts

@@ -1,24 +1,17 @@
 /**
- * TypeScript formatter using Prettier
+ * TypeScript formatter — pass-through.
+ *
+ * The generator's templates and string-builders emit the desired output
+ * shape directly; we no longer round-trip through Prettier. This shrinks
+ * the generation pipeline (no AST parse + reprint per file), drops a
+ * heavy bundler-hostile dependency for non-Node consumers, and makes
+ * generated output deterministic without an external formatter.
  */
 
-import { Formatter, Logger } from "@ts-for-gir/lib";
-import prettier from "prettier";
-
-const logger = new Logger(false, "TypeScriptFormatter");
+import { Formatter } from "@ts-for-gir/lib";
 
 export class TypeScriptFormatter extends Formatter {
 	format(input: string): Promise<string> {
-		try {
-			return prettier.format(input, {
-				singleQuote: true,
-				parser: "typescript",
-				printWidth: 120,
-				tabWidth: 4,
-			});
-		} catch (error) {
-			logger.warn("Failed to format with prettier, returning original input", error);
-			return Promise.resolve(input);
-		}
+		return Promise.resolve(input);
 	}
 }

package/src/start.ts

@@ -4,18 +4,31 @@ import { hideBin } from "yargs/helpers";
 
 import { analyze, copy, create, doc, generate, json, list } from "./commands/index.ts";
 
-void yargs(hideBin(process.argv))
-	.scriptName(APP_NAME)
-	.strict()
-	.usage(APP_USAGE)
-	.version(APP_VERSION)
-	// TODO: Fix this
-	.command(analyze as unknown as CommandModule)
-	.command(create as unknown as CommandModule)
-	.command(generate as unknown as CommandModule)
-	.command(json as unknown as CommandModule)
-	.command(list as unknown as CommandModule)
-	.command(copy as unknown as CommandModule)
-	.command(doc as unknown as CommandModule)
-	.demandCommand(1)
-	.help().argv;
+try {
+	await yargs(hideBin(process.argv))
+		.scriptName(APP_NAME)
+		.strict()
+		.usage(APP_USAGE)
+		.version(APP_VERSION)
+		// Disable yargs's internal `process.exit` and route both success
+		// and failure through `parseAsync` + `process.exitCode` so async
+		// command handlers complete and stdout drains before the runtime
+		// (Node or the gjsify Node-compat loader on GJS) tears down.
+		.exitProcess(false)
+		.fail(false)
+		// TODO: Fix this
+		.command(analyze as unknown as CommandModule)
+		.command(create as unknown as CommandModule)
+		.command(generate as unknown as CommandModule)
+		.command(json as unknown as CommandModule)
+		.command(list as unknown as CommandModule)
+		.command(copy as unknown as CommandModule)
+		.command(doc as unknown as CommandModule)
+		.demandCommand(1)
+		.help()
+		.parseAsync();
+} catch (err) {
+	const message = err instanceof Error ? err.message : String(err);
+	process.stderr.write(`${message}\n`);
+	process.exitCode = 1;
+}