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

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

@@ -0,0 +1,87 @@
+import type { GirField } from "../../gir/field.js";
+import type { PrimitiveCategory } from "../../gir/primitives.js";
+import type { GirRecord } from "../../gir/record.js";
+import type { TypeId } from "../../gir/type-id.js";
+import type { GirType } from "../../gir/type.js";
+import type { ModuleContext } from "../../writer/context.js";
+
+type Scope = { context: ModuleContext; seen: Set<string> };
+
+const POINTER_CATEGORIES: Set<PrimitiveCategory> = new Set<PrimitiveCategory>(["string", "pointer"]);
+
+const recordKey = (namespaceName: string, record: GirRecord): string => `${namespaceName}.${record.name}`;
+
+const hasOwnCopySemantics = (record: GirRecord): boolean =>
+    record.glibGetType !== undefined ||
+    ((record.glibRefFunc ?? record.copyFunc) !== undefined && (record.glibUnrefFunc ?? record.freeFunc) !== undefined);
+
+const isValueSafeArray = (scope: Scope, type: Extract<GirType, { kind: "carray" }>): boolean =>
+    type.fixedSize !== undefined && isValueSafeRef(scope, type.element, type.elementCType);
+
+const isValueSafeAlias = (scope: Scope, type: Extract<GirType, { kind: "alias" }>): boolean =>
+    isValueSafeRef(scope, type.value.target, type.value.targetCType);
+
+function isValueSafeType(scope: Scope, type: GirType): boolean {
+    switch (type.kind) {
+        case "primitive": {
+            return !POINTER_CATEGORIES.has(type.category);
+        }
+        case "enum": {
+            return true;
+        }
+        case "record": {
+            return isValueSafeRecord(scope, type.namespace.name, type.value);
+        }
+        case "carray": {
+            return isValueSafeArray(scope, type);
+        }
+        case "alias": {
+            return isValueSafeAlias(scope, type);
+        }
+        case "callback":
+        case "class":
+        case "hashtable":
+        case "interface":
+        case "list":
+        case "varargs": {
+            return false;
+        }
+    }
+}
+
+function isValueSafeRef(scope: Scope, ref: TypeId | undefined, cType: string | undefined): boolean {
+    if (ref === undefined || cType?.endsWith("*") === true) {
+        return false;
+    }
+
+    const type = scope.context.library.typeFor(ref);
+
+    return type === undefined ? false : isValueSafeType(scope, type);
+}
+
+const isValueSafeField = (scope: Scope, field: GirField): boolean =>
+    field.inlineMembers === undefined
+        ? isValueSafeRef(scope, field.type, field.cType)
+        : field.inlineMembers.every((member) => isValueSafeField(scope, member));
+
+function isValueSafeRecord(scope: Scope, namespaceName: string, record: GirRecord): boolean {
+    const key = recordKey(namespaceName, record);
+
+    if (scope.seen.has(key) || record.fields.length === 0) {
+        return false;
+    }
+
+    scope.seen.add(key);
+    const isSafe = record.fields.every((field) => isValueSafeField(scope, field));
+    scope.seen.delete(key);
+
+    return isSafe;
+}
+
+const isValueMarshalable = (context: ModuleContext, namespaceName: string, record: GirRecord): boolean =>
+    isValueSafeRecord({ context, seen: new Set<string>() }, namespaceName, record);
+
+const isConstructibleRecord = (context: ModuleContext, namespaceName: string, record: GirRecord): boolean =>
+    hasOwnCopySemantics(record) || isValueMarshalable(context, namespaceName, record);
+
+export { hasOwnCopySemantics, isConstructibleRecord, isValueMarshalable };

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/intrinsic-elements.ts

@@ -214,14 +214,6 @@ const hasMatchingAncestorName = (
     isMatch: (glibName: string) => boolean,
 ): boolean => hasMatchingAncestor(klass, namespace, library, (_klass, glibName) => isMatch(glibName));
 
-const hasExposedMethod = (
-    klass: GirClass,
-    namespace: GirNamespace,
-    library: Library,
-    methodName: string,
-): boolean =>
-    hasMatchingAncestor(klass, namespace, library, (current) => current.methods.some((m) => m.name === methodName));
-
 const isIntrinsicElementClass = (klass: GirClass, namespace: GirNamespace, library: Library): boolean =>
     hasMatchingAncestorName(klass, namespace, library, (glibName) => glibName === "GObject");
 
@@ -253,7 +245,6 @@ export {
     newlyImplementedInterfaces,
     collectInterfacePropsClasses,
     ancestorGlibNames,
-    hasExposedMethod,
     isIntrinsicElementClass,
     collectIntrinsicElementClasses,
     type GlibNamedClass,

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

@@ -0,0 +1,30 @@
+/** Props left out of the generated element props, keyed by GLib type name. */
+type OmittedProps = Record<string, string[]>;
+
+const omittedProps: Map<string, Set<string>> = new Map();
+
+const setOmittedProps = (props: OmittedProps): void => {
+    omittedProps.clear();
+
+    for (const [glibName, names] of Object.entries(props)) {
+        omittedProps.set(glibName, new Set(names));
+    }
+};
+
+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 mergeOmittedProps = (...maps: OmittedProps[]): OmittedProps => {
+    const merged: OmittedProps = {};
+
+    for (const map of maps) {
+        for (const [glibName, names] of Object.entries(map)) {
+            merged[glibName] = [...(merged[glibName] ?? []), ...names];
+        }
+    }
+
+    return merged;
+};
+
+export { setOmittedProps, isOmittedProp, mergeOmittedProps, type OmittedProps };

package/src/store/jsx/pipeline.ts

@@ -5,10 +5,12 @@ 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";
 import { generateMetadata } from "./metadata.js";
+import { type OmittedProps, setOmittedProps } from "./omitted-props.js";
 
 type JsxNamespaceFile = {
     directory: string;
@@ -19,12 +21,14 @@ type JsxFiles = {
     namespaces: JsxNamespaceFile[];
     metadata: string;
     intrinsicElementCount: number;
+    elements: GeneratedElement[];
 };
 
 type JsxGenerationOptions = {
     reactSubexports?: string[];
     components?: ElementComponentOverrides;
     props?: ElementProps;
+    omittedProps?: OmittedProps;
     lazyElements?: string[];
 };
 
@@ -47,6 +51,7 @@ type JsxNamespaceContext = {
 
 const generateJsxFiles = (library: Library, options: JsxGenerationOptions = {}): JsxFiles => {
     setElementProps(options.props ?? {});
+    setOmittedProps(options.omittedProps ?? {});
     const intrinsicElements = collectIntrinsicElementClasses(library);
     const intrinsicElementByGlibName = new Map(intrinsicElements.map((entry) => [entry.glibName, entry]));
     const girIndex = buildGirIndex(library);
@@ -63,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

@@ -9,12 +9,8 @@ import { renderHandlerParameters, renderHandlerResultType } from "../../analysis
 import { recordTypeTarget, renderBaseType, type TsTypeTarget } from "../../analysis/ts-type.js";
 import { type GirProperty, isConstructableProperty } from "../../gir/property.js";
 import { renderJsDoc } from "../../writer/doc.js";
-import {
-    giNamespaceAlias,
-    hasExposedMethod,
-    isIntrinsicElementClass,
-    signalHandlerName,
-} from "./intrinsic-elements.js";
+import { getGlibName, giNamespaceAlias, isIntrinsicElementClass, signalHandlerName } from "./intrinsic-elements.js";
+import { isOmittedProp } from "./omitted-props.js";
 
 type IntrinsicElementPropsEntries = {
     propLines: string[];
@@ -75,7 +71,7 @@ const appendPropertyLines = (state: PropCollectorState, property: GirProperty, j
     const tsType = renderReactPropType(state.types, property.type, false);
     const doc = renderJsDoc(property.doc);
 
-    if (isObjectProp(state.owner, property, jsName)) {
+    if (isObjectProp(state.owner.library, property)) {
         state.propLines.push(`${doc}${jsName}?: ${tsType} | ReactElement | null | undefined;`);
         state.objectPropNames.push(jsName);
 
@@ -99,7 +95,7 @@ const acceptCollectorProperty = (state: PropCollectorState, property: GirPropert
 
     const jsName = toCamelIdentifier(property.name);
 
-    if (state.seen.has(jsName)) {
+    if (state.seen.has(jsName) || isOmittedProp(getGlibName(state.owner.klass), jsName)) {
         return;
     }
 
@@ -215,20 +211,12 @@ const isGObjectType = (library: Library, ref: TypeId | undefined): boolean => {
     return isIntrinsicElementClass(resolved.value, resolved.namespace, library);
 };
 
-const isObjectProp = (owner: IntrinsicElementScope, property: GirProperty, jsName: string): boolean => {
+const isObjectProp = (library: Library, property: GirProperty): boolean => {
     if (!property.writable || property.constructOnly) {
         return false;
     }
 
-    if (!isGObjectType(owner.library, property.type)) {
-        return false;
-    }
-
-    if (jsName === "child" && hasExposedMethod(owner.klass, owner.namespace, owner.library, "set_child")) {
-        return false;
-    }
-
-    return true;
+    return isGObjectType(library, property.type);
 };
 
 const renderSignalHandler = (options: SignalRenderOptions): string => {
@@ -243,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 };