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

package/src/analysis/ts-type.ts

@@ -9,7 +9,6 @@ import {
     type ListType,
     type TypeId,
 } from "../gir/type-id.js";
-import { isClassStructRecord } from "../store/gi/class-struct-record.js";
 import { gtypeTsType } from "../store/gi/gtype-binding.js";
 
 type ReferenceName = {
@@ -25,18 +24,13 @@ type TsTypeTarget = {
     renderGtype: () => string;
 };
 
-const willEmitEntity = (library: Library, type: EntityType): boolean => {
+const willEmitEntity = (type: EntityType): boolean => {
     switch (type.kind) {
         case "callback": {
             return type.value.introspectable && type.value.name.length > 0;
         }
         case "record": {
-            return (
-                type.value.introspectable &&
-                !type.value.isVtable &&
-                type.value.name.length > 0 &&
-                !isClassStructRecord(library, type.namespace.name, type.value)
-            );
+            return type.value.introspectable && type.value.name.length > 0;
         }
         case "alias":
         case "class":
@@ -51,11 +45,10 @@ const renderPrimitiveType = (target: TsTypeTarget, type: Extract<GirType, { kind
     type.category === "gtype" ? target.renderGtype() : PRIMITIVE_TS_TYPE[type.category];
 
 const renderEntityType = (
-    library: Library,
     target: TsTypeTarget,
     type: EntityType,
     name: ReferenceName | undefined,
-): string => renderNamedType(target, type, willEmitEntity(library, type) ? name : undefined);
+): string => renderNamedType(target, type, willEmitEntity(type) ? name : undefined);
 
 const renderBaseType = (library: Library, target: TsTypeTarget, ref: TypeId | undefined): string => {
     if (ref === undefined) {
@@ -82,7 +75,7 @@ const renderBaseType = (library: Library, target: TsTypeTarget, ref: TypeId | un
         case "record":
         case "enum":
         case "alias": {
-            return renderEntityType(library, target, type, name);
+            return renderEntityType(target, type, name);
         }
         case "carray":
         case "list":

package/src/docs/api-reference.ts

@@ -5,7 +5,6 @@ import type { GirRecord } from "../gir/record.js";
 import { Library } from "../gir/library.js";
 import { type GirNamespace, namespaceDirectory } from "../gir/namespace.js";
 import { dedupeCallables, isEmittableCallable } from "../store/gi/callables.js";
-import { isClassStructRecord } from "../store/gi/class-struct-record.js";
 import { namespaceFunctionExportName } from "../store/gi/function.js";
 import { collectIntrinsicElementClasses, type GlibNamedClass } from "../store/jsx/intrinsic-elements.js";
 import { createElementPageContext, type ElementPageContext, renderElementPage } from "./element-page.js";
@@ -136,23 +135,19 @@ const classEntries = (namespace: GirNamespace): GiSymbolEntry[] => {
     return entries;
 };
 
-const recordEntry = (library: Library, namespace: GirNamespace, record: GirRecord): GiSymbolEntry | undefined => {
+const recordEntry = (namespace: GirNamespace, record: GirRecord): GiSymbolEntry | undefined => {
     if (!record.introspectable || record.isVtable || record.name.length === 0) {
         return undefined;
     }
 
-    if (isClassStructRecord(library, namespace.name, record)) {
-        return undefined;
-    }
-
     return { kind: "record", namespace, name: record.name, doc: record.doc, record };
 };
 
-const recordEntries = (library: Library, namespace: GirNamespace): GiSymbolEntry[] => {
+const recordEntries = (namespace: GirNamespace): GiSymbolEntry[] => {
     const entries: GiSymbolEntry[] = [];
 
     for (const record of namespace.records) {
-        const entry = recordEntry(library, namespace, record);
+        const entry = recordEntry(namespace, record);
 
         if (entry !== undefined) {
             entries.push(entry);
@@ -322,7 +317,7 @@ class ApiReference {
     private indexNamespace(namespace: GirNamespace): void {
         const entries = [
             ...classEntries(namespace),
-            ...recordEntries(this.library, namespace),
+            ...recordEntries(namespace),
             ...valueEntries(namespace),
         ];
 

package/src/docs/element-page.ts

@@ -13,6 +13,7 @@ import {
     newlyImplementedInterfaces,
     signalHandlerName,
 } from "../store/jsx/intrinsic-elements.js";
+import { isOmittedProp } from "../store/jsx/omitted-props.js";
 import { isObjectProp } from "../store/jsx/props.js";
 import {
     classMethodEntries,
@@ -120,12 +121,7 @@ const propertyEntry = (
     property: GirProperty,
     jsName: string,
 ): PropEntry => {
-    const isObject = isObjectProp(
-        { library: context.library, klass: owner.klass, namespace: owner.namespace },
-        property,
-        jsName,
-    );
-
+    const isObject = isObjectProp(context.library, property);
     const baseType = renderDocsType(context.library, property.type, false);
     const type = isObject ? `${baseType} | ReactElement` : baseType;
     const meta: string[] = [`\`${type}\``];
@@ -149,14 +145,14 @@ const propertyEntry = (
     return { name: jsName, meta: meta.join(" · "), doc: docMarkdown(property.doc) };
 };
 
-const propJsName = (property: GirProperty, seen: Set<string>): string | undefined => {
+const propJsName = (property: GirProperty, owner: MemberOwner, seen: Set<string>): string | undefined => {
     if (!property.introspectable) {
         return undefined;
     }
 
     const jsName = toCamelIdentifier(property.name);
 
-    if (seen.has(jsName)) {
+    if (seen.has(jsName) || isOmittedProp(owner.glibName, jsName)) {
         return undefined;
     }
 
@@ -169,7 +165,7 @@ const ownerPropEntries = (context: ElementPageContext, owner: MemberOwner, seen:
     const entries: PropEntry[] = [];
 
     for (const property of owner.klass.properties) {
-        const jsName = propJsName(property, seen);
+        const jsName = propJsName(property, owner, seen);
 
         if (jsName !== undefined) {
             entries.push(propertyEntry(context, owner, property, jsName));

package/src/docs/pipeline.ts

@@ -6,6 +6,7 @@ import { Library } from "../gir/library.js";
 import { namespaceDirectory } from "../gir/namespace.js";
 import { type ElementProps, setElementProps } from "../store/jsx/element-prop-imports.js";
 import { collectIntrinsicElementClasses, type GlibNamedClass } from "../store/jsx/intrinsic-elements.js";
+import { type OmittedProps, setOmittedProps } from "../store/jsx/omitted-props.js";
 import { createElementPageContext, type ElementPageContext, renderElementPage } from "./element-page.js";
 import { elementSlug, firstSentence, namespaceOrder } from "./render.js";
 
@@ -27,6 +28,7 @@ type DocsOptions = {
     outDir: string;
     basePath?: string;
     props?: ElementProps;
+    omitProps?: OmittedProps;
     force?: boolean;
 };
 
@@ -214,6 +216,7 @@ const writePages = (outDir: string, pages: Page[]): void => {
 
 const writeDocs = (options: DocsOptions): DocsResult => {
     setElementProps(options.props ?? {});
+    setOmittedProps(options.omitProps ?? {});
     const basePath = options.basePath ?? "/reference";
     const manifestPath = join(options.outDir, MANIFEST_FILENAME);
     const cached = cachedDocsResult(options, manifestPath);

package/src/fingerprint.ts

@@ -21,6 +21,7 @@ type JsxFingerprintInput = {
     components: Record<string, ModuleExport>;
     lazyElements: string[];
     props: Record<string, ModuleExport>;
+    omitProps: Record<string, string[]>;
 };
 
 /** The freshness sentinel of the `@gtkx/jsx` store, derived from the React element config. */
@@ -55,6 +56,7 @@ const hashGi = (girFiles: string[], libraries: string[], girPath: string[]): str
     hash.update(sortAlpha(libraries));
     hash.update("\n");
     hash.update(sortAlpha(girPath));
+    hash.update("\n");
     const hashedFiles = sortStrings([...girFiles, ...overrideFiles()]);
 
     for (const file of hashedFiles) {
@@ -67,14 +69,22 @@ const hashGi = (girFiles: string[], libraries: string[], girPath: string[]): str
     return hash.digest("hex");
 };
 
-const computeGiFingerprint = (girFiles: string[], libraries: string[], girPath: string[]): GiFingerprint => ({
+const computeGiFingerprint = (
+    girFiles: string[],
+    libraries: string[],
+    girPath: string[],
+): GiFingerprint => ({
     value: hashGi(girFiles, libraries, girPath),
     girFiles,
     libraries,
     girPath,
 });
 
-const isGiStoreFresh = (giStoreDir: string, libraries: string[], girPath: string[]): boolean => {
+const isGiStoreFresh = (
+    giStoreDir: string,
+    libraries: string[],
+    girPath: string[],
+): boolean => {
     const sentinelPath = join(giStoreDir, FINGERPRINT_FILENAME);
 
     if (!existsSync(sentinelPath)) {
@@ -106,6 +116,9 @@ const hasMatchingRecordedInputs = (sentinel: GiFingerprint, libraries: string[],
 const serializeModuleExports = (map: Record<string, ModuleExport>): [string, string, string][] =>
     sortStrings(Object.keys(map)).map((type) => [type, map[type]?.module ?? "", map[type]?.export ?? ""]);
 
+const serializeOmitProps = (map: Record<string, string[]>): [string, string][] =>
+    sortStrings(Object.keys(map)).map((type) => [type, sortAlpha(map[type] ?? [])]);
+
 const hashJsx = (input: JsxFingerprintInput): string =>
     createHash("sha256")
         .update(
@@ -115,6 +128,7 @@ const hashJsx = (input: JsxFingerprintInput): string =>
                 serializeModuleExports(input.components),
                 sortStrings(input.lazyElements),
                 serializeModuleExports(input.props),
+                serializeOmitProps(input.omitProps),
             ]),
         )
         .digest("hex");

package/src/gi.ts

@@ -4,23 +4,32 @@ import { namespaceDirectory } from "./gir/namespace.js";
 import { type GiNamespaceInput, type GiStoreOptions, writeGiStore } from "./store/gi-store.js";
 import { generateNamespaceModule } from "./store/gi/pipeline.js";
 
+type GiCodegenOptions = {
+    gi: GiStoreOptions;
+    libraries: string[];
+    girPath: string[];
+};
+
 /**
  * Generates the `@gtkx/gi` store from the loaded GIR library and links it into the project. This is the
  * react-free half of codegen: it can run before `@gtkx/gi` (or `@gtkx/react`) exists, since it produces them.
  *
  * @returns The number of namespaces written.
  */
-const runGiCodegen = (library: Library, gi: GiStoreOptions, libraries: string[], girPath: string[]): number => {
+const runGiCodegen = (library: Library, options: GiCodegenOptions): number => {
+    const { gi, libraries, girPath } = options;
+
     const namespaces: GiNamespaceInput[] = Array.from(library.namespaces.values(), (namespace) => ({
         directory: namespaceDirectory(namespace),
         rawSource: generateNamespaceModule(namespace, library),
     }));
 
-    writeGiStore(gi, namespaces, computeGiFingerprint(library.girFiles, [...libraries], [...girPath]));
+    const fingerprint = computeGiFingerprint(library.girFiles, [...libraries], [...girPath]);
+    writeGiStore(gi, namespaces, fingerprint);
 
     return library.namespaces.size;
 };
 
 export { isGiStoreFresh } from "./fingerprint.js";
 export type { GiStoreOptions } from "./store/gi-store.js";
-export { runGiCodegen };
+export { runGiCodegen, type GiCodegenOptions };

package/src/gir/libraries.ts

@@ -1,14 +1,15 @@
-import type { Config } from "@gtkx/config";
-import { GIR_LIBRARY_PATTERN, LIBRARIES_WILDCARD } from "@gtkx/config/internal";
 import { sortStrings } from "@gtkx/utils";
 import { readdirSync } from "node:fs";
 
 type GirNamespace = { name: string; version: string; identifier: string };
+type LibrarySelection = typeof LIBRARIES_WILDCARD | string[] | undefined;
 
+const LIBRARIES_WILDCARD = "*";
+const GIR_LIBRARY_PATTERN = /^[A-Za-z][A-Za-z0-9]*-\d+(?:\.\d+)*$/;
 const DEFAULT_LIBRARIES: string[] = ["Gtk-4.0"];
 const GIR_FILE_SUFFIX = ".gir";
 
-const resolveLibraries = (libraries: Config["libraries"], girPath: string[]): string[] => {
+const resolveLibraries = (libraries: LibrarySelection, girPath: string[]): string[] => {
     if (libraries === undefined) {
         return [...DEFAULT_LIBRARIES];
     }
@@ -99,4 +100,4 @@ const compareVersions = (a: string, b: string): number => {
     return 0;
 };
 
-export { resolveLibraries, discoverGirNamespaces };
+export { resolveLibraries, discoverGirNamespaces, type LibrarySelection };

package/src/index.ts

@@ -26,3 +26,4 @@ export {
 } from "./react/element-config.js";
 export { runCodegen } from "./runner.js";
 export type { ElementProps } from "./store/jsx/element-prop-imports.js";
+export { mergeOmitProps, type OmittedProps } from "./store/jsx/omitted-props.js";

package/src/jsx.ts

@@ -7,6 +7,7 @@ import {
 } from "./fingerprint.js";
 import { type ModuleExport, readBuiltinElements } from "./react/element-config.js";
 import { type JsxStoreOptions, writeJsxStore } from "./store/jsx-store.js";
+import { mergeOmitProps, type OmittedProps } from "./store/jsx/omitted-props.js";
 import { generateJsxFiles } from "./store/jsx/pipeline.js";
 
 type RunJsxCodegenOptions = {
@@ -17,6 +18,7 @@ type RunJsxCodegenOptions = {
     userComponents: Record<string, ModuleExport>;
     userLazyElements: string[];
     userProps: Record<string, ModuleExport>;
+    userOmitProps: OmittedProps;
     giRegenerated: boolean;
     force: boolean;
 };
@@ -36,12 +38,14 @@ const runJsxCodegen = async (options: RunJsxCodegenOptions): Promise<RunJsxCodeg
     const components = { ...builtin.components, ...options.userComponents };
     const lazyElements = [...builtin.lazyElements, ...options.userLazyElements];
     const props = { ...builtin.props, ...options.userProps };
+    const omitProps = mergeOmitProps(builtin.omitProps, options.userOmitProps);
 
     const fingerprintInput: JsxFingerprintInput = {
         reactVersion: options.jsx.version,
         components,
         lazyElements,
         props,
+        omitProps,
     };
 
     if (!options.force && !options.giRegenerated) {
@@ -57,6 +61,7 @@ const runJsxCodegen = async (options: RunJsxCodegenOptions): Promise<RunJsxCodeg
         components,
         lazyElements,
         props,
+        omitProps,
     });
 
     writeJsxStore(options.jsx, namespaces, metadata, {

package/src/react/element-config.ts

@@ -1,14 +1,16 @@
 import type { ModuleExport } from "@gtkx/react/config";
 import { readdirSync } from "node:fs";
+import type { OmittedProps } from "../store/jsx/omitted-props.js";
 
 /** The codegen-relevant subset of a React element config; behaviors are ignored at codegen time. */
-type BuiltinElement = { component?: ModuleExport; lazy?: boolean; props?: ModuleExport };
+type BuiltinElement = { component?: ModuleExport; lazy?: boolean; props?: ModuleExport; omitProps?: string[] };
 
 /** The framework's built-in element config, split into the maps codegen consumes. */
 type BuiltinElements = {
     components: Record<string, ModuleExport>;
     lazyElements: string[];
     props: Record<string, ModuleExport>;
+    omitProps: OmittedProps;
 };
 
 const CONFIG_ENTRYPOINT = "config";
@@ -59,6 +61,10 @@ const applyBuiltinElement = (target: BuiltinElements, type: string, config: Buil
         target.props[type] = config.props;
     }
 
+    if (config.omitProps !== undefined) {
+        target.omitProps[type] = [...(target.omitProps[type] ?? []), ...config.omitProps];
+    }
+
     if (config.lazy === true) {
         target.lazyElements.push(type);
     }
@@ -78,7 +84,7 @@ const collectBuiltinElements = (target: BuiltinElements, elements: Record<string
 const readBuiltinElements = async (reactSubexports: string[], giStoreDir: string): Promise<BuiltinElements> => {
     const present = presentNamespaceDirs(giStoreDir);
     const entrypoints = configEntrypoints(reactSubexports, present);
-    const result: BuiltinElements = { components: {}, lazyElements: [], props: {} };
+    const result: BuiltinElements = { components: {}, lazyElements: [], props: {}, omitProps: {} };
 
     for (const entrypoint of entrypoints) {
         collectBuiltinElements(result, await importBuiltinElements(entrypoint));

package/src/runner.ts

@@ -2,6 +2,7 @@ import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import type { GiStoreOptions } from "./store/gi-store.js";
 import type { JsxStoreOptions } from "./store/jsx-store.js";
+import type { OmittedProps } from "./store/jsx/omitted-props.js";
 import { checkModules } from "./compile.js";
 import { isGiStoreFresh } from "./fingerprint.js";
 import { runGiCodegen } from "./gi.js";
@@ -26,6 +27,7 @@ type CodegenRunnerOptions = {
     userComponents?: Record<string, ModuleExport>;
     userLazyElements?: string[];
     userProps?: Record<string, ModuleExport>;
+    userOmitProps?: OmittedProps;
     gl?: GlCodegenOptions;
     force?: boolean;
 };
@@ -95,11 +97,13 @@ const jsxUserOptions = (
     userComponents: Record<string, ModuleExport>;
     userLazyElements: string[];
     userProps: Record<string, ModuleExport>;
+    userOmitProps: OmittedProps;
 } => ({
     reactSubexports: options.reactSubexports ?? [],
     userComponents: options.userComponents ?? {},
     userLazyElements: options.userLazyElements ?? [],
     userProps: options.userProps ?? {},
+    userOmitProps: options.userOmitProps ?? {},
 });
 
 const emitJsxStore = async (input: {
@@ -140,7 +144,10 @@ const emitStoresWithConfig = async (config: {
     let library: Library | undefined;
     const loadLibrary = (): Library => (library ??= Library.load(libraries, girPath));
     const isGiRegenerated = options.force === true || !isGiStoreFresh(gi.storeDir, libraries, girPath);
-    const namespaces = isGiRegenerated ? runGiCodegen(loadLibrary(), gi, libraries, girPath) : 0;
+
+    const namespaces = isGiRegenerated
+        ? runGiCodegen(loadLibrary(), { gi, libraries, girPath })
+        : 0;
 
     if (jsx === undefined) {
         return { regenerated: isGiRegenerated, namespaces, intrinsicElements: 0 };

package/src/store/gi/callables.ts

@@ -5,7 +5,6 @@ import { hasCallerAllocatedArrayLength } from "../../analysis/param-structure.js
 import { renderJsDoc } from "../../writer/doc.js";
 import { renderBlock } from "../../writer/emit.js";
 import { matchAsyncFinish } from "./async.js";
-import { hasClassStructReference } from "./class-struct-record.js";
 import { renderFnExpression } from "./function.js";
 import { gtypeMemberDeclaration } from "./gtype-binding.js";
 import {
@@ -111,10 +110,6 @@ const renderBinding = (
         return undefined;
     }
 
-    if (hasClassStructReference(context, callable)) {
-        return undefined;
-    }
-
     const expression = renderFnExpression(context, callable);
 
     if (expression === undefined) {
@@ -371,7 +366,6 @@ const isEmittableCallable = (context: ModuleContext, callable: GirFunction): boo
     callable.introspectable &&
     callable.shadowedBy === undefined &&
     callable.cIdentifier !== undefined &&
-    !hasClassStructReference(context, callable) &&
     !hasCallerAllocatedArrayLength(context.library, callable);
 
 const constructorMemberName = (girName: string): string | undefined => {

package/src/store/gi/function.ts

@@ -7,7 +7,6 @@ import { hasCallerAllocatedArrayLength } from "../../analysis/param-structure.js
 import { renderJsDoc } from "../../writer/doc.js";
 import { arrayLiteral, renderBlock } from "../../writer/emit.js";
 import { matchAsyncFinish } from "./async.js";
-import { hasClassStructReference } from "./class-struct-record.js";
 import {
     planCallArgs,
     renderMethodBody,
@@ -63,7 +62,6 @@ const canEmitNamespaceFunction = (context: ModuleContext, fn: GirFunction): bool
     !isMovedOntoEmittedMember(context, fn) &&
     fn.shadowedBy === undefined &&
     fn.cIdentifier !== undefined &&
-    !hasClassStructReference(context, fn) &&
     !hasCallerAllocatedArrayLength(context.library, fn);
 
 const generateNamespaceFunction = (context: ModuleContext, fn: GirFunction): void => {

package/src/store/gi/method.ts

@@ -315,6 +315,7 @@ const renderReturnDescriptor = (context: ModuleContext, fn: GirFunction): string
     return renderDescriptor(context, fn.returnValue.type, fn.returnValue.transferOwnership, {
         argIndexOffset: instanceOffset,
         argIndexMap: emittedArgIndices(fn, instanceOffset),
+        isNewlyCreated: fn.instance === undefined,
     });
 };
 

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

@@ -7,8 +7,9 @@ import { renderDescriptor } from "../../analysis/descriptor-render.js";
 import { renderTsType } from "../../analysis/ts-type.js";
 import { renderBlock, renderBracedOrEmpty } from "../../writer/emit.js";
 import { renderSourceGtype } from "./gtype-binding.js";
-import { emitFieldWrite, isEmittableField } from "./record-field-accessor.js";
+import { emitFieldWrite, isEmittableField, isInlineField } from "./record-field-accessor.js";
 import { computeRecordFieldSlots, type RecordFieldSlot } from "./record-layout.js";
+import { isConstructibleRecord } from "./value-marshalable.js";
 
 type WritableFieldSlot = RecordFieldSlot & { field: GirField & { type: TypeId } };
 
@@ -24,7 +25,7 @@ const renderRecordConstructorPropsInterface = (
 ): string => {
     const head = `export interface ${className}ConstructorProps`;
 
-    if (isOpaque(record)) {
+    if (isOpaque(record) || !isConstructibleRecord(context, context.namespace.name, record)) {
         return renderBracedOrEmpty(head, "");
     }
 
@@ -68,7 +69,7 @@ const renderRecordConstructor = (
 ): string => {
     const superCall = isErrorSubclass ? ["super();"] : [];
 
-    if (isOpaque(record)) {
+    if (isOpaque(record) || !isConstructibleRecord(context, context.namespace.name, record)) {
         return renderOpaqueConstructor(className, superCall);
     }
 
@@ -103,7 +104,11 @@ const allocArgs = (context: ModuleContext, record: GirRecord, size: number): str
 
 const renderFieldWrite = (context: ModuleContext, entry: WritableFieldSlot): string => {
     context.addRuntimeImport("t");
-    const descriptor = context.hoistDescriptor(renderDescriptor(context, entry.field.type, "none"));
+
+    const descriptor = context.hoistDescriptor(
+        renderDescriptor(context, entry.field.type, "none", { isInline: isInlineField(context, entry.field) }),
+    );
+
     const name = toCamelIdentifier(entry.field.name);
 
     const write = emitFieldWrite(context, {

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

@@ -9,9 +9,9 @@ import { tStruct } from "../../analysis/descriptor.js";
 import { renderTsType } from "../../analysis/ts-type.js";
 import { renderJsDoc } from "../../writer/doc.js";
 import { indent, renderBlock } from "../../writer/emit.js";
-import { isClassStructRef } from "./class-struct-record.js";
 import { bitMask, computeRecordFieldSlots, mergeBitfield, type RecordFieldSlot } from "./record-layout.js";
 import { wrapReturnValue } from "./return-wrap.js";
+import { isValueMarshalable } from "./value-marshalable.js";
 
 type FieldWriteSpec = {
     descriptor: string;
@@ -91,18 +91,39 @@ 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;
+    }
+
+    const type = field.type === undefined ? undefined : context.library.typeFor(field.type);
+
+    if (type?.kind !== "record") {
+        return true;
+    }
+
+    return isValueMarshalable(context, type.namespace.name, type.value);
+};
+
 const isEmittableField = (context: ModuleContext, field: GirField): field is GirField & { type: TypeId } =>
     !field.private &&
     field.type !== undefined &&
     !isInlineCallbackRef(context.library, field.type) &&
-    !isClassStructRef(context, field.type);
+    isMarshalableField(context, field);
 
 const emitFieldWrite = (context: ModuleContext, spec: FieldWriteSpec): string => {
     const { descriptor, slot, targetExpr, valueExpr } = spec;
     context.addRuntimeImport("write");
 
     if (slot.bitWidth === undefined) {
-        return `write(${targetExpr}, ${descriptor}, ${String(slot.byteOffset)}, ${valueExpr});`;
+        context.addRuntimeImport("toNative");
+
+        return (
+            `write(${targetExpr}, ${descriptor}, ${String(slot.byteOffset)}, ` +
+            `toNative(${descriptor}, ${valueExpr}));`
+        );
     }
 
     context.addRuntimeImport("read");
@@ -192,8 +213,10 @@ const renderRecordFieldAccessor = (
 
     // 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 isInline = resolveInlineStructFields(context, field.type, field.cType) !== undefined;
-    const descriptor = context.hoistDescriptor(renderDescriptor(context, field.type, "none", { isInline }));
+    const descriptor = context.hoistDescriptor(
+        renderDescriptor(context, field.type, "none", { isInline: isInlineField(context, field) }),
+    );
+
     const tsType = renderTsType(context, field.type, false);
 
     const accessorOptions: AccessorOptions = {
@@ -246,6 +269,11 @@ 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;
+
 const resolveInlineStructFields = (
     context: ModuleContext,
     ref: TypeId | undefined,
@@ -604,4 +632,11 @@ const setterBlock = (options: AccessorOptions): string =>
         setterBody(options.context, options.descriptor, options.slot),
     );
 
-export { isEmittableField, emitFieldWrite, resolveRecordFieldEntry, renderRecordFieldAccessor, type RecordFieldEntry };
+export {
+    isEmittableField,
+    isInlineField,
+    emitFieldWrite,
+    resolveRecordFieldEntry,
+    renderRecordFieldAccessor,
+    type RecordFieldEntry,
+};

package/src/store/gi/record.ts

@@ -3,7 +3,6 @@ import type { ModuleContext } from "../../writer/context.js";
 import { renderJsDoc } from "../../writer/doc.js";
 import { indentMembers } from "../../writer/emit.js";
 import { type Callables, dedupeCallables, generateBindings, renderPlainTypeMembers } from "./callables.js";
-import { isClassStructRecord } from "./class-struct-record.js";
 import { renderSourceGtype } from "./gtype-binding.js";
 import { renderRecordConstructor, renderRecordConstructorPropsInterface } from "./record-constructor.js";
 import { renderRecordFieldAccessor } from "./record-field-accessor.js";
@@ -18,18 +17,10 @@ const generateRecord = (context: ModuleContext, record: GirRecord): void => {
         return;
     }
 
-    if (record.isVtable) {
-        return;
-    }
-
     if (record.name.length === 0) {
         return;
     }
 
-    if (isClassStructRecord(context.library, context.namespace.name, record)) {
-        return;
-    }
-
     const className = record.name;
     const isErrorSubclass = isGErrorRecord(context, record);