@gtkx/codegen 1.0.0 → 1.1.0

package/src/store/gi/signal.ts

@@ -1,13 +1,14 @@
 import { camelCase, sourceStringLiteral } from "@gtkx/utils";
 import type { GirClass } from "../../gir/class.js";
-import type { GirCallable, GirParameter } from "../../gir/parameter.js";
+import type { GirCallable, GirParameter, GirReturnValue } from "../../gir/parameter.js";
 import type { GirProperty } from "../../gir/property.js";
 import type { ModuleContext } from "../../writer/context.js";
+import type { Declaration } from "../../writer/module.js";
 import {
     isCellInout,
+    primaryReturnKind,
     renderDescriptor,
     renderParamDescriptor,
-    shouldOmitPrimaryReturn,
 } from "../../analysis/descriptor-render.js";
 import { tCallback, tObject, tVoid } from "../../analysis/descriptor.js";
 import {
@@ -23,7 +24,7 @@ import { renderJsDoc } from "../../writer/doc.js";
 import { indent, renderBlock, renderBracedOrEmpty } from "../../writer/emit.js";
 import { parentCompanionRef } from "./companion.js";
 import { getDoc, handlerSpec } from "./doc-spec.js";
-import { isRecordCallerOut, isRecordInout } from "./param-marshal.js";
+import { isAllocatableCallerOut, isRecordInout, renderCallerOutInstance } from "./param-marshal.js";
 
 type SignalMapSpec = {
     context: ModuleContext;
@@ -92,12 +93,18 @@ const renderSignalDeclarations = (
     klass: GirClass,
     className: string,
     isParentlessObjectSubclass: boolean,
-): string[] => {
+): Declaration[] => {
     const base = { context, klass, className, isParentlessObjectSubclass };
 
-    const declarations = [
-        renderSignalMap({ ...base, suffix: SIGNALS_SUFFIX, renderEntry: renderSignalHandlerType }),
-        renderSignalMap({ ...base, suffix: SIGNAL_EMIT_SUFFIX, renderEntry: renderSignalEmitEntry }),
+    const declarations: Declaration[] = [
+        {
+            name: `${className}${SIGNALS_SUFFIX}`,
+            code: renderSignalMap({ ...base, suffix: SIGNALS_SUFFIX, renderEntry: renderSignalHandlerType }),
+        },
+        {
+            name: `${className}${SIGNAL_EMIT_SUFFIX}`,
+            code: renderSignalMap({ ...base, suffix: SIGNAL_EMIT_SUFFIX, renderEntry: renderSignalEmitEntry }),
+        },
     ];
 
     if (
@@ -107,7 +114,7 @@ const renderSignalDeclarations = (
             klass.implements.length > 0)
     ) {
         const isRootObject = context.namespace.name === "GObject" && klass.name === "Object";
-        declarations.push(renderSignalConnectInterface(className, isRootObject));
+        declarations.push({ name: className, code: renderSignalConnectInterface(className, isRootObject) });
     }
 
     return declarations;
@@ -263,7 +270,7 @@ const renderEmitArgLiteral = (options: EmitArgOptions): { literal: string; nextA
     }
 
     if (isCallerAllocatedOut(parameter)) {
-        const value = renderCallerOutAllocation(context, parameter);
+        const value = renderCallerOutInstance(context, parameter);
 
         return {
             literal: `{ type: ${descriptor}, direction: "out", isCallerAllocated: true, value: ${value} }`,
@@ -283,10 +290,18 @@ const renderEmitArgLiteral = (options: EmitArgOptions): { literal: string; nextA
     return { literal: `{ type: ${descriptor}, value: args[${String(argIndex)}] }`, nextArgIndex: argIndex + 1 };
 };
 
+const renderEmitReturnArg = (context: ModuleContext, returnValue: GirReturnValue): string => {
+    if (primaryReturnKind(context.library, returnValue) === "void") {
+        return "";
+    }
+
+    return `, ${renderDescriptor(context, returnValue.type, returnValue.transferOwnership)}`;
+};
+
 const renderEmitCase = (context: ModuleContext, signal: GirCallable): string => {
     const params = nonVarargParameters(signal);
 
-    if (params.some((parameter) => isCallerAllocatedOut(parameter) && !isRecordCallerOut(context, parameter))) {
+    if (params.some((parameter) => isCallerAllocatedOut(parameter) && !isAllocatableCallerOut(context, parameter))) {
         return renderUnsupportedEmitCase(signal);
     }
 
@@ -301,12 +316,7 @@ const renderEmitCase = (context: ModuleContext, signal: GirCallable): string =>
         return rendered.literal;
     });
 
-    const isVoid = shouldOmitPrimaryReturn(context.library, signal.returnValue);
-
-    const returnArg = isVoid
-        ? ""
-        : `, ${renderDescriptor(context, signal.returnValue.type, signal.returnValue.transferOwnership)}`;
-
+    const returnArg = renderEmitReturnArg(context, signal.returnValue);
     const body = `return emitSignal(this, sigName, [${argLiterals.join(", ")}]${returnArg});`;
 
     return renderBlock(`case ${sourceStringLiteral(signal.name)}:`, body);
@@ -321,16 +331,6 @@ const renderUnsupportedEmitCase = (signal: GirCallable): string => {
     );
 };
 
-const renderCallerOutAllocation = (context: ModuleContext, parameter: GirParameter): string => {
-    const name = parameter.type === undefined ? undefined : context.library.nameFor(parameter.type);
-
-    if (name === undefined) {
-        throw new Error("renderCallerOutAllocation: expected a named caller-allocated out-parameter");
-    }
-
-    return `new ${context.qualify(name.namespaceName, name.typeName)}()`;
-};
-
 const renderCallback = (context: ModuleContext, signal: GirCallable): string => {
     const params = nonVarargParameters(signal);
 
@@ -338,21 +338,19 @@ const renderCallback = (context: ModuleContext, signal: GirCallable): string =>
         renderParamDescriptor(context, parameter, parameter.type, { argIndexOffset: 1 }),
     );
 
-    const isVoid = shouldOmitPrimaryReturn(context.library, signal.returnValue);
-
-    const returnDescriptor = isVoid
-        ? tVoid
-        : renderDescriptor(context, signal.returnValue.type, signal.returnValue.transferOwnership);
-
     const callbackArgs = [tObject("borrowed"), ...callbackParamDescriptors, tVoid];
     const userDataIndex = String(params.length + 1);
-    const destroy = "hasDestroy: true, destroyKind: \"closureNotify\"";
 
-    return tCallback(
-        callbackArgs,
-        returnDescriptor,
-        `{ ${destroy}, hasUserData: true, userDataIndex: ${userDataIndex} }`,
-    );
+    return tCallback({
+        argTypes: callbackArgs,
+        returns: renderDescriptor(context, signal.returnValue.type, signal.returnValue.transferOwnership),
+        options: [
+            "hasDestroy: true",
+            "destroyKind: \"closureNotify\"",
+            "hasUserData: true",
+            `userDataIndex: ${userDataIndex}`,
+        ],
+    });
 };
 
 const forEachInterfaceSignal = (

package/src/store/gi/value-marshalable.ts

@@ -15,6 +15,8 @@ const hasOwnCopySemantics = (record: GirRecord): boolean =>
     record.glibGetType !== undefined ||
     ((record.glibRefFunc ?? record.copyFunc) !== undefined && (record.glibUnrefFunc ?? record.freeFunc) !== undefined);
 
+const isOpaqueRecord = (record: GirRecord): boolean => record.opaque || record.disguised;
+
 const isValueSafeArray = (scope: Scope, type: Extract<GirType, { kind: "carray" }>): boolean =>
     type.fixedSize !== undefined && isValueSafeRef(scope, type.element, type.elementCType);
 
@@ -82,6 +84,6 @@ const isValueMarshalable = (context: ModuleContext, namespaceName: string, recor
     isValueSafeRecord({ context, seen: new Set<string>() }, namespaceName, record);
 
 const isConstructibleRecord = (context: ModuleContext, namespaceName: string, record: GirRecord): boolean =>
-    hasOwnCopySemantics(record) || isValueMarshalable(context, namespaceName, record);
+    !isOpaqueRecord(record) && (hasOwnCopySemantics(record) || isValueMarshalable(context, namespaceName, record));
 
 export { isConstructibleRecord, isValueMarshalable };

package/src/store/gi/vtable.ts

@@ -1,7 +1,8 @@
-import { pascalCase, sourceStringLiteral } from "@gtkx/utils";
-import type { GirCallback } from "../../gir/callback.js";
+import { pascalCase, sanitizeTypeIdentifier, sourceStringLiteral } from "@gtkx/utils";
 import type { GirClass, GirVirtualMethod } from "../../gir/class.js";
 import type { GirField } from "../../gir/field.js";
+import type { GirFunction } from "../../gir/function.js";
+import type { Library } from "../../gir/library.js";
 import type { GirParameter } from "../../gir/parameter.js";
 import type { GirRecord } from "../../gir/record.js";
 import type { TypeId } from "../../gir/type-id.js";
@@ -22,7 +23,9 @@ import {
     renderHandlerResultType,
 } from "../../analysis/param-structure.js";
 import { renderTsType } from "../../analysis/ts-type.js";
+import { typeKey } from "../../analysis/type-key.js";
 import { ancestorChain, type ResolvedAncestor, resolveInterfaces } from "../../gir/ancestry.js";
+import { callbackAsFunction, type GirCallback } from "../../gir/callback.js";
 import { renderJsDoc } from "../../writer/doc.js";
 import { renderBlock, renderBraced } from "../../writer/emit.js";
 import { handlerSpec, THROWS_TEXT } from "./doc-spec.js";
@@ -80,6 +83,7 @@ const UNCALLABLE_SLOT_KEYS: Set<string> = new Set([
     "vfuncSetProperty",
 ]);
 
+const VTABLE_CACHE: WeakMap<GirClass, Vtable> = new WeakMap();
 const PROTECTED_SLOT_NOTE = "It is `protected`, so only a subclass chaining up reaches it.";
 const PUBLIC_SLOT_NOTE = "Calling it from anywhere else re-enters the slot on a live instance.";
 
@@ -193,7 +197,7 @@ const attachVirtualMethods = (slots: VtableSlot[], klass: GirClass): VtableSlot[
     return slots.map((slot) => ({ ...slot, vfunc: byKey.get(slot.key) }));
 };
 
-const collectVtable = (context: ModuleContext, namespaceName: string, klass: GirClass): Vtable | undefined => {
+const buildVtable = (context: ModuleContext, namespaceName: string, klass: GirClass): Vtable | undefined => {
     const resolved = resolveVtableRecord(context, namespaceName, klass);
 
     if (resolved === undefined) {
@@ -210,10 +214,63 @@ const collectVtable = (context: ModuleContext, namespaceName: string, klass: Gir
         structName: pascalCase(resolved.typeStruct),
         kind: klass.isInterface ? "interface" : "class",
         vtableSize,
-        slots: attachVirtualMethods(slots, klass),
+        slots: disambiguateSlots(context, namespaceName, klass, attachVirtualMethods(slots, klass)),
     };
 };
 
+const collectVtable = (context: ModuleContext, namespaceName: string, klass: GirClass): Vtable | undefined => {
+    const cached = VTABLE_CACHE.get(klass);
+
+    if (cached !== undefined) {
+        return cached;
+    }
+
+    const vtable = buildVtable(context, namespaceName, klass);
+
+    if (vtable !== undefined) {
+        VTABLE_CACHE.set(klass, vtable);
+    }
+
+    return vtable;
+};
+
+const shadowedSlotKey = (klass: GirClass, slot: VtableSlot): string =>
+    `vfunc${sanitizeTypeIdentifier(klass.name)}${pascalCase(slot.field.name)}`;
+
+const slotSignatureKey = (library: Library, slot: VtableSlot): string => {
+    const [, ...parameters] = slot.callback.parameters;
+
+    const parts = parameters.map(
+        (parameter) => `${typeKey(library, parameter.type)}/${parameter.direction}/${String(parameter.nullable)}`);
+
+    return `${parts.join(",")}->${typeKey(library, slot.callback.returnValue.type)}`;
+};
+
+const isShadowingSlot = (library: Library, slot: VtableSlot, inherited: VtableSlot[]): boolean =>
+    inherited.some(
+        (other) =>
+            other.key === slot.key &&
+            slotIdentity(other) !== slotIdentity(slot) &&
+            slotSignatureKey(library, other) !== slotSignatureKey(library, slot));
+
+const disambiguateSlots = (
+    context: ModuleContext,
+    namespaceName: string,
+    klass: GirClass,
+    slots: VtableSlot[],
+): VtableSlot[] => {
+    const inherited = ancestorSlots(context, namespaceName, klass);
+
+    return slots.map((slot) =>
+        isShadowingSlot(context.library, slot, inherited) ? { ...slot, key: shadowedSlotKey(klass, slot) } : slot);
+};
+
+const ancestorSlots = (context: ModuleContext, namespaceName: string, klass: GirClass): VtableSlot[] => {
+    const [, ...ancestors] = [...ancestorChain(context.library, klass, namespaceName)];
+
+    return ancestors.flatMap((ancestor) => collectVtable(context, ancestor.namespaceName, ancestor.klass)?.slots ?? []);
+};
+
 const vfuncMemberNames = (context: ModuleContext, namespaceName: string, klass: GirClass): string[] =>
     collectVtable(context, namespaceName, klass)?.slots.map((slot) => slot.key) ?? [];
 
@@ -231,21 +288,8 @@ const renderVfuncMetadata = (context: ModuleContext, klass: GirClass): string |
 
 const slotIdentity = (slot: VtableSlot): string => `${slot.key}:${String(slot.byteOffset)}`;
 
-const inheritedSlotIdentities = (context: ModuleContext, namespaceName: string, klass: GirClass): Set<string> => {
-    const identities: Set<string> = new Set();
-    const [, ...ancestors] = [...ancestorChain(context.library, klass, namespaceName)];
-
-    for (const ancestor of ancestors) {
-        const vtable = collectVtable(context, ancestor.namespaceName, ancestor.klass);
-        const slots = vtable?.slots ?? [];
-
-        for (const slot of slots) {
-            identities.add(slotIdentity(slot));
-        }
-    }
-
-    return identities;
-};
+const inheritedSlotIdentities = (context: ModuleContext, namespaceName: string, klass: GirClass): Set<string> =>
+    new Set(ancestorSlots(context, namespaceName, klass).map((slot) => slotIdentity(slot)));
 
 const addInterfaceSlotKeys = (
     context: ModuleContext,
@@ -295,6 +339,37 @@ const protectedSlotKeys = (options: VfuncMembersOptions, slots: VtableSlot[]): S
     return new Set(slots.map((slot) => slot.key).filter((key) => !shared.has(key)));
 };
 
+const vfuncCallables = (context: ModuleContext, namespaceName: string, klass: GirClass): Map<string, GirFunction> => {
+    const members: Map<string, GirFunction> = new Map();
+
+    for (const slot of callableVfuncSlots(context, namespaceName, klass)) {
+        const [, ...parameters] = slot.callback.parameters;
+        members.set(slot.key, { ...callbackAsFunction(slot.callback), parameters });
+    }
+
+    return members;
+};
+
+const addProtectedSlotKeys = (context: ModuleContext, ancestor: ResolvedAncestor, keys: Set<string>): void => {
+    const shared = implementedSlotKeys(context, ancestor.namespaceName, ancestor.klass);
+
+    for (const slot of callableVfuncSlots(context, ancestor.namespaceName, ancestor.klass)) {
+        if (!shared.has(slot.key)) {
+            keys.add(slot.key);
+        }
+    }
+};
+
+const protectedChainSlotKeys = (context: ModuleContext, klass: GirClass): Set<string> => {
+    const keys: Set<string> = new Set();
+
+    for (const ancestor of ancestorChain(context.library, klass, context.namespace.name)) {
+        addProtectedSlotKeys(context, ancestor, keys);
+    }
+
+    return keys;
+};
+
 const callableVfuncSlots = (context: ModuleContext, namespaceName: string, klass: GirClass): VtableSlot[] => {
     const vtable = collectVtable(context, namespaceName, klass);
 
@@ -339,7 +414,7 @@ const vfuncEntries = (context: ModuleContext, namespaceName: string, klass: GirC
 
 const renderVfuncMembers = (options: VfuncMembersOptions): string[] => {
     const { context, klass, mode } = options;
-    const ownerRef = pascalCase(klass.name);
+    const ownerRef = sanitizeTypeIdentifier(klass.name);
     const slots = callableVfuncSlots(context, context.namespace.name, klass);
 
     if (slots.length === 0) {
@@ -468,7 +543,9 @@ const renderVtableSlotDescriptor = (context: ModuleContext, vtable: Vtable, slot
 
 export {
     hasCallableVfuncSlots,
+    protectedChainSlotKeys,
     renderVfuncMembers,
+    vfuncCallables,
     renderVfuncMetadata,
     vfuncEntries,
     vfuncMemberNames,

package/src/store/gi-store.ts

@@ -1,64 +1,59 @@
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import type { SourceModule } from "../compile.js";
 import { FINGERPRINT_FILENAME, type GiFingerprint } from "../fingerprint.js";
-import { buildManifest, type StoreOptions, subpathExport, writeStore } from "./store-fs.js";
+import { buildManifest, namespaceBarrel, type StoreOptions, subpathExport, writeStore } from "./store-fs.js";
 
 type GiNamespaceInput = {
     directory: string;
     rawSource: string;
-};
-
-type CollectedFile = {
-    fileName: string;
-    source: string;
+    girFile: string;
 };
 
 const OVERRIDES_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "overrides");
 
-const overrideFiles = (directory: string): string[] => {
+const overrideFiles = (directory: string): SourceModule[] => {
     const dir = join(OVERRIDES_ROOT, directory);
 
     if (!existsSync(dir)) {
         return [];
     }
 
-    return readdirSync(dir).filter((name) => name.endsWith(".ejs") && name !== "index.ts.ejs");
+    return readdirSync(dir)
+        .filter((name) => name.endsWith(".ejs") && name !== "index.ts.ejs")
+        .map((name) => overrideModule(`${directory}/overrides/${name.replace(/\.ejs$/, "")}`, join(dir, name)));
 };
 
-const barrelSource = (directory: string): string => {
+const overrideModule = (fileName: string, overridePath: string): SourceModule => ({
+    fileName,
+    source: readFileSync(overridePath, "utf8"),
+    origin: overridePath,
+});
+
+const barrelFile = (directory: string, girFile: string): SourceModule => {
+    const barrel = namespaceBarrel(directory);
     const overrideIndex = join(OVERRIDES_ROOT, directory, "index.ts.ejs");
 
     if (!existsSync(overrideIndex)) {
-        return `export * from "./${directory}.js";\n`;
+        return { ...barrel, origin: girFile };
     }
 
-    return readFileSync(overrideIndex, "utf8");
+    return overrideModule(barrel.fileName, overrideIndex);
 };
 
 const collectStoreSources = (
     namespaces: GiNamespaceInput[],
-): { collected: CollectedFile[]; exportsMap: Record<string, unknown> } => {
+): { collected: SourceModule[]; exportsMap: Record<string, unknown> } => {
     const exportsMap: Record<string, unknown> = {};
-    const collected: CollectedFile[] = [];
-
-    for (const { directory, rawSource } of namespaces) {
-        collected.push({
-            fileName: `${directory}/${directory}.ts`,
-            source: rawSource,
-        });
-
-        for (const file of overrideFiles(directory)) {
-            collected.push({
-                fileName: `${directory}/overrides/${file.replace(/\.ejs$/, "")}`,
-                source: readFileSync(join(OVERRIDES_ROOT, directory, file), "utf8"),
-            });
-        }
-
-        collected.push({
-            fileName: `${directory}/index.ts`,
-            source: barrelSource(directory),
-        });
+    const collected: SourceModule[] = [];
+
+    for (const { directory, rawSource, girFile } of namespaces) {
+        collected.push(
+            { fileName: `${directory}/${directory}.ts`, source: rawSource, origin: girFile },
+            ...overrideFiles(directory),
+            barrelFile(directory, girFile),
+        );
 
         exportsMap[`./${directory}`] = subpathExport(`${directory}/index`);
     }

package/src/store/jsx/generated-elements.ts

@@ -1,7 +1,8 @@
-import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import type { GlibNamedClass } from "./intrinsic-elements.js";
 import { namespaceDirectory } from "../../gir/namespace.js";
+import { arrayGuard, hasFields, isBoolean, isString } from "../../guards.js";
+import { readJsonFile } from "../../json.js";
 
 /** One element the `@gtkx/jsx` store binds. */
 type GeneratedElement = {
@@ -33,22 +34,30 @@ const collectGeneratedElements = (intrinsicElements: GlibNamedClass[]): Generate
 const renderGeneratedElements = (elements: GeneratedElement[]): string =>
     `${JSON.stringify(elements, null, 2)}\n`;
 
+const isGeneratedElement = (value: unknown): value is GeneratedElement =>
+    hasFields<GeneratedElement>(value, {
+        namespace: isString,
+        directory: isString,
+        glibName: isString,
+        isMountable: isBoolean,
+    });
+
+const isGeneratedInventory = (value: unknown): value is GeneratedElement[] =>
+    arrayGuard(isGeneratedElement)(value);
+
 /**
  * Reads the inventory of elements the `@gtkx/jsx` store binds, written into the store by codegen. Answers
  * "what does this project's JSX layer cover" without loading the store, which resolves `virtual:` specifiers
  * that only exist inside a Vite or Vitest build.
  *
  * @param jsxStoreDir The jsx store directory, as given by `resolveStore(projectRoot).jsx.storeDir`.
- * @returns Every bound element, sorted by GLib type name, or an empty array when the store has no inventory.
+ * @returns Every bound element, sorted by GLib type name, or an empty array when the store holds no inventory
+ * codegen wrote, which covers an absent, unreadable, unparseable and structurally foreign store file alike.
  */
 const readGeneratedElements = (jsxStoreDir: string): GeneratedElement[] => {
-    const path = join(jsxStoreDir, ELEMENTS_FILENAME);
-
-    if (!existsSync(path)) {
-        return [];
-    }
+    const parsed = readJsonFile(join(jsxStoreDir, ELEMENTS_FILENAME));
 
-    return JSON.parse(readFileSync(path, "utf8")) as GeneratedElement[];
+    return isGeneratedInventory(parsed) ? parsed : [];
 };
 
 export {

package/src/store/jsx/jsx.ts

@@ -1,4 +1,4 @@
-import { sourceStringLiteral } from "@gtkx/utils";
+import { sanitizeTypeIdentifier, sourceStringLiteral } from "@gtkx/utils";
 import type { GirClass } from "../../gir/class.js";
 import type { Library } from "../../gir/library.js";
 import type { GirNamespace } from "../../gir/namespace.js";
@@ -285,7 +285,7 @@ const renderInterfacePropsBlock = (
 
     const extendsClause = prerequisiteExtends.length === 0 ? "" : ` extends ${prerequisiteExtends.join(", ")}`;
     addGiNamespace(imports, iface.namespace.name, giNamespaceAlias(iface.namespace.name));
-    const selfDefault = `${giNamespaceAlias(iface.namespace.name)}.${iface.klass.name}`;
+    const selfDefault = `${giNamespaceAlias(iface.namespace.name)}.${sanitizeTypeIdentifier(iface.klass.name)}`;
     const signature = `export interface ${glib}Props<Self = ${selfDefault}>${extendsClause}`;
     const block = `${getDoc(iface.klass)}${renderBlock(signature, ownerLines.join("\n"))}`;
 
@@ -324,7 +324,7 @@ const renderPropBlock = (
     const ownerLines = dedupePropLines(["ref?: Ref<Self | null> | undefined;", ...propLines]);
     const extendsList = resolveElementExtends(library, entry, context);
     const extendsClause = extendsList.length === 0 ? "" : ` extends ${extendsList.join(", ")}`;
-    const selfDefault = `${giNamespaceAlias(entry.namespace.name)}.${entry.klass.name}`;
+    const selfDefault = `${giNamespaceAlias(entry.namespace.name)}.${sanitizeTypeIdentifier(entry.klass.name)}`;
 
     const block = `${getDoc(entry.klass)}${renderBlock(
         `export interface ${entry.glibName}Props<Self = ${selfDefault}>${extendsClause}`,

package/src/store/jsx/metadata.ts

@@ -66,12 +66,15 @@ const generateMetadata = (library: Library): string => {
 
 const collectIntrinsicElements = (library: Library): IntrinsicElementEntry[] => {
     const entries: IntrinsicElementEntry[] = [];
+    const seen: Set<string> = new Set();
 
     for (const { glibName, klass, namespace } of iterateClassesWithGlibName(library)) {
-        if (!isIntrinsicElementClass(klass, namespace, library)) {
+        if (!isIntrinsicElementClass(klass, namespace, library) || seen.has(glibName)) {
             continue;
         }
 
+        seen.add(glibName);
+
         const sources: GirClass[] = [
             klass,
             ...implementedInterfaces(klass, namespace, library).map((entry) => entry.klass),

package/src/store/jsx-store.ts

@@ -1,6 +1,6 @@
 import type { JsxNamespaceFile } from "./jsx/pipeline.js";
 import type { RawFile } from "./store-fs.js";
-import { buildManifest, type StoreOptions, subpathExport, writeStore } from "./store-fs.js";
+import { buildManifest, namespaceBarrel, type StoreOptions, subpathExport, writeStore } from "./store-fs.js";
 
 const writeJsxStore = (
     options: StoreOptions,
@@ -15,8 +15,8 @@ const writeJsxStore = (
     const files = [{ fileName: "metadata.ts", source: metadata }];
 
     for (const { directory, source } of namespaces) {
-        files.push({ fileName: `${directory}/${directory}.tsx`, source });
-        exportsMap[`./${directory}`] = subpathExport(`${directory}/${directory}`);
+        files.push({ fileName: `${directory}/${directory}.tsx`, source }, namespaceBarrel(directory));
+        exportsMap[`./${directory}`] = subpathExport(`${directory}/index`);
     }
 
     writeStore({