@gtkx/runtime 1.0.0-rc.4 → 1.1.0

package/dist/register-class.d.ts

@@ -1,25 +1,160 @@
 import { type AnyClass } from "@gtkx/utils";
 import { type PropertySpec } from "./properties.js";
+/**
+ * A generated interface value, such as `Gio.ListModel`, in the form {@link registerClass} takes it.
+ * `__impl__` exists only in the type system: it carries the interface's `Impl` type, of which a class
+ * has to match every member it declares itself, which rejects a class value and a member whose
+ * signature does not fit the slot it fills. Leaving a slot to the interface is not rejected,
+ * because `registerClass` does not reject it either: every member of an `Impl` type is optional,
+ * and the `Partial` holds that open whatever the type declares. The `object` beside it keeps
+ * TypeScript from also demanding one member in common. An interface that introspection describes
+ * no vtable for carries `unknown`, since it has no slot a class could fill.
+ */
+type Interface<TImpl> = AnyClass & {
+    /** Type-level slot holding the interface's `Impl` type; no value ever carries it. */
+    __impl__: (impl: Partial<TImpl> & object) => void;
+};
+/**
+ * One key of `RegisterClassOptions.properties` with every underscore turned into the dash a canonical
+ * GObject property name separates its words with.
+ */
+type Dashed<TName extends string> = TName extends `${infer THead}_${infer TTail}` ? Dashed<`${THead}-${TTail}`> : TName;
+/**
+ * One dashed key in the camelCase spelling the accessors {@link registerClass} installs carry, which is
+ * the spelling the hooks that address a property by name take.
+ */
+type Camelized<TName extends string> = TName extends `${infer THead}-${infer TTail}` ? `${THead}${Capitalize<Camelized<TTail>>}` : TName;
+/**
+ * The names a registered class carries in its property map: every key of
+ * `RegisterClassOptions.properties` in camelCase, whichever of the three spellings it was written in.
+ * A `properties` object given a type of its own rather than left to inference has `string` for its key
+ * type and names nothing, because a name only known as `string` addresses no member in particular.
+ */
+type InstalledNames<TProperties> = string extends keyof TProperties ? never : Camelized<Dashed<keyof TProperties & string>>;
+/**
+ * An instance of a registered class: everything the class itself declares, plus the property map the
+ * hooks that address a property by name, such as `useProperty` from `@gtkx/react`, read the installed
+ * names off. Each name is typed with the value type the class declares for the member of that name,
+ * so a property the class does not `declare` contributes nothing.
+ */
+type RegisteredInstance<TInstance, TProperties> = TInstance & {
+    /** Type-level map from installed property name to value type; no value ever carries it. */
+    __properties__: Pick<TInstance, InstalledNames<TProperties> & keyof TInstance>;
+};
+/**
+ * The construct signature and prototype a registered class carries, both giving
+ * {@link RegisteredInstance}. The signature stays abstract for as long as the class itself is, so
+ * registering an abstract base leaves it as impossible to construct as it was.
+ */
+type RegisteredConstructor<TClass, TArgs extends unknown[], TInstance> = {
+    /** Object the class's instances inherit from. */
+    prototype: TInstance;
+} & (TClass extends new (...args: never) => unknown ? new (...args: TArgs) => TInstance : abstract new (...args: TArgs) => TInstance);
+/**
+ * The class {@link registerClass} hands back: the same class, with the same statics, whose instances
+ * carry the properties `RegisterClassOptions.properties` installed. Binding the call to a name, rather
+ * than discarding it, is what carries those names into the type system.
+ */
+type RegisteredClass<TClass extends AnyClass, TProperties> = TClass extends abstract new (...args: infer TArgs) => infer TInstance ? Omit<TClass, "prototype"> & RegisteredConstructor<TClass, TArgs, RegisteredInstance<TInstance, TProperties>> : never;
 /** What {@link registerClass} adds to the new GType beyond the vtable slots it discovers on the class. */
-type RegisterClassOptions = {
+type RegisterClassOptions<TInstance extends object, TProperties extends Record<string, PropertySpec>> = {
     /** Name to register the new GType under, defaulting to the class's own name. */
     typeName?: string;
     /**
-     * Properties to install on the new type, keyed by canonical name and valued with the
-     * `GObject.ParamSpec` describing each. Every property gains dashed, underscored and camelCased
-     * prototype accessors that emit `notify` on write, unless the class already defines that name.
+     * Interfaces the new type implements on top of the ones it inherits, given as the interface values
+     * themselves, such as `Gio.ListModel`. Their vtable slots are filled from the `vfunc`-prefixed methods on
+     * the class's prototype chain, each of which has to match the interface's `Impl` type, such as
+     * `Gio.ListModelImpl`.
      */
-    properties?: Record<string, PropertySpec>;
+    implements?: Interface<TInstance>[];
+    /**
+     * Properties to install on the new type, keyed by the name JavaScript addresses each one by and
+     * valued with the `GObject.ParamSpec` describing it. A key is read in camelCase however it is
+     * written, so `dewPoint`, `dew_point` and `dew-point` all name the same member, and the ParamSpec
+     * has to carry the canonical spelling of that name, `dew-point`, or registration throws: the
+     * ParamSpec's name is the one GObject emits `notify` with, and a name the key does not spell
+     * reaches nothing that listens for it. Every property gains prototype accessors, one for the key
+     * as written, one for it with dashes turned into underscores and one for it in camelCase, each
+     * unless the class already defines that name. They serve the value from storage of their own on
+     * the instance, which is also what the type's `get_property` and `set_property` slots read and
+     * write, so a value set from JavaScript, from `g_object_set_property` and at construction all
+     * land in the same place.
+     *
+     * A write the ParamSpec would refuse throws rather than reaching GObject, which reports such a
+     * write as a GLib critical and drops it: a `TypeError` for a read-only or construct-only
+     * property and for a value of a type the property cannot hold, and a `RangeError` for a value
+     * the ParamSpec rejects. The same two checks run over a value handed to the constructor, where
+     * a construct-only property is the one that is writable. An accepted write emits one `notify`,
+     * which a `freeze_notify` batch collects; a write of the value the property already holds is
+     * dropped and emits none.
+     *
+     * `null` and `undefined` both mean NULL, and mean it only where the ParamSpec's own type holds
+     * NULL, which is a string, string-array, boxed, object, interface, param, variant or pointer
+     * property. Such a property holds the `null` either spelling wrote, so the member, the type's
+     * `get_property` slot and `g_object_get_property` serve the same thing, and writing the other
+     * spelling over it emits no `notify`. Every other property, so every integer, floating-point,
+     * boolean, enum, flags and GType one, refuses both with the same `TypeError` it refuses a
+     * string with, and keeps the value it already holds. It refuses them for what it holds rather
+     * than for its range, whatever that range is: the type is checked before the range, so a
+     * `gint` whose range excludes 0 answers a nullish with that same `TypeError` and never with
+     * the `RangeError` that names the value GObject would put in its place. The one place
+     * `undefined` means something else is the constructor, which reads it as the property not
+     * being given at all and leaves it at the ParamSpec's default, so a property is never handed a
+     * value it cannot serve back.
+     *
+     * A floating-point property takes every JavaScript number, `NaN` and both infinities
+     * included, and its ParamSpec alone rules on which of them the range admits: a `gdouble`
+     * bounded by `-Infinity` and `Infinity` holds either infinity, and a magnitude a bounded
+     * one excludes, like any `NaN`, comes back as the `RangeError` that names what GObject
+     * would put in its place rather than as the `TypeError` a type the property cannot hold
+     * earns. A `gfloat` property holds what GObject narrows the double to, so it serves `0.1`
+     * back as `0.10000000149011612` and a finite magnitude no `gfloat` reaches as an infinity,
+     * which the range then rules on in turn. That narrowing belongs to the property alone: the
+     * same magnitude written to a `gfloat` through a generated binding, a signal argument or a
+     * closure return is refused outright rather than narrowed.
+     *
+     * A generated property of a wrapped type answers a nullish differently, and the two halves of
+     * the API disagree here: that property marshals what it is written through its descriptor
+     * rather than through the checks above, so `new Gtk.Label({ widthRequest: null })` and a later
+     * write of `null` to that member both land 0, where a `gint` installed here refuses both.
+     *
+     * A class that defines the camelCase member itself owns the property: its own accessor decides
+     * what a write means, the other two spellings forward to it, and the type's property slots read
+     * and write it rather than the generated storage.
+     */
+    properties?: TProperties;
 };
 /**
- * Registers a subclass of a wrapper class as a new GType, wiring up any class and
- * inherited-interface virtual functions it overrides. Throws if the class does not
- * extend a registered wrapper class, has no derivable type name, or overrides an
- * unsupported construct-time vtable slot.
+ * Registers a subclass of a wrapper class as a new GType, wiring up any class and interface
+ * virtual functions it overrides, both for the interfaces it inherits and for the ones
+ * `RegisterClassOptions.implements` names.
+ *
+ * Throws when the class does not extend a registered wrapper class, when it has no derivable type
+ * name, when an entry in `RegisterClassOptions.implements` is not a registered interface, when a
+ * listed interface has a prerequisite that neither the parent type nor another listed interface meets,
+ * and when an entry in `RegisterClassOptions.properties` names its `GObject.ParamSpec` something other
+ * than the canonical spelling of the key it sits under.
+ *
+ * A slot is filled from the `vfunc`-prefixed methods on the class's prototype chain, up to but not
+ * including the registered ancestor the class extends, so a method an intermediate base class
+ * declares fills a slot the same way one the class itself declares does. A slot nothing on that
+ * chain fills is left untouched.
+ *
+ * Declare every slot as a method: a class field holding a function, such as `vfuncGetNItems = () => 1`,
+ * is assigned to each instance after registration and never reaches the vtable.
+ *
+ * An override of `vfuncConstructed` runs from inside the base constructor, before JavaScript
+ * installs the subclass's field initializers and runs its constructor body, so a field still
+ * reads `undefined` there and reading a `#private` field throws. Declare state the override
+ * touches without an initializer, and assign private state from the constructor body after
+ * `super()`. An instance a native caller creates, through `GObject.newv` or `Gtk.Builder`,
+ * never runs the subclass constructor at all, so its declared fields stay uninitialized for
+ * the object's whole life.
  *
  * @param klass The subclass to register.
- * @returns The same class, now registered.
+ * @param options What the new GType gains beyond the vtable slots the class overrides.
+ * @returns The same class, now registered, with every name in `options.properties` in its property map.
  */
-declare function registerClass<T extends AnyClass>(klass: T, options?: RegisterClassOptions): T;
-export { registerClass };
+declare function registerClass<T extends AnyClass, TProperties extends Record<string, PropertySpec> = Record<never, PropertySpec>>(klass: T, options?: RegisterClassOptions<T["prototype"], TProperties>): RegisteredClass<T, TProperties>;
+export { type Interface, registerClass };
 //# sourceMappingURL=register-class.d.ts.map

package/dist/register-class.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"register-class.d.ts","sourceRoot":"","sources":["../src/register-class.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,QAAQ,EAAkC,MAAM,aAAa,CAAC;AAE5E,OAAO,EAKH,KAAK,YAAY,EAEpB,MAAM,iBAAiB,CAAC;AAUzB,0GAA0G;AAC1G,KAAK,oBAAoB,GAAG;IACxB,gFAAgF;IAChF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;CAC7C,CAAC;AAWF;;;;;;;;GAQG;AACH,iBAAS,aAAa,CAAC,CAAC,SAAS,QAAQ,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,GAAE,oBAAyB,GAAG,CAAC,CAuB1F;AAgOD,OAAO,EAAE,aAAa,EAAE,CAAC"}
+{"version":3,"file":"register-class.d.ts","sourceRoot":"","sources":["../src/register-class.ts"],"names":[],"mappings":"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"}

package/dist/register-class.js

@@ -1,20 +1,19 @@
 import { registerClass as nativeRegisterClass, } from "@gtkx/native";
 import { getParentClass, walkClassChain } from "@gtkx/utils";
 import { wrapCallback } from "./callback.js";
-import { buildAccessors, makeGetProperty, makeSetProperty, toNativeProperties, } from "./properties.js";
-import { getClassType, getInterfaceVfuncRegistry, getVfuncRegistry, registerClassType, } from "./registry.js";
-import { TYPE_INVALID, typeInterfaces } from "./type.js";
-const UNSUPPORTED_CONSTRUCT_VFUNCS = new Set(["constructed", "setProperty", "getProperty"]);
+import { insertMixinLayer } from "./mixin.js";
+import { buildPropertyDispatch, GET_PROPERTY_VFUNC, makeGetProperty, makeSetProperty, SET_PROPERTY_VFUNC, toNativeProperties, } from "./properties.js";
+import { getClassType, getInterfaceMixin, markDerivedClass, registerClassType, } from "./registry.js";
+import { TYPE_INTERFACE, TYPE_INVALID, typeFundamental, typeInterfaces, typeIsA } from "./type.js";
+import { findClassVfuncDescriptor, findInterfaceVfuncDescriptor } from "./vfunc.js";
+const INSTANCE_ARG_INDEX = 0;
 const VALUE_ARG_INDEX = 2;
-/**
- * Registers a subclass of a wrapper class as a new GType, wiring up any class and
- * inherited-interface virtual functions it overrides. Throws if the class does not
- * extend a registered wrapper class, has no derivable type name, or overrides an
- * unsupported construct-time vtable slot.
- *
- * @param klass The subclass to register.
- * @returns The same class, now registered.
- */
+const TEARDOWN_VFUNC_NAMES = new Set(["dispose", "finalize"]);
+const PROPERTY_VFUNC_SPECS = [
+    { methodName: GET_PROPERTY_VFUNC, isValueOut: true, makeDispatch: makeGetProperty },
+    { methodName: SET_PROPERTY_VFUNC, isValueOut: false, makeDispatch: makeSetProperty },
+];
+const PROPERTY_VFUNC_NAMES = new Set(PROPERTY_VFUNC_SPECS.map((spec) => spec.methodName));
 function registerClass(klass, options = {}) {
     const parentType = resolveParentType(klass);
     if (parentType === TYPE_INVALID) {
@@ -24,35 +23,84 @@ function registerClass(klass, options = {}) {
     if (!name) {
         throw new Error("registerClass: cannot derive a GType name (anonymous class with no typeName option)");
     }
+    const declaredTypes = resolveInterfaceTypes(klass, options.implements ?? []);
+    const adoptedTypes = declaredTypes.filter((gtype) => !typeIsA(parentType, gtype));
     const properties = options.properties ?? {};
-    const accessors = buildAccessors(klass, properties);
-    const classVfuncs = [...discoverClassVfuncs(klass), ...propertyVfuncs(klass, accessors)];
+    const { methods, inheritedNames } = collectInstanceMembers(klass);
+    const dispatch = buildPropertyDispatch({ klass, properties, adoptedTypes });
+    const classVfuncs = [
+        ...discoverClassVfuncs(klass, methods),
+        ...propertyVfuncs({ klass, methods, dispatch, adoptedTypes }),
+    ];
     const claimedMethodNames = new Set(classVfuncs.map((vfunc) => vfunc.methodName));
-    const interfaceBindings = discoverInheritedInterfaceVfuncs(klass, parentType, claimedMethodNames);
+    const interfaceBindings = discoverInterfaceBindings(methods, parentType, declaredTypes, claimedMethodNames);
     const nativeOptions = toNativeOptions(classVfuncs, interfaceBindings, properties);
     const newType = nativeRegisterClass(name, parentType, nativeOptions);
     registerClassType(klass, newType);
+    markDerivedClass(klass);
+    applyInterfaceMixins(klass, adoptedTypes, inheritedNames);
     return klass;
 }
+function resolveInterfaceType(klass, entry) {
+    const gtype = getClassType(entry);
+    if (typeFundamental(gtype) !== TYPE_INTERFACE) {
+        const label = typeof entry === "function" ? entry.name : String(entry);
+        throw new TypeError(`registerClass: ${klass.name} lists '${label}' in implements, which is not a registered interface`);
+    }
+    return gtype;
+}
+function resolveInterfaceTypes(klass, entries) {
+    return [...new Set(entries.map((entry) => resolveInterfaceType(klass, entry)))];
+}
+function applyInterfaceMixins(klass, adoptedTypes, inheritedNames) {
+    for (const gtype of adoptedTypes) {
+        const mixin = getInterfaceMixin(gtype);
+        if (mixin !== undefined) {
+            insertMixinLayer(klass, mixin, inheritedNames);
+        }
+    }
+}
 function resolveParentType(klass) {
     return (walkClassChain(getParentClass(klass), (cls) => {
         const gtype = getClassType(cls);
         return gtype === TYPE_INVALID ? undefined : gtype;
     }) ?? TYPE_INVALID);
 }
-function ownInstanceMethodNames(klass) {
+function addOwnMember(members, proto, name, isInherited) {
+    if (name === "constructor") {
+        return;
+    }
+    if (isInherited) {
+        members.inheritedNames.add(name);
+    }
+    if (members.names.has(name)) {
+        return;
+    }
+    members.names.add(name);
+    const descriptor = Object.getOwnPropertyDescriptor(proto, name);
+    if (typeof descriptor?.value === "function") {
+        members.methods.set(name, descriptor.value);
+    }
+}
+function addOwnMembers(members, klass, isInherited) {
     const proto = klass.prototype;
-    if (!proto) {
-        return [];
+    if (proto === undefined) {
+        return;
     }
-    return Object.getOwnPropertyNames(proto).filter((name) => {
-        if (name === "constructor") {
-            return false;
-        }
-        return typeof Object.getOwnPropertyDescriptor(proto, name)?.value === "function";
-    });
+    for (const name of Object.getOwnPropertyNames(proto)) {
+        addOwnMember(members, proto, name, isInherited);
+    }
+}
+function collectInstanceMembers(klass) {
+    const members = { methods: new Map(), names: new Set(), inheritedNames: new Set() };
+    let cls = klass;
+    while (cls !== null && getClassType(cls) === TYPE_INVALID) {
+        addOwnMembers(members, cls, cls !== klass);
+        cls = getParentClass(cls);
+    }
+    return members;
 }
-function buildDiscoveredVfunc(proto, methodName, resolveDescriptor, skip) {
+function buildDiscoveredVfunc(fn, methodName, resolveDescriptor, skip) {
     if (skip?.has(methodName)) {
         return undefined;
     }
@@ -60,78 +108,69 @@ function buildDiscoveredVfunc(proto, methodName, resolveDescriptor, skip) {
     if (!descriptor) {
         return undefined;
     }
-    const fn = proto[methodName];
-    if (!fn) {
-        return undefined;
-    }
+    const argDescriptors = slotArgDescriptors(descriptor);
     return {
         ...descriptor,
         methodName,
-        fn: wrapVfunc(fn, descriptor.argDescriptors, descriptor.returnDescriptor),
+        argDescriptors,
+        fn: wrapVfunc(fn, argDescriptors, descriptor),
     };
 }
-function collectDiscoveredVfuncs(klass, resolveDescriptor, skip) {
-    const proto = klass.prototype;
+function collectDiscoveredVfuncs(methods, resolveDescriptor, skip) {
     const result = [];
-    for (const methodName of ownInstanceMethodNames(klass)) {
-        const discovered = buildDiscoveredVfunc(proto, methodName, resolveDescriptor, skip);
+    for (const [methodName, fn] of methods) {
+        const discovered = buildDiscoveredVfunc(fn, methodName, resolveDescriptor, skip);
         if (discovered) {
             result.push(discovered);
         }
     }
     return result;
 }
-function discoverClassVfuncs(klass) {
-    return collectDiscoveredVfuncs(klass, (methodName) => {
-        const descriptor = findClassVfuncDescriptor(klass, methodName);
-        if (descriptor && UNSUPPORTED_CONSTRUCT_VFUNCS.has(methodName)) {
-            throw new Error(`registerClass: overriding the GObject construct-time vtable slot '${methodName}' is not ` +
-                "supported; run construct-time initialization in the subclass constructor, after " +
-                "super(...), instead");
-        }
-        return descriptor ?? undefined;
-    });
+function discoverClassVfuncs(klass, methods) {
+    return collectDiscoveredVfuncs(methods, (methodName) => findClassVfuncDescriptor(klass, methodName) ?? undefined, PROPERTY_VFUNC_NAMES);
 }
-function wrapVfunc(fn, argDescriptors, returnDescriptor) {
-    return wrapCallback(fn, { argDescriptors, returnDescriptor }, "this");
+function wrapVfunc(fn, argDescriptors, descriptor) {
+    return wrapCallback(fn, { argDescriptors, returnDescriptor: descriptor.returnDescriptor }, "vfunc");
 }
-function discoverInheritedInterfaceVfuncs(klass, parentGtype, claimedMethodNames) {
+function discoverInterfaceBindings(methods, parentGtype, declaredTypes, claimedMethodNames) {
+    const declared = new Set(declaredTypes);
+    const gtypes = new Set([...typeInterfaces(parentGtype), ...declaredTypes]);
     const bindings = [];
-    for (const interfaceGtype of typeInterfaces(parentGtype)) {
-        const [first, ...rest] = discoverInterfaceVfuncs(klass, interfaceGtype, claimedMethodNames);
-        if (first !== undefined) {
-            bindings.push({ gtype: interfaceGtype, vtableSize: first.vtableSize, vfuncs: [first, ...rest] });
+    for (const gtype of gtypes) {
+        const vfuncs = discoverInterfaceVfuncs(methods, gtype, claimedMethodNames);
+        if (vfuncs.length > 0 || declared.has(gtype)) {
+            bindings.push({ gtype, vfuncs });
         }
     }
     return bindings;
 }
-function discoverInterfaceVfuncs(klass, interfaceGtype, claimedMethodNames) {
-    const vfuncRegistry = getInterfaceVfuncRegistry(interfaceGtype);
-    if (!vfuncRegistry) {
-        return [];
-    }
-    return collectDiscoveredVfuncs(klass, (methodName) => {
-        const entry = vfuncRegistry[methodName];
-        return entry?.kind === "interface" ? entry : undefined;
-    }, claimedMethodNames);
+function discoverInterfaceVfuncs(methods, interfaceGtype, claimedMethodNames) {
+    return collectDiscoveredVfuncs(methods, (methodName) => findInterfaceVfuncDescriptor(interfaceGtype, methodName), claimedMethodNames);
 }
-function findClassVfuncDescriptor(klass, methodName) {
-    return (walkClassChain(getParentClass(klass), (cls) => {
-        const entry = getVfuncRegistry(cls)?.[methodName];
-        return entry?.kind === "class" ? entry : undefined;
-    }) ?? null);
+const hasDispatchedProperties = (dispatch, adoptedTypes) => dispatch.accessors.length > 0 || adoptedTypes.length > 0;
+function propertyVfuncFor(source, spec) {
+    const { klass, methods, dispatch, adoptedTypes } = source;
+    const dispatched = hasDispatchedProperties(dispatch, adoptedTypes)
+        ? spec.makeDispatch(dispatch)
+        : undefined;
+    const fn = methods.get(spec.methodName) ?? dispatched;
+    return fn === undefined ? undefined : buildPropertyVfunc(klass, spec.methodName, fn, spec.isValueOut);
 }
-function propertyVfuncs(klass, accessors) {
-    if (accessors.length === 0) {
-        return [];
-    }
-    return [
-        buildPropertyVfunc(klass, "getProperty", makeGetProperty(accessors), true),
-        buildPropertyVfunc(klass, "setProperty", makeSetProperty(accessors), false),
-    ];
+function propertyVfuncs(source) {
+    return PROPERTY_VFUNC_SPECS.map((spec) => propertyVfuncFor(source, spec)).filter((vfunc) => vfunc !== undefined);
+}
+function markArg(argDescriptors, index, patch) {
+    return argDescriptors.map((arg, at) => (at === index ? { ...arg, ...patch } : arg));
 }
-function markValueCallerAllocated(argDescriptors) {
-    return argDescriptors.map((arg, index) => index === VALUE_ARG_INDEX ? { ...arg, isCallerAllocated: true } : arg);
+function isTeardownSlot(descriptor) {
+    return (TEARDOWN_VFUNC_NAMES.has(descriptor.vfuncName) &&
+        descriptor.argDescriptors[INSTANCE_ARG_INDEX]?.kind === "object");
+}
+function slotArgDescriptors(descriptor) {
+    if (!isTeardownSlot(descriptor)) {
+        return descriptor.argDescriptors;
+    }
+    return markArg(descriptor.argDescriptors, INSTANCE_ARG_INDEX, { isCallScoped: true });
 }
 function buildPropertyVfunc(klass, methodName, fn, isValueOut) {
     const descriptor = findClassVfuncDescriptor(klass, methodName);
@@ -139,15 +178,26 @@ function buildPropertyVfunc(klass, methodName, fn, isValueOut) {
         throw new Error(`registerClass: the parent class exposes no '${methodName}' vtable slot`);
     }
     const argDescriptors = isValueOut
-        ? markValueCallerAllocated(descriptor.argDescriptors)
+        ? markArg(descriptor.argDescriptors, VALUE_ARG_INDEX, { isCallerAllocated: true })
         : descriptor.argDescriptors;
     return {
         ...descriptor,
         methodName,
         argDescriptors,
-        fn: wrapVfunc(fn, argDescriptors, descriptor.returnDescriptor),
+        fn: wrapVfunc(fn, argDescriptors, descriptor),
     };
 }
+function toNativeInterface(binding) {
+    const nativeInterface = {
+        type: binding.gtype,
+        vfuncs: [...binding.vfuncs],
+    };
+    const vtableSize = binding.vfuncs[0]?.vtableSize;
+    if (vtableSize !== undefined) {
+        nativeInterface.vtableSize = vtableSize;
+    }
+    return nativeInterface;
+}
 function toNativeOptions(classVfuncs, interfaceBindings, properties) {
     const hasInterfaces = interfaceBindings.length > 0;
     const hasClassVfuncs = classVfuncs.length > 0;
@@ -163,11 +213,7 @@ function toNativeOptions(classVfuncs, interfaceBindings, properties) {
         options.vfuncs = [...classVfuncs];
     }
     if (hasInterfaces) {
-        options.interfaces = interfaceBindings.map((binding) => ({
-            type: binding.gtype,
-            vtableSize: binding.vtableSize,
-            vfuncs: [...binding.vfuncs],
-        }));
+        options.interfaces = interfaceBindings.map((binding) => toNativeInterface(binding));
     }
     return options;
 }

package/dist/register-class.js.map

@@ -1 +1 @@
-{"version":3,"file":"register-class.js","sourceRoot":"","sources":["../src/register-class.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Descriptor } from \"@gtkx/native\";\nimport {\n    registerClass as nativeRegisterClass,\n    type RegisterClassOptions as NativeRegisterClassOptions,\n    type RegisterClassVfunc as NativeRegisterClassVfunc,\n} from \"@gtkx/native\";\nimport { type AnyClass, getParentClass, walkClassChain } from \"@gtkx/utils\";\nimport { wrapCallback } from \"./callback.js\";\nimport {\n    buildAccessors,\n    makeGetProperty,\n    makeSetProperty,\n    type PropertyAccessor,\n    type PropertySpec,\n    toNativeProperties,\n} from \"./properties.js\";\nimport {\n    getClassType,\n    getInterfaceVfuncRegistry,\n    getVfuncRegistry,\n    registerClassType,\n    type VfuncDescriptor,\n} from \"./registry.js\";\nimport { TYPE_INVALID, typeInterfaces } from \"./type.js\";\n\n/** What {@link registerClass} adds to the new GType beyond the vtable slots it discovers on the class. */\ntype RegisterClassOptions = {\n    /** Name to register the new GType under, defaulting to the class's own name. */\n    typeName?: string;\n    /**\n     * Properties to install on the new type, keyed by canonical name and valued with the\n     * `GObject.ParamSpec` describing each. Every property gains dashed, underscored and camelCased\n     * prototype accessors that emit `notify` on write, unless the class already defines that name.\n     */\n    properties?: Record<string, PropertySpec>;\n};\n\ntype VfuncFn = NativeRegisterClassVfunc[\"fn\"];\ntype DiscoveredVfunc<K extends \"class\" | \"interface\"> = VfuncDescriptor<K> & { methodName: string; fn: VfuncFn };\ntype DiscoveredClassVfunc = DiscoveredVfunc<\"class\">;\ntype DiscoveredInterfaceVfunc = DiscoveredVfunc<\"interface\">;\ntype InterfaceVfuncBinding = { gtype: bigint; vtableSize: number; vfuncs: DiscoveredInterfaceVfunc[] };\n\nconst UNSUPPORTED_CONSTRUCT_VFUNCS: Set<string> = new Set([\"constructed\", \"setProperty\", \"getProperty\"]);\nconst VALUE_ARG_INDEX = 2;\n\n/**\n * Registers a subclass of a wrapper class as a new GType, wiring up any class and\n * inherited-interface virtual functions it overrides. Throws if the class does not\n * extend a registered wrapper class, has no derivable type name, or overrides an\n * unsupported construct-time vtable slot.\n *\n * @param klass The subclass to register.\n * @returns The same class, now registered.\n */\nfunction registerClass<T extends AnyClass>(klass: T, options: RegisterClassOptions = {}): T {\n    const parentType = resolveParentType(klass);\n\n    if (parentType === TYPE_INVALID) {\n        throw new TypeError(`registerClass: ${klass.name} must extend a registered wrapper class`);\n    }\n\n    const name = options.typeName ?? klass.name;\n\n    if (!name) {\n        throw new Error(\"registerClass: cannot derive a GType name (anonymous class with no typeName option)\");\n    }\n\n    const properties = options.properties ?? {};\n    const accessors = buildAccessors(klass, properties);\n    const classVfuncs = [...discoverClassVfuncs(klass), ...propertyVfuncs(klass, accessors)];\n    const claimedMethodNames = new Set(classVfuncs.map((vfunc) => vfunc.methodName));\n    const interfaceBindings = discoverInheritedInterfaceVfuncs(klass, parentType, claimedMethodNames);\n    const nativeOptions = toNativeOptions(classVfuncs, interfaceBindings, properties);\n    const newType: bigint = nativeRegisterClass(name, parentType, nativeOptions);\n    registerClassType(klass, newType);\n\n    return klass;\n}\n\nfunction resolveParentType(klass: AnyClass): bigint {\n    return (\n        walkClassChain(getParentClass(klass), (cls) => {\n            const gtype = getClassType(cls);\n\n            return gtype === TYPE_INVALID ? undefined : gtype;\n        }) ?? TYPE_INVALID\n    );\n}\n\nfunction ownInstanceMethodNames(klass: AnyClass): string[] {\n    const proto = (klass as { prototype?: object }).prototype;\n\n    if (!proto) {\n        return [];\n    }\n\n    return Object.getOwnPropertyNames(proto).filter((name) => {\n        if (name === \"constructor\") {\n            return false;\n        }\n\n        return typeof Object.getOwnPropertyDescriptor(proto, name)?.value === \"function\";\n    });\n}\n\nfunction buildDiscoveredVfunc<K extends \"class\" | \"interface\">(\n    proto: Record<string, VfuncFn>,\n    methodName: string,\n    resolveDescriptor: (methodName: string) => VfuncDescriptor<K> | undefined,\n    skip: Set<string> | undefined,\n): DiscoveredVfunc<K> | undefined {\n    if (skip?.has(methodName)) {\n        return undefined;\n    }\n\n    const descriptor = resolveDescriptor(methodName);\n\n    if (!descriptor) {\n        return undefined;\n    }\n\n    const fn = proto[methodName];\n\n    if (!fn) {\n        return undefined;\n    }\n\n    return {\n        ...descriptor,\n        methodName,\n        fn: wrapVfunc(fn, descriptor.argDescriptors, descriptor.returnDescriptor),\n    };\n}\n\nfunction collectDiscoveredVfuncs<K extends \"class\" | \"interface\">(\n    klass: AnyClass,\n    resolveDescriptor: (methodName: string) => VfuncDescriptor<K> | undefined,\n    skip?: Set<string>,\n): DiscoveredVfunc<K>[] {\n    const proto = (klass as { prototype: Record<string, VfuncFn> }).prototype;\n    const result: DiscoveredVfunc<K>[] = [];\n\n    for (const methodName of ownInstanceMethodNames(klass)) {\n        const discovered = buildDiscoveredVfunc(proto, methodName, resolveDescriptor, skip);\n\n        if (discovered) {\n            result.push(discovered);\n        }\n    }\n\n    return result;\n}\n\nfunction discoverClassVfuncs(klass: AnyClass): DiscoveredClassVfunc[] {\n    return collectDiscoveredVfuncs(klass, (methodName) => {\n        const descriptor = findClassVfuncDescriptor(klass, methodName);\n\n        if (descriptor && UNSUPPORTED_CONSTRUCT_VFUNCS.has(methodName)) {\n            throw new Error(\n                `registerClass: overriding the GObject construct-time vtable slot '${methodName}' is not ` +\n                \"supported; run construct-time initialization in the subclass constructor, after \" +\n                \"super(...), instead\",\n            );\n        }\n\n        return descriptor ?? undefined;\n    });\n}\n\nfunction wrapVfunc(\n    fn: VfuncFn,\n    argDescriptors: NativeRegisterClassVfunc[\"argDescriptors\"],\n    returnDescriptor: NativeRegisterClassVfunc[\"returnDescriptor\"],\n): VfuncFn {\n    return wrapCallback(fn as (...args: unknown[]) => unknown, { argDescriptors, returnDescriptor }, \"this\");\n}\n\nfunction discoverInheritedInterfaceVfuncs(\n    klass: AnyClass,\n    parentGtype: bigint,\n    claimedMethodNames: Set<string>,\n): InterfaceVfuncBinding[] {\n    const bindings: InterfaceVfuncBinding[] = [];\n\n    for (const interfaceGtype of typeInterfaces(parentGtype)) {\n        const [first, ...rest] = discoverInterfaceVfuncs(klass, interfaceGtype, claimedMethodNames);\n\n        if (first !== undefined) {\n            bindings.push({ gtype: interfaceGtype, vtableSize: first.vtableSize, vfuncs: [first, ...rest] });\n        }\n    }\n\n    return bindings;\n}\n\nfunction discoverInterfaceVfuncs(\n    klass: AnyClass,\n    interfaceGtype: bigint,\n    claimedMethodNames: Set<string>,\n): DiscoveredInterfaceVfunc[] {\n    const vfuncRegistry = getInterfaceVfuncRegistry(interfaceGtype);\n\n    if (!vfuncRegistry) {\n        return [];\n    }\n\n    return collectDiscoveredVfuncs(\n        klass,\n        (methodName) => {\n            const entry = vfuncRegistry[methodName];\n\n            return entry?.kind === \"interface\" ? entry : undefined;\n        },\n        claimedMethodNames,\n    );\n}\n\nfunction findClassVfuncDescriptor(klass: AnyClass, methodName: string): VfuncDescriptor<\"class\"> | null {\n    return (\n        walkClassChain(getParentClass(klass), (cls) => {\n            const entry = getVfuncRegistry(cls)?.[methodName];\n\n            return entry?.kind === \"class\" ? entry : undefined;\n        }) ?? null\n    );\n}\n\nfunction propertyVfuncs(klass: AnyClass, accessors: PropertyAccessor[]): DiscoveredClassVfunc[] {\n    if (accessors.length === 0) {\n        return [];\n    }\n\n    return [\n        buildPropertyVfunc(klass, \"getProperty\", makeGetProperty(accessors), true),\n        buildPropertyVfunc(klass, \"setProperty\", makeSetProperty(accessors), false),\n    ];\n}\n\nfunction markValueCallerAllocated(argDescriptors: Descriptor[]): Descriptor[] {\n    return argDescriptors.map((arg, index) =>\n        index === VALUE_ARG_INDEX ? { ...arg, isCallerAllocated: true } : arg);\n}\n\nfunction buildPropertyVfunc(\n    klass: AnyClass,\n    methodName: string,\n    fn: VfuncFn,\n    isValueOut: boolean,\n): DiscoveredClassVfunc {\n    const descriptor = findClassVfuncDescriptor(klass, methodName);\n\n    if (!descriptor) {\n        throw new Error(`registerClass: the parent class exposes no '${methodName}' vtable slot`);\n    }\n\n    const argDescriptors = isValueOut\n        ? markValueCallerAllocated(descriptor.argDescriptors)\n        : descriptor.argDescriptors;\n\n    return {\n        ...descriptor,\n        methodName,\n        argDescriptors,\n        fn: wrapVfunc(fn, argDescriptors, descriptor.returnDescriptor),\n    };\n}\n\nfunction toNativeOptions(\n    classVfuncs: DiscoveredClassVfunc[],\n    interfaceBindings: InterfaceVfuncBinding[],\n    properties: Record<string, PropertySpec>,\n): NativeRegisterClassOptions | undefined {\n    const hasInterfaces = interfaceBindings.length > 0;\n    const hasClassVfuncs = classVfuncs.length > 0;\n    const hasProperties = Object.keys(properties).length > 0;\n\n    if (!hasClassVfuncs && !hasInterfaces && !hasProperties) {\n        return undefined;\n    }\n\n    const options: NativeRegisterClassOptions = {};\n\n    if (hasProperties) {\n        options.properties = toNativeProperties(properties);\n    }\n\n    if (hasClassVfuncs) {\n        options.vfuncs = [...classVfuncs];\n    }\n\n    if (hasInterfaces) {\n        options.interfaces = interfaceBindings.map((binding) => ({\n            type: binding.gtype,\n            vtableSize: binding.vtableSize,\n            vfuncs: [...binding.vfuncs],\n        }));\n    }\n\n    return options;\n}\n\nexport { registerClass };\n"]}
+{"version":3,"file":"register-class.js","sourceRoot":"","sources":["../src/register-class.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Descriptor } from \"@gtkx/native\";\nimport {\n    registerClass as nativeRegisterClass,\n    type RegisterClassInterface as NativeRegisterClassInterface,\n    type RegisterClassOptions as NativeRegisterClassOptions,\n    type RegisterClassVfunc as NativeRegisterClassVfunc,\n} from \"@gtkx/native\";\nimport { type AnyClass, getParentClass, walkClassChain } from \"@gtkx/utils\";\nimport { wrapCallback } from \"./callback.js\";\nimport { insertMixinLayer } from \"./mixin.js\";\nimport {\n    buildPropertyDispatch,\n    GET_PROPERTY_VFUNC,\n    makeGetProperty,\n    makeSetProperty,\n    type PropertyDispatch,\n    type PropertySpec,\n    SET_PROPERTY_VFUNC,\n    toNativeProperties,\n} from \"./properties.js\";\nimport {\n    getClassType,\n    getInterfaceMixin,\n    markDerivedClass,\n    registerClassType,\n    type VfuncDescriptor,\n} from \"./registry.js\";\nimport { TYPE_INTERFACE, TYPE_INVALID, typeFundamental, typeInterfaces, typeIsA } from \"./type.js\";\nimport { findClassVfuncDescriptor, findInterfaceVfuncDescriptor } from \"./vfunc.js\";\n\n/**\n * A generated interface value, such as `Gio.ListModel`, in the form {@link registerClass} takes it.\n * `__impl__` exists only in the type system: it carries the interface's `Impl` type, of which a class\n * has to match every member it declares itself, which rejects a class value and a member whose\n * signature does not fit the slot it fills. Leaving a slot to the interface is not rejected,\n * because `registerClass` does not reject it either: every member of an `Impl` type is optional,\n * and the `Partial` holds that open whatever the type declares. The `object` beside it keeps\n * TypeScript from also demanding one member in common. An interface that introspection describes\n * no vtable for carries `unknown`, since it has no slot a class could fill.\n */\ntype Interface<TImpl> = AnyClass & {\n    /** Type-level slot holding the interface's `Impl` type; no value ever carries it. */\n    __impl__: (impl: Partial<TImpl> & object) => void;\n};\n\n/**\n * One key of `RegisterClassOptions.properties` with every underscore turned into the dash a canonical\n * GObject property name separates its words with.\n */\ntype Dashed<TName extends string> = TName extends `${infer THead}_${infer TTail}`\n    ? Dashed<`${THead}-${TTail}`>\n    : TName;\n\n/**\n * One dashed key in the camelCase spelling the accessors {@link registerClass} installs carry, which is\n * the spelling the hooks that address a property by name take.\n */\ntype Camelized<TName extends string> = TName extends `${infer THead}-${infer TTail}`\n    ? `${THead}${Capitalize<Camelized<TTail>>}`\n    : TName;\n\n/**\n * The names a registered class carries in its property map: every key of\n * `RegisterClassOptions.properties` in camelCase, whichever of the three spellings it was written in.\n * A `properties` object given a type of its own rather than left to inference has `string` for its key\n * type and names nothing, because a name only known as `string` addresses no member in particular.\n */\ntype InstalledNames<TProperties> = string extends keyof TProperties\n    ? never\n    : Camelized<Dashed<keyof TProperties & string>>;\n\n/**\n * An instance of a registered class: everything the class itself declares, plus the property map the\n * hooks that address a property by name, such as `useProperty` from `@gtkx/react`, read the installed\n * names off. Each name is typed with the value type the class declares for the member of that name,\n * so a property the class does not `declare` contributes nothing.\n */\ntype RegisteredInstance<TInstance, TProperties> = TInstance & {\n    /** Type-level map from installed property name to value type; no value ever carries it. */\n    __properties__: Pick<TInstance, InstalledNames<TProperties> & keyof TInstance>;\n};\n\n/**\n * The construct signature and prototype a registered class carries, both giving\n * {@link RegisteredInstance}. The signature stays abstract for as long as the class itself is, so\n * registering an abstract base leaves it as impossible to construct as it was.\n */\ntype RegisteredConstructor<TClass, TArgs extends unknown[], TInstance> = {\n    /** Object the class's instances inherit from. */\n    prototype: TInstance;\n} & (TClass extends new (...args: never) => unknown\n    ? new (...args: TArgs) => TInstance\n    : abstract new (...args: TArgs) => TInstance);\n\n/**\n * The class {@link registerClass} hands back: the same class, with the same statics, whose instances\n * carry the properties `RegisterClassOptions.properties` installed. Binding the call to a name, rather\n * than discarding it, is what carries those names into the type system.\n */\ntype RegisteredClass<TClass extends AnyClass, TProperties> =\n    TClass extends abstract new (...args: infer TArgs) => infer TInstance\n        ? Omit<TClass, \"prototype\"> & RegisteredConstructor<TClass, TArgs, RegisteredInstance<TInstance, TProperties>>\n        : never;\n\n/** What {@link registerClass} adds to the new GType beyond the vtable slots it discovers on the class. */\ntype RegisterClassOptions<TInstance extends object, TProperties extends Record<string, PropertySpec>> = {\n    /** Name to register the new GType under, defaulting to the class's own name. */\n    typeName?: string;\n    /**\n     * Interfaces the new type implements on top of the ones it inherits, given as the interface values\n     * themselves, such as `Gio.ListModel`. Their vtable slots are filled from the `vfunc`-prefixed methods on\n     * the class's prototype chain, each of which has to match the interface's `Impl` type, such as\n     * `Gio.ListModelImpl`.\n     */\n    implements?: Interface<TInstance>[];\n    /**\n     * Properties to install on the new type, keyed by the name JavaScript addresses each one by and\n     * valued with the `GObject.ParamSpec` describing it. A key is read in camelCase however it is\n     * written, so `dewPoint`, `dew_point` and `dew-point` all name the same member, and the ParamSpec\n     * has to carry the canonical spelling of that name, `dew-point`, or registration throws: the\n     * ParamSpec's name is the one GObject emits `notify` with, and a name the key does not spell\n     * reaches nothing that listens for it. Every property gains prototype accessors, one for the key\n     * as written, one for it with dashes turned into underscores and one for it in camelCase, each\n     * unless the class already defines that name. They serve the value from storage of their own on\n     * the instance, which is also what the type's `get_property` and `set_property` slots read and\n     * write, so a value set from JavaScript, from `g_object_set_property` and at construction all\n     * land in the same place.\n     *\n     * A write the ParamSpec would refuse throws rather than reaching GObject, which reports such a\n     * write as a GLib critical and drops it: a `TypeError` for a read-only or construct-only\n     * property and for a value of a type the property cannot hold, and a `RangeError` for a value\n     * the ParamSpec rejects. The same two checks run over a value handed to the constructor, where\n     * a construct-only property is the one that is writable. An accepted write emits one `notify`,\n     * which a `freeze_notify` batch collects; a write of the value the property already holds is\n     * dropped and emits none.\n     *\n     * `null` and `undefined` both mean NULL, and mean it only where the ParamSpec's own type holds\n     * NULL, which is a string, string-array, boxed, object, interface, param, variant or pointer\n     * property. Such a property holds the `null` either spelling wrote, so the member, the type's\n     * `get_property` slot and `g_object_get_property` serve the same thing, and writing the other\n     * spelling over it emits no `notify`. Every other property, so every integer, floating-point,\n     * boolean, enum, flags and GType one, refuses both with the same `TypeError` it refuses a\n     * string with, and keeps the value it already holds. It refuses them for what it holds rather\n     * than for its range, whatever that range is: the type is checked before the range, so a\n     * `gint` whose range excludes 0 answers a nullish with that same `TypeError` and never with\n     * the `RangeError` that names the value GObject would put in its place. The one place\n     * `undefined` means something else is the constructor, which reads it as the property not\n     * being given at all and leaves it at the ParamSpec's default, so a property is never handed a\n     * value it cannot serve back.\n     *\n     * A floating-point property takes every JavaScript number, `NaN` and both infinities\n     * included, and its ParamSpec alone rules on which of them the range admits: a `gdouble`\n     * bounded by `-Infinity` and `Infinity` holds either infinity, and a magnitude a bounded\n     * one excludes, like any `NaN`, comes back as the `RangeError` that names what GObject\n     * would put in its place rather than as the `TypeError` a type the property cannot hold\n     * earns. A `gfloat` property holds what GObject narrows the double to, so it serves `0.1`\n     * back as `0.10000000149011612` and a finite magnitude no `gfloat` reaches as an infinity,\n     * which the range then rules on in turn. That narrowing belongs to the property alone: the\n     * same magnitude written to a `gfloat` through a generated binding, a signal argument or a\n     * closure return is refused outright rather than narrowed.\n     *\n     * A generated property of a wrapped type answers a nullish differently, and the two halves of\n     * the API disagree here: that property marshals what it is written through its descriptor\n     * rather than through the checks above, so `new Gtk.Label({ widthRequest: null })` and a later\n     * write of `null` to that member both land 0, where a `gint` installed here refuses both.\n     *\n     * A class that defines the camelCase member itself owns the property: its own accessor decides\n     * what a write means, the other two spellings forward to it, and the type's property slots read\n     * and write it rather than the generated storage.\n     */\n    properties?: TProperties;\n};\n\n/** {@link RegisterClassOptions} with the widest instance and property types {@link registerClass} accepts. */\ntype AnyRegisterClassOptions = RegisterClassOptions<object, Record<string, PropertySpec>>;\ntype VfuncFn = NativeRegisterClassVfunc[\"fn\"];\ntype DiscoveredVfunc = VfuncDescriptor & { methodName: string; fn: VfuncFn };\ntype MethodTable = Map<string, VfuncFn>;\ntype InstanceMembers = { methods: MethodTable; names: Set<string>; inheritedNames: Set<string> };\n\ntype InterfaceVfuncBinding = {\n    gtype: bigint;\n    vfuncs: DiscoveredVfunc[];\n};\n\ntype PropertyVfuncSource = {\n    klass: AnyClass;\n    methods: MethodTable;\n    dispatch: PropertyDispatch;\n    adoptedTypes: bigint[];\n};\n\ntype PropertyVfuncSpec = {\n    methodName: string;\n    isValueOut: boolean;\n    makeDispatch: (dispatch: PropertyDispatch) => VfuncFn;\n};\n\ntype ArgPatch = { isCallerAllocated: true } | { isCallScoped: true };\n\nconst INSTANCE_ARG_INDEX = 0;\nconst VALUE_ARG_INDEX = 2;\nconst TEARDOWN_VFUNC_NAMES: Set<string> = new Set([\"dispose\", \"finalize\"]);\n\nconst PROPERTY_VFUNC_SPECS: PropertyVfuncSpec[] = [\n    { methodName: GET_PROPERTY_VFUNC, isValueOut: true, makeDispatch: makeGetProperty },\n    { methodName: SET_PROPERTY_VFUNC, isValueOut: false, makeDispatch: makeSetProperty },\n];\n\nconst PROPERTY_VFUNC_NAMES: Set<string> = new Set(PROPERTY_VFUNC_SPECS.map((spec) => spec.methodName));\n\n/**\n * Registers a subclass of a wrapper class as a new GType, wiring up any class and interface\n * virtual functions it overrides, both for the interfaces it inherits and for the ones\n * `RegisterClassOptions.implements` names.\n *\n * Throws when the class does not extend a registered wrapper class, when it has no derivable type\n * name, when an entry in `RegisterClassOptions.implements` is not a registered interface, when a\n * listed interface has a prerequisite that neither the parent type nor another listed interface meets,\n * and when an entry in `RegisterClassOptions.properties` names its `GObject.ParamSpec` something other\n * than the canonical spelling of the key it sits under.\n *\n * A slot is filled from the `vfunc`-prefixed methods on the class's prototype chain, up to but not\n * including the registered ancestor the class extends, so a method an intermediate base class\n * declares fills a slot the same way one the class itself declares does. A slot nothing on that\n * chain fills is left untouched.\n *\n * Declare every slot as a method: a class field holding a function, such as `vfuncGetNItems = () => 1`,\n * is assigned to each instance after registration and never reaches the vtable.\n *\n * An override of `vfuncConstructed` runs from inside the base constructor, before JavaScript\n * installs the subclass's field initializers and runs its constructor body, so a field still\n * reads `undefined` there and reading a `#private` field throws. Declare state the override\n * touches without an initializer, and assign private state from the constructor body after\n * `super()`. An instance a native caller creates, through `GObject.newv` or `Gtk.Builder`,\n * never runs the subclass constructor at all, so its declared fields stay uninitialized for\n * the object's whole life.\n *\n * @param klass The subclass to register.\n * @param options What the new GType gains beyond the vtable slots the class overrides.\n * @returns The same class, now registered, with every name in `options.properties` in its property map.\n */\nfunction registerClass<\n    T extends AnyClass,\n    TProperties extends Record<string, PropertySpec> = Record<never, PropertySpec>,\n>(klass: T, options?: RegisterClassOptions<T[\"prototype\"], TProperties>): RegisteredClass<T, TProperties>;\n\nfunction registerClass(klass: AnyClass, options: AnyRegisterClassOptions = {}): AnyClass {\n    const parentType = resolveParentType(klass);\n\n    if (parentType === TYPE_INVALID) {\n        throw new TypeError(`registerClass: ${klass.name} must extend a registered wrapper class`);\n    }\n\n    const name = options.typeName ?? klass.name;\n\n    if (!name) {\n        throw new Error(\"registerClass: cannot derive a GType name (anonymous class with no typeName option)\");\n    }\n\n    const declaredTypes = resolveInterfaceTypes(klass, options.implements ?? []);\n    const adoptedTypes = declaredTypes.filter((gtype) => !typeIsA(parentType, gtype));\n    const properties = options.properties ?? {};\n    const { methods, inheritedNames } = collectInstanceMembers(klass);\n    const dispatch = buildPropertyDispatch({ klass, properties, adoptedTypes });\n\n    const classVfuncs = [\n        ...discoverClassVfuncs(klass, methods),\n        ...propertyVfuncs({ klass, methods, dispatch, adoptedTypes }),\n    ];\n\n    const claimedMethodNames = new Set(classVfuncs.map((vfunc) => vfunc.methodName));\n    const interfaceBindings = discoverInterfaceBindings(methods, parentType, declaredTypes, claimedMethodNames);\n    const nativeOptions = toNativeOptions(classVfuncs, interfaceBindings, properties);\n    const newType: bigint = nativeRegisterClass(name, parentType, nativeOptions);\n    registerClassType(klass, newType);\n    markDerivedClass(klass);\n    applyInterfaceMixins(klass, adoptedTypes, inheritedNames);\n\n    return klass;\n}\n\nfunction resolveInterfaceType(klass: AnyClass, entry: AnyClass): bigint {\n    const gtype = getClassType(entry);\n\n    if (typeFundamental(gtype) !== TYPE_INTERFACE) {\n        const label = typeof entry === \"function\" ? entry.name : String(entry);\n\n        throw new TypeError(\n            `registerClass: ${klass.name} lists '${label}' in implements, which is not a registered interface`,\n        );\n    }\n\n    return gtype;\n}\n\nfunction resolveInterfaceTypes(klass: AnyClass, entries: AnyClass[]): bigint[] {\n    return [...new Set(entries.map((entry) => resolveInterfaceType(klass, entry)))];\n}\n\nfunction applyInterfaceMixins(klass: AnyClass, adoptedTypes: bigint[], inheritedNames: Set<string>): void {\n    for (const gtype of adoptedTypes) {\n        const mixin = getInterfaceMixin(gtype);\n\n        if (mixin !== undefined) {\n            insertMixinLayer(klass, mixin, inheritedNames);\n        }\n    }\n}\n\nfunction resolveParentType(klass: AnyClass): bigint {\n    return (\n        walkClassChain(getParentClass(klass), (cls) => {\n            const gtype = getClassType(cls);\n\n            return gtype === TYPE_INVALID ? undefined : gtype;\n        }) ?? TYPE_INVALID\n    );\n}\n\nfunction addOwnMember(members: InstanceMembers, proto: object, name: string, isInherited: boolean): void {\n    if (name === \"constructor\") {\n        return;\n    }\n\n    if (isInherited) {\n        members.inheritedNames.add(name);\n    }\n\n    if (members.names.has(name)) {\n        return;\n    }\n\n    members.names.add(name);\n    const descriptor = Object.getOwnPropertyDescriptor(proto, name);\n\n    if (typeof descriptor?.value === \"function\") {\n        members.methods.set(name, descriptor.value as VfuncFn);\n    }\n}\n\nfunction addOwnMembers(members: InstanceMembers, klass: AnyClass, isInherited: boolean): void {\n    const proto = (klass as { prototype?: object }).prototype;\n\n    if (proto === undefined) {\n        return;\n    }\n\n    for (const name of Object.getOwnPropertyNames(proto)) {\n        addOwnMember(members, proto, name, isInherited);\n    }\n}\n\nfunction collectInstanceMembers(klass: AnyClass): InstanceMembers {\n    const members: InstanceMembers = { methods: new Map(), names: new Set(), inheritedNames: new Set() };\n    let cls: AnyClass | null = klass;\n\n    while (cls !== null && getClassType(cls) === TYPE_INVALID) {\n        addOwnMembers(members, cls, cls !== klass);\n        cls = getParentClass(cls);\n    }\n\n    return members;\n}\n\nfunction buildDiscoveredVfunc(\n    fn: VfuncFn,\n    methodName: string,\n    resolveDescriptor: (methodName: string) => VfuncDescriptor | undefined,\n    skip: Set<string> | undefined,\n): DiscoveredVfunc | undefined {\n    if (skip?.has(methodName)) {\n        return undefined;\n    }\n\n    const descriptor = resolveDescriptor(methodName);\n\n    if (!descriptor) {\n        return undefined;\n    }\n\n    const argDescriptors = slotArgDescriptors(descriptor);\n\n    return {\n        ...descriptor,\n        methodName,\n        argDescriptors,\n        fn: wrapVfunc(fn, argDescriptors, descriptor),\n    };\n}\n\nfunction collectDiscoveredVfuncs(\n    methods: MethodTable,\n    resolveDescriptor: (methodName: string) => VfuncDescriptor | undefined,\n    skip?: Set<string>,\n): DiscoveredVfunc[] {\n    const result: DiscoveredVfunc[] = [];\n\n    for (const [methodName, fn] of methods) {\n        const discovered = buildDiscoveredVfunc(fn, methodName, resolveDescriptor, skip);\n\n        if (discovered) {\n            result.push(discovered);\n        }\n    }\n\n    return result;\n}\n\nfunction discoverClassVfuncs(klass: AnyClass, methods: MethodTable): DiscoveredVfunc[] {\n    return collectDiscoveredVfuncs(\n        methods,\n        (methodName) => findClassVfuncDescriptor(klass, methodName) ?? undefined,\n        PROPERTY_VFUNC_NAMES,\n    );\n}\n\nfunction wrapVfunc(\n    fn: VfuncFn,\n    argDescriptors: NativeRegisterClassVfunc[\"argDescriptors\"],\n    descriptor: VfuncDescriptor,\n): VfuncFn {\n    return wrapCallback(\n        fn as (...args: unknown[]) => unknown,\n        { argDescriptors, returnDescriptor: descriptor.returnDescriptor },\n        \"vfunc\",\n    );\n}\n\nfunction discoverInterfaceBindings(\n    methods: MethodTable,\n    parentGtype: bigint,\n    declaredTypes: bigint[],\n    claimedMethodNames: Set<string>,\n): InterfaceVfuncBinding[] {\n    const declared: Set<bigint> = new Set(declaredTypes);\n    const gtypes: Set<bigint> = new Set([...typeInterfaces(parentGtype), ...declaredTypes]);\n    const bindings: InterfaceVfuncBinding[] = [];\n\n    for (const gtype of gtypes) {\n        const vfuncs = discoverInterfaceVfuncs(methods, gtype, claimedMethodNames);\n\n        if (vfuncs.length > 0 || declared.has(gtype)) {\n            bindings.push({ gtype, vfuncs });\n        }\n    }\n\n    return bindings;\n}\n\nfunction discoverInterfaceVfuncs(\n    methods: MethodTable,\n    interfaceGtype: bigint,\n    claimedMethodNames: Set<string>,\n): DiscoveredVfunc[] {\n    return collectDiscoveredVfuncs(\n        methods,\n        (methodName) => findInterfaceVfuncDescriptor(interfaceGtype, methodName),\n        claimedMethodNames,\n    );\n}\n\nconst hasDispatchedProperties = (dispatch: PropertyDispatch, adoptedTypes: bigint[]): boolean =>\n    dispatch.accessors.length > 0 || adoptedTypes.length > 0;\n\nfunction propertyVfuncFor(\n    source: PropertyVfuncSource,\n    spec: PropertyVfuncSpec,\n): DiscoveredVfunc | undefined {\n    const { klass, methods, dispatch, adoptedTypes } = source;\n\n    const dispatched = hasDispatchedProperties(dispatch, adoptedTypes)\n        ? spec.makeDispatch(dispatch)\n        : undefined;\n\n    const fn = methods.get(spec.methodName) ?? dispatched;\n\n    return fn === undefined ? undefined : buildPropertyVfunc(klass, spec.methodName, fn, spec.isValueOut);\n}\n\nfunction propertyVfuncs(source: PropertyVfuncSource): DiscoveredVfunc[] {\n    return PROPERTY_VFUNC_SPECS.map((spec) => propertyVfuncFor(source, spec)).filter(\n        (vfunc) => vfunc !== undefined,\n    );\n}\n\nfunction markArg(argDescriptors: Descriptor[], index: number, patch: ArgPatch): Descriptor[] {\n    return argDescriptors.map((arg, at) => (at === index ? { ...arg, ...patch } : arg));\n}\n\nfunction isTeardownSlot(descriptor: VfuncDescriptor): boolean {\n    return (\n        TEARDOWN_VFUNC_NAMES.has(descriptor.vfuncName) &&\n        descriptor.argDescriptors[INSTANCE_ARG_INDEX]?.kind === \"object\"\n    );\n}\n\nfunction slotArgDescriptors(descriptor: VfuncDescriptor): Descriptor[] {\n    if (!isTeardownSlot(descriptor)) {\n        return descriptor.argDescriptors;\n    }\n\n    return markArg(descriptor.argDescriptors, INSTANCE_ARG_INDEX, { isCallScoped: true });\n}\n\nfunction buildPropertyVfunc(\n    klass: AnyClass,\n    methodName: string,\n    fn: VfuncFn,\n    isValueOut: boolean,\n): DiscoveredVfunc {\n    const descriptor = findClassVfuncDescriptor(klass, methodName);\n\n    if (!descriptor) {\n        throw new Error(`registerClass: the parent class exposes no '${methodName}' vtable slot`);\n    }\n\n    const argDescriptors = isValueOut\n        ? markArg(descriptor.argDescriptors, VALUE_ARG_INDEX, { isCallerAllocated: true })\n        : descriptor.argDescriptors;\n\n    return {\n        ...descriptor,\n        methodName,\n        argDescriptors,\n        fn: wrapVfunc(fn, argDescriptors, descriptor),\n    };\n}\n\nfunction toNativeInterface(binding: InterfaceVfuncBinding): NativeRegisterClassInterface {\n    const nativeInterface: NativeRegisterClassInterface = {\n        type: binding.gtype,\n        vfuncs: [...binding.vfuncs],\n    };\n\n    const vtableSize = binding.vfuncs[0]?.vtableSize;\n\n    if (vtableSize !== undefined) {\n        nativeInterface.vtableSize = vtableSize;\n    }\n\n    return nativeInterface;\n}\n\nfunction toNativeOptions(\n    classVfuncs: DiscoveredVfunc[],\n    interfaceBindings: InterfaceVfuncBinding[],\n    properties: Record<string, PropertySpec>,\n): NativeRegisterClassOptions | undefined {\n    const hasInterfaces = interfaceBindings.length > 0;\n    const hasClassVfuncs = classVfuncs.length > 0;\n    const hasProperties = Object.keys(properties).length > 0;\n\n    if (!hasClassVfuncs && !hasInterfaces && !hasProperties) {\n        return undefined;\n    }\n\n    const options: NativeRegisterClassOptions = {};\n\n    if (hasProperties) {\n        options.properties = toNativeProperties(properties);\n    }\n\n    if (hasClassVfuncs) {\n        options.vfuncs = [...classVfuncs];\n    }\n\n    if (hasInterfaces) {\n        options.interfaces = interfaceBindings.map((binding) => toNativeInterface(binding));\n    }\n\n    return options;\n}\n\nexport { type Interface, registerClass };\n"]}