@gtkx/codegen 1.0.0-rc.3 → 1.0.0-rc.4

package/src/store/gi/record-field-accessor.ts

@@ -28,7 +28,7 @@ type AdmittedField = {
 type RecordFieldEntry = {
     jsName: string;
     tsType: string;
-    writable: boolean;
+    isWritable: boolean;
     doc: string | undefined;
 };
 
@@ -91,8 +91,6 @@ type AccessorOptions = {
     fieldType: TypeId;
 };
 
-// An inline record field is read and written through its own bytes, so it can only be exposed when
-// those bytes are copyable; a pointer field is marshalled as a handle and is always fine.
 const isMarshalableField = (context: ModuleContext, field: GirField): boolean => {
     if (field.cType?.endsWith("*") === true) {
         return true;
@@ -180,7 +178,7 @@ const resolveRecordFieldEntry = (
     return {
         jsName: admitted.jsName,
         tsType: renderTsType(context, admitted.field.type, false),
-        writable: admitted.field.writable,
+        isWritable: admitted.field.writable,
         doc: admitted.field.doc,
     };
 };
@@ -211,8 +209,6 @@ const renderRecordFieldAccessor = (
         return `${doc}declare ${jsName}: ${tsType};`;
     }
 
-    // A record field whose C type is the record itself rather than a pointer to it holds the value
-    // in place, so its own address is the value and no word may be loaded out of it.
     const descriptor = context.hoistDescriptor(
         renderDescriptor(context, field.type, "none", { isInline: isInlineField(context, field) }),
     );
@@ -269,8 +265,6 @@ const isAccessorEligibleType = (context: ModuleContext, ref: TypeId): boolean =>
     }
 };
 
-// A field whose record is embedded by value is read and written through its own bytes, so the
-// constructor and the setter have to describe it the same way.
 const isInlineField = (context: ModuleContext, field: GirField): boolean =>
     field.type !== undefined && resolveInlineStructFields(context, field.type, field.cType) !== undefined;
 
@@ -571,7 +565,7 @@ const renderStructArrayAccessor = (context: ModuleContext, target: StructArrayTa
         elementDescriptor: tStruct("borrowed", {
             size: `${lengthExpr} * ${String(elementSize)}`,
             wrapperClass: undefined,
-            callerAllocated: false,
+            isCallerAllocated: false,
         }),
         offset: slot.byteOffset,
         lengthExpr,
@@ -603,7 +597,7 @@ const getterBlock = (options: AccessorOptions): string => {
 
         const wrapped = wrapReturnValue(context, {
             ref: fieldType,
-            nullable: false,
+            isNullable: false,
             valueExpression,
         });
 

package/src/store/gi/record-layout.ts

@@ -20,10 +20,6 @@ type RecordFieldSlot = {
 const POINTER_LAYOUT: FieldLayout = { size: 8, align: 8 };
 const recordLayoutCache: Map<string, FieldLayout> = new Map();
 
-// GIR carries no alignment attribute, and a type whose alignment exceeds its widest member cannot be
-// derived from the field list: Graphene models `graphene_simd4f_t` as four `gfloat`, which computes
-// to align 4 while the real type is a 16-byte SIMD vector. Keying the override on `c:type` keeps it
-// to the handful of types where the XML genuinely cannot express the ABI.
 const ALIGNMENT_OVERRIDES: Map<string, FieldLayout> = new Map([
     ["graphene_simd4f_t", { size: 16, align: 16 }],
     ["graphene_simd4x4f_t", { size: 64, align: 16 }],

package/src/store/gi/return-wrap.ts

@@ -6,14 +6,14 @@ import { renderTsType } from "../../analysis/ts-type.js";
 
 type WrapReturnOptions = {
     ref: TypeId | undefined;
-    nullable: boolean;
+    isNullable: boolean;
     valueExpression: string;
 };
 
 const BIGINT_CATEGORIES: Set<PrimitiveCategory> = new Set(["gtype", "bigint64", "biguint64"]);
 
 const wrapReturnValue = (context: ModuleContext, options: WrapReturnOptions): string => {
-    const { ref, nullable, valueExpression } = options;
+    const { ref, isNullable, valueExpression } = options;
 
     if (ref === undefined) {
         return valueExpression;
@@ -27,7 +27,7 @@ const wrapReturnValue = (context: ModuleContext, options: WrapReturnOptions): st
 
     switch (type.kind) {
         case "primitive": {
-            return wrapPrimitive(type.category, nullable, valueExpression);
+            return wrapPrimitive(type.category, isNullable, valueExpression);
         }
         case "varargs": {
             return `(${valueExpression} as unknown[])`;
@@ -39,7 +39,7 @@ const wrapReturnValue = (context: ModuleContext, options: WrapReturnOptions): st
             return `(${valueExpression} as number)`;
         }
         case "alias": {
-            return wrapAlias(context, type.value.target, nullable, valueExpression);
+            return wrapAlias(context, type.value.target, isNullable, valueExpression);
         }
         case "carray":
         case "class":
@@ -65,7 +65,7 @@ const wrapAlias = (
 ): string =>
     target === undefined
         ? valueExpression
-        : wrapReturnValue(context, { ref: target, nullable: isNullable, valueExpression });
+        : wrapReturnValue(context, { ref: target, isNullable, valueExpression });
 
 const wrapValue = (context: ModuleContext, ref: TypeId, valueExpression: string): string => {
     context.addRuntimeImport("fromNative");

package/src/store/gi/signal.ts

@@ -28,7 +28,7 @@ type SignalMapSpec = {
     context: ModuleContext;
     klass: GirClass;
     className: string;
-    parentlessExtendsObject: boolean;
+    isParentlessObjectSubclass: boolean;
     suffix: string;
     renderEntry: (context: ModuleContext, signal: GirCallable) => string;
 };
@@ -66,7 +66,7 @@ const renderSignalMembers = (context: ModuleContext, klass: GirClass): string[]
 
     const connectDefault = isRootObject
         ? "default:\n    throw new globalThis.Error(\"Unknown signal '\" + signal + \"'\");"
-        : "default:\n    return super.connect(signal, handler, after);";
+        : "default:\n    return super.connect(signal, handler, isAfter);";
 
     const emitDefault = isRootObject
         ? "default:\n    throw new globalThis.Error(\"Unknown signal '\" + sigName + \"'\");"
@@ -78,7 +78,10 @@ const renderSignalMembers = (context: ModuleContext, klass: GirClass): string[]
     const emitSwitch = `switch (getSignalBaseName(sigName)) {\n${emitBody}\n}`;
 
     return [
-        renderBlock(`connect(signal: string, handler: ${SIGNAL_HANDLER_TYPE}, after?: boolean): number`, connectSwitch),
+        renderBlock(
+            `connect(signal: string, handler: ${SIGNAL_HANDLER_TYPE}, isAfter?: boolean): number`,
+            connectSwitch,
+        ),
         renderBlock("emit(sigName: string, ...args: unknown[]): unknown", emitSwitch),
     ];
 };
@@ -89,7 +92,7 @@ const renderSignalDeclarations = (
     className: string,
     isParentlessObjectSubclass: boolean,
 ): string[] => {
-    const base = { context, klass, className, parentlessExtendsObject: isParentlessObjectSubclass };
+    const base = { context, klass, className, isParentlessObjectSubclass };
 
     const declarations = [
         renderSignalMap({ ...base, suffix: SIGNALS_SUFFIX, renderEntry: renderSignalHandlerType }),
@@ -110,8 +113,8 @@ const renderSignalDeclarations = (
 };
 
 const renderSignalMap = (spec: SignalMapSpec): string => {
-    const { context, klass, className, parentlessExtendsObject, suffix, renderEntry } = spec;
-    const extendsRefs = signalMapParentRefs(context, klass, parentlessExtendsObject, suffix);
+    const { context, klass, className, isParentlessObjectSubclass, suffix, renderEntry } = spec;
+    const extendsRefs = signalMapParentRefs(context, klass, isParentlessObjectSubclass, suffix);
     const extendsClause = extendsRefs.length === 0 ? "" : ` extends ${extendsRefs.join(", ")}`;
 
     const signalEntries = collectClassSignals(context, klass).map((signal) => {
@@ -177,8 +180,8 @@ const renderSignalConnectInterface = (className: string, isRootObject: boolean):
 
     const lines = [
         `__signals__?: ${map};`,
-        `connect<K extends keyof ${map}>(signal: K, handler: ${map}[K], after?: boolean): number;`,
-        `connect(signal: string, handler: ${SIGNAL_HANDLER_TYPE}, after?: boolean): number;`,
+        `connect<K extends keyof ${map}>(signal: K, handler: ${map}[K], isAfter?: boolean): number;`,
+        `connect(signal: string, handler: ${SIGNAL_HANDLER_TYPE}, isAfter?: boolean): number;`,
         `emit<K extends keyof ${emitMap}>(sigName: K, ...args: ${emitMap}[K]["args"]): ${emitMap}[K]["result"];`,
         "emit(sigName: string, ...args: unknown[]): unknown;",
     ];
@@ -193,7 +196,7 @@ const renderSignalConnectInterface = (className: string, isRootObject: boolean):
             }
         };
 
-        chainable(["on", "once", "addEventListener"], ", after?: boolean");
+        chainable(["on", "once", "addEventListener"], ", isAfter?: boolean");
         chainable(["off", "removeEventListener"], "");
     }
 
@@ -216,8 +219,8 @@ const renderResultType = (
         library: context.library,
         signal,
         renderType: (ref, nullable) => renderTsType(context, ref, nullable),
-        includeCallerAllocated: shouldIncludeCallerAllocated,
-        optOut: isOptOut,
+        shouldIncludeCallerAllocated,
+        isOptOut,
     });
 
 const renderSignalEmitEntry = (context: ModuleContext, signal: GirCallable): string => {
@@ -237,7 +240,7 @@ const nonVarargParameters = (signal: GirCallable): GirParameter[] =>
 
 const renderConnectCase = (context: ModuleContext, signal: GirCallable): string => {
     const callback = renderCallback(context, signal);
-    const body = `return connectSignal(this, signal, { callback: ${callback}, handler, after: after ?? false });`;
+    const body = `return connectSignal(this, signal, { callback: ${callback}, handler, isAfter: isAfter ?? false });`;
 
     return renderBlock(`case ${sourceStringLiteral(signal.name)}:`, body);
 };
@@ -260,7 +263,7 @@ const renderEmitArgLiteral = (options: EmitArgOptions): { literal: string; nextA
         const value = renderCallerOutAllocation(context, parameter);
 
         return {
-            literal: `{ type: ${descriptor}, direction: "out", callerAllocated: true, value: ${value} }`,
+            literal: `{ type: ${descriptor}, direction: "out", isCallerAllocated: true, value: ${value} }`,
             nextArgIndex: argIndex,
         };
     }
@@ -268,7 +271,7 @@ const renderEmitArgLiteral = (options: EmitArgOptions): { literal: string; nextA
     if (isRecordInout(context, parameter)) {
         return {
             literal:
-                `{ type: ${descriptor}, direction: "inout", callerAllocated: true, ` +
+                `{ type: ${descriptor}, direction: "inout", isCallerAllocated: true, ` +
                 `value: args[${String(argIndex)}] }`,
             nextArgIndex: argIndex + 1,
         };
@@ -328,9 +331,6 @@ const renderCallerOutAllocation = (context: ModuleContext, parameter: GirParamet
 const renderCallback = (context: ModuleContext, signal: GirCallable): string => {
     const params = nonVarargParameters(signal);
 
-    // The emitted argument list prepends the instance the signal was raised on, so every index a
-    // parameter descriptor carries (an array's `sizeParamIndex`, above all) sits one slot further
-    // right than the position GIR assigned it.
     const callbackParamDescriptors = params.map((parameter) =>
         renderParamDescriptor(context, parameter, parameter.type, { argIndexOffset: 1 }),
     );

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

@@ -7,7 +7,6 @@ import type { ModuleContext } from "../../writer/context.js";
 
 type Scope = { context: ModuleContext; seen: Set<string> };
 
-/** Primitive categories that are a pointer at the C level, so copying the bytes aliases the pointee. */
 const POINTER_CATEGORIES: Set<PrimitiveCategory> = new Set<PrimitiveCategory>(["string", "pointer"]);
 
 const recordKey = (namespaceName: string, record: GirRecord): string => `${namespaceName}.${record.name}`;
@@ -79,17 +78,9 @@ function isValueSafeRecord(scope: Scope, namespaceName: string, record: GirRecor
     return isSafe;
 }
 
-/**
- * Whether a record can be copied by value. A plain struct is duplicated with a byte-wise `g_memdup2`,
- * which shallow-copies whatever the bytes hold, so only a record whose every field is transitively a
- * scalar can be owned, allocated or written into an inline slot. A pointer, a string, a function
- * pointer or an opaque record makes it borrow-only. Records that carry their own copy/free pair are
- * duplicated through that instead and never reach the byte-wise path.
- */
 const isValueMarshalable = (context: ModuleContext, namespaceName: string, record: GirRecord): boolean =>
     isValueSafeRecord({ context, seen: new Set<string>() }, namespaceName, record);
 
-/** Whether a record can be allocated and populated from JavaScript. */
 const isConstructibleRecord = (context: ModuleContext, namespaceName: string, record: GirRecord): boolean =>
     hasOwnCopySemantics(record) || isValueMarshalable(context, namespaceName, record);
 

package/src/store/gi-store.ts

@@ -4,8 +4,6 @@ import { fileURLToPath } from "node:url";
 import { FINGERPRINT_FILENAME, type GiFingerprint } from "../fingerprint.js";
 import { buildManifest, type StoreOptions, subpathExport, writeStore } from "./store-fs.js";
 
-type GiStoreOptions = StoreOptions;
-
 type GiNamespaceInput = {
     directory: string;
     rawSource: string;
@@ -69,7 +67,7 @@ const collectStoreSources = (
 };
 
 const writeGiStore = (
-    options: GiStoreOptions,
+    options: StoreOptions,
     namespaces: GiNamespaceInput[],
     fingerprint: GiFingerprint,
 ): void => {
@@ -89,4 +87,4 @@ const writeGiStore = (
     });
 };
 
-export { writeGiStore, type GiStoreOptions, type GiNamespaceInput };
+export { writeGiStore, type GiNamespaceInput };

package/src/store/jsx/element-components.ts

@@ -6,9 +6,7 @@ import type { LazyElementSpec } from "./element-prop-types.js";
 import { renderJsDoc } from "../../writer/doc.js";
 import { ancestorGlibNames, type GlibNamedClass } from "./intrinsic-elements.js";
 
-/** A component that wraps a generated element, keyed by GLib type name (built-in or user-provided). */
 type ElementComponent = { module: string; export: string };
-/** Component wrappers keyed by GLib type name; the framework's built-ins merged with the project's own. */
 type ElementComponentOverrides = Record<string, ElementComponent>;
 
 type ExportCollector = {
@@ -73,9 +71,6 @@ const appendCandidateExport = (
     collector.exportedNames.add(candidate.glibName);
 };
 
-// An abstract GType cannot be instantiated: `g_object_new` on one is a fatal GObject error rather
-// than a NULL return. Its props interface and metadata still have to be emitted, since every
-// concrete subclass extends them, so only the constructible component export is withheld.
 const collectCandidateExports = (collector: ExportCollector, options: CandidateExportOptions): void => {
     for (const candidate of options.intrinsicElements) {
         if (candidate.klass.isAbstract) {
@@ -121,7 +116,6 @@ const renderCandidateExport = (
     return `${renderJsDoc(klass.doc)}${renderElementComponentExport(glibName, component)}`;
 };
 
-/** The component for the nearest ancestry match, most-derived first; user overrides win on their exact type. */
 const resolveElementComponent = (
     ancestry: string[],
     components: Record<string, ElementComponent>,

package/src/store/jsx/element-prop-imports.ts

@@ -1,11 +1,15 @@
-/** Props interface a generated element's props extend, declared by hand in `@gtkx/react`. */
 type ElementPropTypeRef = { type: string; module: string; export: string };
+
 /** Base props interface each element extends, keyed by GLib type name (the module exports it). */
-type ElementProps = Record<string, { module: string; export: string }>;
+type ElementProps = Record<string, {
+    /** Specifier the props interface is imported from. */
+    module: string;
+    /** Identifier the module exports it under. */
+    export: string;
+}>;
 
 const elementProps: Map<string, { module: string; export: string }> = new Map();
 
-/** Installs the base props each element extends (GLib type name → `{ module, export }`); set once per run. */
 const setElementProps = (props: ElementProps): void => {
     elementProps.clear();
 
@@ -14,7 +18,6 @@ const setElementProps = (props: ElementProps): void => {
     }
 };
 
-/** The base props interface an element extends, when its element config declares one. */
 const elementPropTypeFor = (glibName: string): ElementPropTypeRef | undefined => {
     const ref = elementProps.get(glibName);
 

package/src/store/jsx/element-prop-types.ts

@@ -37,7 +37,6 @@ const createLazyElementSpec = (context: GirIndex, element: string, entry: GirTyp
     return { element, typeName, typeSource: `export type ${typeName} = ${base} & { children?: ReactNode };` };
 };
 
-/** Lazy element prop types to emit, grouped by the namespace declaring each element. */
 const lazyElementSpecs = (context: GirIndex, lazyElements: string[]): Map<string, LazyElementSpec[]> => {
     const specs: Map<string, LazyElementSpec[]> = new Map();
 

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

@@ -0,0 +1,60 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { GlibNamedClass } from "./intrinsic-elements.js";
+import { namespaceDirectory } from "../../gir/namespace.js";
+
+/** One element the `@gtkx/jsx` store binds. */
+type GeneratedElement = {
+    /** GIR namespace name, such as `"Gtk"`. */
+    namespace: string;
+    /** Subexport the element is reachable through, such as `"gtk"` in `@gtkx/jsx/gtk`. */
+    directory: string;
+    /** GLib type name, which is also the JSX tag name, such as `"GtkButton"`. */
+    glibName: string;
+    /**
+     * Whether the element can be rendered. An abstract GType is bound for its props and metadata but
+     * exports no component, because `g_object_new` on one is a fatal GObject error.
+     */
+    isMountable: boolean;
+};
+
+const ELEMENTS_FILENAME = "elements.json";
+
+const collectGeneratedElements = (intrinsicElements: GlibNamedClass[]): GeneratedElement[] =>
+    intrinsicElements
+        .map((entry) => ({
+            namespace: entry.namespace.name,
+            directory: namespaceDirectory(entry.namespace),
+            glibName: entry.glibName,
+            isMountable: !entry.klass.isAbstract,
+        }))
+        .toSorted((a, b) => a.glibName.localeCompare(b.glibName));
+
+const renderGeneratedElements = (elements: GeneratedElement[]): string =>
+    `${JSON.stringify(elements, null, 2)}\n`;
+
+/**
+ * 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.
+ */
+const readGeneratedElements = (jsxStoreDir: string): GeneratedElement[] => {
+    const path = join(jsxStoreDir, ELEMENTS_FILENAME);
+
+    if (!existsSync(path)) {
+        return [];
+    }
+
+    return JSON.parse(readFileSync(path, "utf8")) as GeneratedElement[];
+};
+
+export {
+    ELEMENTS_FILENAME,
+    collectGeneratedElements,
+    readGeneratedElements,
+    renderGeneratedElements,
+    type GeneratedElement,
+};

package/src/store/jsx/jsx.ts

@@ -109,7 +109,7 @@ const generateJsxSection = (
     addReactBuiltin(imports, "ReactNode");
     addReactBuiltin(imports, "Ref");
     const interfaceResult = renderInterfacePropBlocks(library, targetNamespace.name, options);
-    let isNeedsReactElement = interfaceResult.needsReactElement;
+    let requiresReactElement = interfaceResult.requiresReactElement;
     const propBlocks: string[] = [...interfaceResult.blocks];
 
     const blockContext: RenderPropBlockContext = {
@@ -124,13 +124,13 @@ const generateJsxSection = (
         const { block, objectPropNames } = renderPropBlock(library, entry, blockContext);
 
         if (objectPropNames.length > 0) {
-            isNeedsReactElement = true;
+            requiresReactElement = true;
         }
 
         propBlocks.push(block);
     }
 
-    if (isNeedsReactElement) {
+    if (requiresReactElement) {
         addReactBuiltin(imports, "ReactElement");
     }
 
@@ -152,11 +152,11 @@ const renderInterfacePropBlocks = (
     library: Library,
     targetNamespaceName: string,
     options: GenerateJsxOptions,
-): { blocks: string[]; needsReactElement: boolean; hasContainerProps: HasContainerProps } => {
+): { blocks: string[]; requiresReactElement: boolean; hasContainerProps: HasContainerProps } => {
     const { imports, intrinsicElements } = options;
     const context: InterfaceBlockContext = { library, targetNamespaceName, imports, hasContainerProps };
     const blocks: string[] = [];
-    let isNeedsReactElement = false;
+    let requiresReactElement = false;
 
     for (const iface of collectInterfacePropsClasses(
         library,
@@ -173,13 +173,13 @@ const renderInterfacePropBlocks = (
         const { block, objectPropNames } = renderInterfacePropsBlock(iface, glibName, context);
 
         if (objectPropNames.length > 0) {
-            isNeedsReactElement = true;
+            requiresReactElement = true;
         }
 
         blocks.push(block);
     }
 
-    return { blocks, needsReactElement: isNeedsReactElement, hasContainerProps };
+    return { blocks, requiresReactElement, hasContainerProps };
 };
 
 const registerCrossNsProps = (

package/src/store/jsx/metadata.ts

@@ -23,7 +23,7 @@ type IntrinsicElementEntry = {
 };
 
 type PropNameCollector = {
-    keep: (property: GirProperty) => boolean;
+    shouldKeep: (property: GirProperty) => boolean;
     seen: Set<string>;
     names: string[];
 };
@@ -57,10 +57,10 @@ const generateMetadata = (library: Library): string => {
         .map(({ glibName, defaults }) => `    "${glibName}": ${renderDefaultsObject(defaults)},`);
 
     return `${[
-        `export const SIGNALS: Record<string, Record<string, string>> = {\n${signalsEntries.join("\n")}\n};`,
-        `export const CONSTRUCT_ONLY_PROPS: Record<string, Set<string>> = {\n${constructOnlyEntries.join("\n")}\n};`,
-        `export const CONSTRUCT_PROPS: Record<string, Set<string>> = {\n${constructableEntries.join("\n")}\n};`,
-        `export const DEFAULT_PROPS: Record<string, Record<string, unknown>> = {\n${defaultsEntries.join("\n")}\n};`,
+        `export const signals: Record<string, Record<string, string>> = {\n${signalsEntries.join("\n")}\n};`,
+        `export const constructOnlyProps: Record<string, Set<string>> = {\n${constructOnlyEntries.join("\n")}\n};`,
+        `export const constructProps: Record<string, Set<string>> = {\n${constructableEntries.join("\n")}\n};`,
+        `export const defaultProps: Record<string, Record<string, unknown>> = {\n${defaultsEntries.join("\n")}\n};`,
     ].join("\n\n")}\n`;
 };
 
@@ -114,10 +114,10 @@ const collectSignals = (sources: GirClass[]): [string, string][] => {
 };
 
 const collectPropNamesFromSource = (source: GirClass, collector: PropNameCollector): void => {
-    const { keep, seen, names } = collector;
+    const { shouldKeep, seen, names } = collector;
 
     for (const property of source.properties) {
-        if (!keep(property)) {
+        if (!shouldKeep(property)) {
             continue;
         }
 
@@ -133,7 +133,7 @@ const collectPropNamesFromSource = (source: GirClass, collector: PropNameCollect
 };
 
 const collectPropNames = (sources: GirClass[], shouldKeep: (property: GirProperty) => boolean): string[] => {
-    const collector: PropNameCollector = { keep: shouldKeep, seen: new Set<string>(), names: [] };
+    const collector: PropNameCollector = { shouldKeep, seen: new Set<string>(), names: [] };
 
     for (const source of sources) {
         collectPropNamesFromSource(source, collector);

package/src/store/jsx/omitted-props.ts

@@ -3,7 +3,6 @@ type OmittedProps = Record<string, string[]>;
 
 const omittedProps: Map<string, Set<string>> = new Map();
 
-/** Installs the props each element omits (GLib type name → prop names); set once per run. */
 const setOmittedProps = (props: OmittedProps): void => {
     omittedProps.clear();
 
@@ -12,12 +11,11 @@ const setOmittedProps = (props: OmittedProps): void => {
     }
 };
 
-/** Whether the element config declares this prop omitted for the type that declares the property. */
 const isOmittedProp = (glibName: string | undefined, jsName: string): boolean =>
     glibName !== undefined && omittedProps.get(glibName)?.has(jsName) === true;
 
 /** Merges omitted-prop maps keyed by GLib type name, concatenating the names each map contributes. */
-const mergeOmitProps = (...maps: OmittedProps[]): OmittedProps => {
+const mergeOmittedProps = (...maps: OmittedProps[]): OmittedProps => {
     const merged: OmittedProps = {};
 
     for (const map of maps) {
@@ -29,4 +27,4 @@ const mergeOmitProps = (...maps: OmittedProps[]): OmittedProps => {
     return merged;
 };
 
-export { setOmittedProps, isOmittedProp, mergeOmitProps, type OmittedProps };
+export { setOmittedProps, isOmittedProp, mergeOmittedProps, type OmittedProps };

package/src/store/jsx/pipeline.ts

@@ -5,6 +5,7 @@ import { ImportsBuilder } from "../../writer/imports.js";
 import { type ElementComponentOverrides, generateElementComponentsSection } from "./element-components.js";
 import { type ElementProps, setElementProps } from "./element-prop-imports.js";
 import { type LazyElementSpec, lazyElementSpecs } from "./element-prop-types.js";
+import { collectGeneratedElements, type GeneratedElement } from "./generated-elements.js";
 import { buildGirIndex } from "./gir-index.js";
 import { collectIntrinsicElementClasses, type GlibNamedClass } from "./intrinsic-elements.js";
 import { generateJsxSection } from "./jsx.js";
@@ -20,13 +21,14 @@ type JsxFiles = {
     namespaces: JsxNamespaceFile[];
     metadata: string;
     intrinsicElementCount: number;
+    elements: GeneratedElement[];
 };
 
 type JsxGenerationOptions = {
     reactSubexports?: string[];
     components?: ElementComponentOverrides;
     props?: ElementProps;
-    omitProps?: OmittedProps;
+    omittedProps?: OmittedProps;
     lazyElements?: string[];
 };
 
@@ -49,7 +51,7 @@ type JsxNamespaceContext = {
 
 const generateJsxFiles = (library: Library, options: JsxGenerationOptions = {}): JsxFiles => {
     setElementProps(options.props ?? {});
-    setOmittedProps(options.omitProps ?? {});
+    setOmittedProps(options.omittedProps ?? {});
     const intrinsicElements = collectIntrinsicElementClasses(library);
     const intrinsicElementByGlibName = new Map(intrinsicElements.map((entry) => [entry.glibName, entry]));
     const girIndex = buildGirIndex(library);
@@ -66,7 +68,7 @@ const generateJsxFiles = (library: Library, options: JsxGenerationOptions = {}):
 
     const metadata = generateMetadata(library);
 
-    return { namespaces, metadata, intrinsicElementCount };
+    return { namespaces, metadata, intrinsicElementCount, elements: collectGeneratedElements(intrinsicElements) };
 };
 
 const orderedIntrinsicNamespaces = (intrinsicElements: GlibNamedClass[]): GirNamespace[] => {

package/src/store/jsx/props.ts

@@ -231,8 +231,8 @@ const renderSignalHandler = (options: SignalRenderOptions): string => {
         library: types.library,
         signal,
         renderType: (ref, nullable) => renderReactPropType(types, ref, nullable),
-        includeCallerAllocated: false,
-        optOut: true,
+        shouldIncludeCallerAllocated: false,
+        isOptOut: true,
     });
 
     return `(${params.join(", ")}) => ${result}`;

package/src/store/jsx-store.ts

@@ -2,13 +2,11 @@ import type { JsxNamespaceFile } from "./jsx/pipeline.js";
 import type { RawFile } from "./store-fs.js";
 import { buildManifest, type StoreOptions, subpathExport, writeStore } from "./store-fs.js";
 
-type JsxStoreOptions = StoreOptions;
-
 const writeJsxStore = (
-    options: JsxStoreOptions,
+    options: StoreOptions,
     namespaces: JsxNamespaceFile[],
     metadata: string,
-    fingerprint: RawFile,
+    rawFiles: RawFile[],
 ): void => {
     const exportsMap: Record<string, unknown> = {
         "./metadata": subpathExport("metadata"),
@@ -31,9 +29,9 @@ const writeJsxStore = (
             exports: exportsMap,
             peerDependencies: { "@gtkx/gi": "*", "@gtkx/react": "*", react: "*" },
         }),
-        rawFiles: [fingerprint],
-        configEnv: true,
+        rawFiles,
+        requiresEnvReference: true,
     });
 };
 
-export { writeJsxStore, type JsxStoreOptions };
+export { writeJsxStore };