@gtkx/runtime 1.0.0 → 1.2.0

package/src/internal.ts

@@ -1,4 +1,5 @@
 export { checkError, createErrorDomain } from "./error.js";
+export { type ApplicationInstance, getApplicationInstance } from "./lifecycle.js";
 export { registerClassType, resolveWrapperClass, wrapHandle } from "./registry.js";
 export { hasSignalListener } from "./signal.js";
 export { resolveType } from "./type.js";

package/src/library.ts

@@ -1,6 +1,7 @@
 import { type BoxedDescriptor, boxedT, type FundamentalDescriptor, fundamentalT } from "./descriptors.js";
 
 const LIB = "libgobject-2.0.so.0,libglib-2.0.so.0";
+const GIO_LIB = "libgio-2.0.so.0";
 const VALUE_SIZE = 24;
 const CLOSURE_SIZE = 32;
 const VALUE_T: BoxedDescriptor = boxedT("GValue", { sharedLibrary: LIB, getTypeFnName: "g_value_get_type" });
@@ -15,4 +16,4 @@ const VARIANT_T: FundamentalDescriptor = fundamentalT(LIB, "g_variant_ref", "g_v
     typeName: "GVariant",
 });
 
-export { CLOSURE_SIZE, LIB, VALUE_SIZE, VALUE_T, PARAM_T, VARIANT_T };
+export { CLOSURE_SIZE, GIO_LIB, LIB, VALUE_SIZE, VALUE_T, PARAM_T, VARIANT_T };

package/src/lifecycle.ts

@@ -1,5 +1,6 @@
 import { keepAlive, quit as nativeQuit } from "@gtkx/native";
 import { isDerivedApplication, type LocalCommandLineApplication, shutDownThroughRun } from "./application-class.js";
+import { claimDefaultApplication, releaseDefaultApplication } from "./default-application.js";
 
 /**
  * The GIO and GTK application surface {@link runApplication} and {@link quitApplication} drive, so any
@@ -30,6 +31,8 @@ type ApplicationLike = {
     emit(signal: "shutdown"): unknown;
 };
 
+type ApplicationInstance = "primary" | "remote" | "shutDown" | "unregistered";
+
 /** What {@link runApplication} reports about the process it just started. */
 type RunApplicationResult = {
     /** Whether this process owns the application ID and may build a user interface. */
@@ -40,6 +43,7 @@ type RunApplicationResult = {
 
 const shutdownCallbacks: (() => void)[] = [];
 const startedApplications: WeakSet<object> = new WeakSet();
+const registeredApplications: WeakSet<object> = new WeakSet();
 const shutDownApplications: WeakSet<object> = new WeakSet();
 /**
  * Runs every registered exit callback and shuts down the native runtime. Safe to
@@ -101,6 +105,14 @@ const restartApplication = (application: ApplicationLike): number => {
     return 0;
 };
 
+const getApplicationInstance = (application: ApplicationLike): ApplicationInstance => {
+    if (!application.getIsRegistered()) {
+        return registeredApplications.has(application) ? "shutDown" : "unregistered";
+    }
+
+    return application.getIsRemote?.() === true ? "remote" : "primary";
+};
+
 /**
  * Hands `argv` to GLib's own command line handling, which parses the application's options, prints
  * `--help`, runs `handle-local-options`, registers the application, and either activates it or
@@ -119,6 +131,13 @@ const restartApplication = (application: ApplicationLike): number => {
  * user interface may be built here, because a remote application has no `GtkApplicationImpl` and
  * attaching a window to it crashes.
  *
+ * The application also claims the process-wide default `Gio.Application.getDefault()` returns, before
+ * its command line is parsed, so an `activate` handler and anything the host reads afterwards see the
+ * application being started rather than an earlier one. That holds whether the start ends registered,
+ * remote or unregistered: a refused command line still has to be reportable through the default, which
+ * is how `gtkx dev` learns which application its entry mounted. {@link quitApplication} gives the
+ * default back up, since GLib drops it only at finalize.
+ *
  * @param application The application to start.
  * @param argv The command line, whose first entry names the program as `--help` should print it.
  * @returns Whether this process may build a user interface, and the status to exit with.
@@ -132,11 +151,19 @@ const runApplication = (application: ApplicationLike, argv: string[]): RunApplic
         );
     }
 
+    claimDefaultApplication(application);
+
     const exitStatus = startedApplications.has(application)
         ? restartApplication(application)
         : startApplication(application, argv);
 
-    const isPrimary = application.getIsRegistered() && application.getIsRemote?.() !== true;
+    const instance = getApplicationInstance(application);
+
+    if (instance !== "unregistered") {
+        registeredApplications.add(application);
+    }
+
+    const isPrimary = instance === "primary";
 
     if (isPrimary) {
         keepAlive(true);
@@ -145,18 +172,7 @@ const runApplication = (application: ApplicationLike, argv: string[]): RunApplic
     return { isPrimary, exitStatus };
 };
 
-/**
- * Detaches every window from the application and runs GLib's own shutdown, which emits `shutdown`,
- * destroys the application implementation and releases the D-Bus registration. Does nothing for an
- * application that is not registered, so a repeated call is a no-op.
- *
- * GLib's own shutdown is reachable once per application: reaching it marks the application as
- * quitting, which GLib never undoes. An application that has already quit falls back to emitting
- * `shutdown`, which releases the runtime and leaves the registration for GLib to drop at finalize.
- *
- * @param application The application to shut down.
- */
-const quitApplication = (application: ApplicationLike): void => {
+const tearDownApplication = (application: ApplicationLike): void => {
     if (!application.getIsRegistered() || shutDownApplications.has(application)) {
         return;
     }
@@ -175,4 +191,34 @@ const quitApplication = (application: ApplicationLike): void => {
     }
 };
 
-export { onExit, quit, runApplication, quitApplication, type ApplicationLike, type RunApplicationResult };
+/**
+ * Detaches every window from the application and runs GLib's own shutdown, which emits `shutdown`,
+ * destroys the application implementation and releases the D-Bus registration. Does nothing for an
+ * application that is not registered, so a repeated call is a no-op.
+ *
+ * GLib's own shutdown is reachable once per application: reaching it marks the application as
+ * quitting, which GLib never undoes. An application that has already quit falls back to emitting
+ * `shutdown`, which releases the runtime and leaves the registration for GLib to drop at finalize.
+ *
+ * The process-wide default {@link runApplication} claimed is given up whichever of those paths the
+ * application took, including the ones that have no teardown left to do, so
+ * `Gio.Application.getDefault()` never hands back an application that has been torn down or that
+ * never registered in the first place. GLib clears that default only at finalize, which a
+ * garbage-collected wrapper reaches arbitrarily late or never.
+ *
+ * @param application The application to shut down.
+ */
+const quitApplication = (application: ApplicationLike): void => {
+    tearDownApplication(application);
+    releaseDefaultApplication(application);
+};
+
+export {
+    getApplicationInstance,
+    onExit,
+    quit,
+    runApplication,
+    quitApplication,
+    type ApplicationInstance,
+    type RunApplicationResult,
+};

package/src/listeners.ts

@@ -11,10 +11,10 @@ type SignalConnectable = {
     disconnect(handlerId: number): void;
 };
 
-const listenerTable: WeakMap<object, Map<string, Map<SignalHandler, number>>> = new WeakMap();
+const listenerTable: WeakMap<object, Map<string, Map<SignalHandler, number[]>>> = new WeakMap();
 
 const findListenerHandlerId = (instance: object, signal: string, handler: SignalHandler): number | undefined =>
-    listenerTable.get(instance)?.get(signal)?.get(handler);
+    listenerTable.get(instance)?.get(signal)?.get(handler)?.at(-1);
 
 const trackListener = (instance: object, signal: string, handler: SignalHandler, handlerId: number): void => {
     let bySignal = listenerTable.get(instance);
@@ -31,7 +31,24 @@ const trackListener = (instance: object, signal: string, handler: SignalHandler,
         bySignal.set(signal, byHandler);
     }
 
-    byHandler.set(handler, handlerId);
+    let handlerIds = byHandler.get(handler);
+
+    if (!handlerIds) {
+        handlerIds = [];
+        byHandler.set(handler, handlerIds);
+    }
+
+    handlerIds.push(handlerId);
+};
+
+const removeTrackedHandlerId = (handlerIds: number[], handlerId: number): number => {
+    const index = handlerIds.lastIndexOf(handlerId);
+
+    if (index !== -1) {
+        handlerIds.splice(index, 1);
+    }
+
+    return handlerIds.length;
 };
 
 const untrackHandlerId = (instance: object, signal: string, handlerId: number): void => {
@@ -42,8 +59,8 @@ const untrackHandlerId = (instance: object, signal: string, handlerId: number):
         return;
     }
 
-    for (const [handler, id] of byHandler) {
-        if (id === handlerId) {
+    for (const [handler, handlerIds] of byHandler) {
+        if (removeTrackedHandlerId(handlerIds, handlerId) === 0) {
             byHandler.delete(handler);
         }
     }

package/src/native-value.ts

@@ -1,6 +1,6 @@
 import type { Descriptor, ExternalObject, Handle } from "@gtkx/native";
 import type { ArrayDescriptor, FundamentalDescriptor, HashTableDescriptor, StructDescriptor } from "./descriptors.js";
-import { getHandle, getWrapperClass, wrapHandle, wrapObject } from "./registry.js";
+import { getHandle, getWrapperClass, wrapCallScopedObject, wrapHandle, wrapObject } from "./registry.js";
 import { resolveDescriptorType } from "./type.js";
 
 type MarshalledKind = "object" | "struct" | "boxed" | "fundamental" | "array" | "hashtable";
@@ -76,7 +76,7 @@ function fromNative(descriptor: Descriptor, value: unknown): unknown {
 
     switch (descriptor.kind) {
         case "object": {
-            return wrapObject(value);
+            return descriptor.isCallScoped === true ? wrapCallScopedObject(value) : wrapObject(value);
         }
         case "struct": {
             return wrapHandle(value as ExternalObject<Handle> | null, (descriptor as StructDescriptor).wrapperClass);

package/src/object.ts

@@ -121,7 +121,9 @@ function constructPropertyForEntry(
  * that name, dashed or camelCased, and is skipped when the type installs none.
  * A value that ParamSpec would refuse throws before GObject sees it: a `TypeError`
  * for a read-only property and for a value of a type the property cannot hold, and
- * a `RangeError` for a value the ParamSpec rejects.
+ * a `RangeError` for a value the ParamSpec rejects. A value marshalled through a
+ * declared descriptor is converted rather than checked, so a `null` handed to a
+ * numeric one of those lands 0 rather than being refused.
  * Properties whose value is `undefined` are skipped. A type registered with
  * `registerClass` binds the wrapper before its `constructed` slot runs, so an
  * override of that slot already sees a usable instance.
@@ -168,7 +170,10 @@ function getObjectProperty(obj: object, propertyName: string, descriptor: Descri
 
 /**
  * Writes a JavaScript value to a GObject property, converting it to native form
- * using the descriptor.
+ * using the descriptor. The descriptor converts what it is given rather than checking it against
+ * the property's `GObject.ParamSpec`, so `null` and `undefined` written to a numeric or enum
+ * property land 0, where the same write to a property installed through `registerClass` is
+ * refused with a `TypeError`.
  *
  * @param obj The object to write to.
  * @param propertyName The property name.

package/src/param-spec.ts

@@ -13,6 +13,7 @@ import {
     TYPE_ENUM,
     TYPE_FLAGS,
     TYPE_FLOAT,
+    TYPE_GTYPE,
     TYPE_INT,
     TYPE_INT64,
     TYPE_INTERFACE,
@@ -51,7 +52,6 @@ const UINT32_MAXIMUM = 4_294_967_295;
 const INT64_MINIMUM = -(2n ** 63n);
 const INT64_MAXIMUM = 2n ** 63n - 1n;
 const UINT64_MAXIMUM = 2n ** 64n - 1n;
-const FLOAT_MAXIMUM = 3.4028234663852886e38;
 
 const WRAPPED_FUNDAMENTALS: Set<bigint> = new Set([
     TYPE_BOXED,
@@ -61,6 +61,8 @@ const WRAPPED_FUNDAMENTALS: Set<bigint> = new Set([
     TYPE_VARIANT,
 ]);
 
+const isWideUnsignedValue: ValueGuard = wideIntegerGuardFor(0n, UINT64_MAXIMUM);
+
 const SCALAR_GUARDS: Map<bigint, ValueGuard> = new Map([
     [TYPE_BOOLEAN, isBooleanValue],
     [TYPE_STRING, isStringValue],
@@ -71,11 +73,11 @@ const SCALAR_GUARDS: Map<bigint, ValueGuard> = new Map([
     [TYPE_ENUM, integerGuardFor(INT32_MINIMUM, INT32_MAXIMUM)],
     [TYPE_FLAGS, integerGuardFor(0, UINT32_MAXIMUM)],
     [TYPE_LONG, wideIntegerGuardFor(INT64_MINIMUM, INT64_MAXIMUM)],
-    [TYPE_ULONG, wideIntegerGuardFor(0n, UINT64_MAXIMUM)],
+    [TYPE_ULONG, isWideUnsignedValue],
     [TYPE_INT64, wideIntegerGuardFor(INT64_MINIMUM, INT64_MAXIMUM)],
-    [TYPE_UINT64, wideIntegerGuardFor(0n, UINT64_MAXIMUM)],
-    [TYPE_FLOAT, isFloatValue],
-    [TYPE_DOUBLE, isDoubleValue],
+    [TYPE_UINT64, isWideUnsignedValue],
+    [TYPE_FLOAT, isNumberValue],
+    [TYPE_DOUBLE, isNumberValue],
     [TYPE_POINTER, isNullValue],
 ]);
 
@@ -115,12 +117,8 @@ function isStrvValue(value: unknown): boolean {
     return value == null || (Array.isArray(value) && value.every((item) => typeof item === "string"));
 }
 
-function isDoubleValue(value: unknown): boolean {
-    return value == null || (typeof value === "number" && Number.isFinite(value));
-}
-
-function isFloatValue(value: unknown): boolean {
-    return isDoubleValue(value) && (value == null || Math.abs(value as number) <= FLOAT_MAXIMUM);
+function isNumberValue(value: unknown): boolean {
+    return typeof value === "number";
 }
 
 function isAnyValue(): boolean {
@@ -131,12 +129,8 @@ function isNullValue(value: unknown): boolean {
     return value == null;
 }
 
-function isIntegerWithin(value: unknown, minimum: number, maximum: number): boolean {
-    return Number.isSafeInteger(value) && (value as number) >= minimum && (value as number) <= maximum;
-}
-
 function integerGuardFor(minimum: number, maximum: number): ValueGuard {
-    return (value) => value == null || isIntegerWithin(value, minimum, maximum);
+    return (value) => Number.isSafeInteger(value) && (value as number) >= minimum && (value as number) <= maximum;
 }
 
 function toWideInteger(value: unknown): bigint | undefined {
@@ -149,10 +143,6 @@ function toWideInteger(value: unknown): bigint | undefined {
 
 function wideIntegerGuardFor(minimum: bigint, maximum: bigint): ValueGuard {
     return (value) => {
-        if (value == null) {
-            return true;
-        }
-
         const wide = toWideInteger(value);
 
         return wide !== undefined && wide >= minimum && wide <= maximum;
@@ -173,11 +163,20 @@ function wrappedGuardFor(valueType: bigint): ValueGuard {
     return (value) => value == null || typeIsA(resolveGtype(value), valueType);
 }
 
+function exactGuardFor(valueType: bigint): ValueGuard | undefined {
+    if (valueType === TYPE_GTYPE) {
+        return isWideUnsignedValue;
+    }
+
+    return valueType === getStrvType() ? isStrvValue : undefined;
+}
+
 function valueGuardFor(valueType: bigint): ValueGuard {
     assertParamLayout();
+    const exact = exactGuardFor(valueType);
 
-    if (valueType === getStrvType()) {
-        return isStrvValue;
+    if (exact !== undefined) {
+        return exact;
     }
 
     const fundamental = typeFundamental(valueType);

package/src/properties.ts

@@ -16,7 +16,14 @@ import {
 } from "./param-spec.js";
 import { getHandle, getInterfaceProperties, instanceClassName, type InterfaceProperty } from "./registry.js";
 import { typeName } from "./type.js";
-import { fromValue, intoValue, newValueForType, type ValueWriter, valueWriterFor } from "./value.js";
+import {
+    fromValue,
+    newValueForType,
+    type ValueNarrower,
+    valueNarrowerFor,
+    type ValueWriter,
+    valueWriterFor,
+} from "./value.js";
 
 type PropertyCheck = {
     name: string;
@@ -25,6 +32,7 @@ type PropertyCheck = {
     flags: number;
     valueType: bigint;
     canHoldValue: ValueGuard;
+    narrowValue: ValueNarrower;
     write?: ValueWriter;
     scratch?: ExternalObject<Handle>;
 };
@@ -80,6 +88,8 @@ const typeLabel = (type: bigint): string => typeName(type) ?? String(type);
 const defaultValueFor = (handle: ExternalObject<Handle>): ExternalObject<Handle> =>
     paramSpecDefaultValue(handle) as ExternalObject<Handle>;
 
+const heldValue = (value: unknown): unknown => value ?? null;
+
 const holdsReason = (check: PropertyCheck): string =>
     `the property holds values of type '${typeLabel(check.valueType)}'`;
 
@@ -93,6 +103,7 @@ function checkFor(handle: ExternalObject<Handle>, name: string): PropertyCheck {
         flags: getParamFlags(handle),
         valueType,
         canHoldValue: valueGuardFor(valueType),
+        narrowValue: valueNarrowerFor(valueType),
     };
 }
 
@@ -168,6 +179,11 @@ function assertWritable(instance: object, check: PropertyCheck, value: unknown):
     throw new TypeError(propertyMessage(instance, check, refusalTail(check, value, READ_ONLY_REASON)));
 }
 
+function writeHeld(check: PropertyCheck, gValue: ExternalObject<Handle>, value: unknown): void {
+    check.write ??= valueWriterFor(check.valueType);
+    check.write(gValue, check.narrowValue(value));
+}
+
 function fillCheckedValue(
     instance: object,
     check: PropertyCheck,
@@ -175,8 +191,7 @@ function fillCheckedValue(
     value: unknown,
 ): void {
     assertValueFits(instance, check, value);
-    check.write ??= valueWriterFor(check.valueType);
-    check.write(gValue, value);
+    writeHeld(check, gValue, value);
     assertValueValidates(instance, check, value, gValue);
 }
 
@@ -224,11 +239,11 @@ function readStored(instance: Record<symbol, unknown>, accessor: PropertyAccesso
 }
 
 function storeValue(instance: Record<symbol, unknown>, accessor: PropertyAccessor, value: unknown): void {
-    instance[accessor.storage] = value;
+    instance[accessor.storage] = heldValue(value);
 }
 
 function writeStored(instance: Record<symbol, unknown>, accessor: PropertyAccessor, value: unknown): void {
-    if (readStored(instance, accessor) === value) {
+    if (readStored(instance, accessor) === heldValue(value)) {
         return;
     }
 
@@ -239,13 +254,12 @@ function writeStored(instance: Record<symbol, unknown>, accessor: PropertyAccess
 function writeProperty(instance: object, accessor: PropertyAccessor, value: unknown): void {
     const stored = instance as Record<symbol, unknown>;
 
-    if (readStored(stored, accessor) === value) {
+    if (readStored(stored, accessor) === heldValue(value)) {
         return;
     }
 
     assertValueAccepted(instance, accessor, value);
-    storeValue(stored, accessor, value);
-    (instance as NotifyingObject).notify?.(accessor.propertyName);
+    writeStored(stored, accessor, accessor.narrowValue(value));
 }
 
 function storedGetter(accessor: PropertyAccessor): (this: object) => unknown {
@@ -431,7 +445,7 @@ function makeGetProperty(dispatch: PropertyDispatch) {
         const accessor = resolveAccessor(dispatch, propertyId, pspec);
         const current = readCurrent(this, accessor);
         assertValueServes(this, accessor, current);
-        intoValue(getHandle(value), current);
+        writeHeld(accessor, getHandle(value), current);
     };
 }
 

package/src/register-class.ts

@@ -61,7 +61,7 @@ type Camelized<TName extends string> = TName extends `${infer THead}-${infer TTa
 
 /**
  * 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.
+ * `RegisterClassOptions.properties` in camelCase, whichever spelling 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.
  */
@@ -129,13 +129,43 @@ type RegisterClassOptions<TInstance extends object, TProperties extends Record<s
      * 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
+     * the ParamSpec rejects. The same 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
+     * what a write means, the other spellings forward to it, and the type's property slots read
      * and write it rather than the generated storage.
      */
     properties?: TProperties;
@@ -166,7 +196,11 @@ type PropertyVfuncSpec = {
     makeDispatch: (dispatch: PropertyDispatch) => VfuncFn;
 };
 
+type ArgPatch = { isCallerAllocated: true } | { isCallScoped: true };
+
+const INSTANCE_ARG_INDEX = 0;
 const VALUE_ARG_INDEX = 2;
+const TEARDOWN_VFUNC_NAMES: Set<string> = new Set(["dispose", "finalize"]);
 
 const PROPERTY_VFUNC_SPECS: PropertyVfuncSpec[] = [
     { methodName: GET_PROPERTY_VFUNC, isValueOut: true, makeDispatch: makeGetProperty },
@@ -345,10 +379,13 @@ function buildDiscoveredVfunc(
         return undefined;
     }
 
+    const argDescriptors = slotArgDescriptors(descriptor);
+
     return {
         ...descriptor,
         methodName,
-        fn: wrapVfunc(fn, descriptor.argDescriptors, descriptor.returnDescriptor),
+        argDescriptors,
+        fn: wrapVfunc(fn, argDescriptors, descriptor),
     };
 }
 
@@ -381,9 +418,13 @@ function discoverClassVfuncs(klass: AnyClass, methods: MethodTable): DiscoveredV
 function wrapVfunc(
     fn: VfuncFn,
     argDescriptors: NativeRegisterClassVfunc["argDescriptors"],
-    returnDescriptor: NativeRegisterClassVfunc["returnDescriptor"],
+    descriptor: VfuncDescriptor,
 ): VfuncFn {
-    return wrapCallback(fn as (...args: unknown[]) => unknown, { argDescriptors, returnDescriptor }, "this");
+    return wrapCallback(
+        fn as (...args: unknown[]) => unknown,
+        { argDescriptors, returnDescriptor: descriptor.returnDescriptor },
+        "vfunc",
+    );
 }
 
 function discoverInterfaceBindings(
@@ -443,9 +484,23 @@ function propertyVfuncs(source: PropertyVfuncSource): DiscoveredVfunc[] {
     );
 }
 
-function markValueCallerAllocated(argDescriptors: Descriptor[]): Descriptor[] {
-    return argDescriptors.map((arg, index) =>
-        index === VALUE_ARG_INDEX ? { ...arg, isCallerAllocated: true } : arg);
+function markArg(argDescriptors: Descriptor[], index: number, patch: ArgPatch): Descriptor[] {
+    return argDescriptors.map((arg, at) => (at === index ? { ...arg, ...patch } : arg));
+}
+
+function isTeardownSlot(descriptor: VfuncDescriptor): boolean {
+    return (
+        TEARDOWN_VFUNC_NAMES.has(descriptor.vfuncName) &&
+        descriptor.argDescriptors[INSTANCE_ARG_INDEX]?.kind === "object"
+    );
+}
+
+function slotArgDescriptors(descriptor: VfuncDescriptor): Descriptor[] {
+    if (!isTeardownSlot(descriptor)) {
+        return descriptor.argDescriptors;
+    }
+
+    return markArg(descriptor.argDescriptors, INSTANCE_ARG_INDEX, { isCallScoped: true });
 }
 
 function buildPropertyVfunc(
@@ -461,14 +516,14 @@ function buildPropertyVfunc(
     }
 
     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),
     };
 }