@gtkx/runtime 1.5.0 → 2.0.0-beta.1

package/src/descriptors.ts

@@ -33,16 +33,25 @@ type FlagsDescriptor = Extract<Descriptor, { kind: "flags" }>;
 type BooleanDescriptor = Extract<Descriptor, { kind: "boolean" }>;
 /** Descriptor variant for a C string. */
 type StringDescriptor = Extract<Descriptor, { kind: "string" }>;
-/** Descriptor variant for a `GObject`. */
-type ObjectDescriptor = Extract<Descriptor, { kind: "object" }>;
+
+/** Descriptor variant for a `GObject`, extended with the statically declared type of its value. */
+type ObjectDescriptor = Extract<Descriptor, { kind: "object" }> & {
+    /** Retains and supplies the declared wrapper when no more-derived wrapper is registered. */
+    fallbackClass?: () => AnyClass;
+};
+
 /** Descriptor variant for a `gunichar`. */
 type UnicharDescriptor = Extract<Descriptor, { kind: "unichar" }>;
 /** Descriptor variant for the absence of a value. */
 type VoidDescriptor = Extract<Descriptor, { kind: "void" }>;
 /** Descriptor variant for an opaque `gpointer`. */
 type BufferDescriptor = Extract<Descriptor, { kind: "buffer" }>;
-/** Descriptor variant for a `GBoxed` value. */
-type BoxedDescriptor = Extract<Descriptor, { kind: "boxed" }>;
+
+/** Descriptor variant for a `GBoxed` value, extended with the statically declared type of its value. */
+type BoxedDescriptor = Extract<Descriptor, { kind: "boxed" }> & {
+    /** Retains and supplies the declared wrapper when none is registered. */
+    fallbackClass?: () => AnyClass;
+};
 
 /** Descriptor variant for a plain C struct, extended with the class its decoded value is wrapped in. */
 type StructDescriptor = Extract<Descriptor, { kind: "struct" }> & {
@@ -54,6 +63,8 @@ type StructDescriptor = Extract<Descriptor, { kind: "struct" }> & {
 type FundamentalDescriptor = Extract<Descriptor, { kind: "fundamental" }> & {
     /** Class a decoded value is wrapped in; without it the wrapper comes from the type named by `typeName`. */
     wrapperClass?: AnyClass;
+    /** Retains and supplies the declared wrapper after checking the runtime-type registry. */
+    fallbackClass?: () => AnyClass;
 };
 
 /** Descriptor variant for an array of items in one of the supported container layouts. */
@@ -87,12 +98,11 @@ type BoxedOptions = {
     freeFnName?: string;
     /** Byte size of the value, needed to copy it into an inline field. */
     size?: number;
+    /** Returns the wrapper class of the declared type, used when none is registered for the GType. */
+    fallbackClass?: () => AnyClass;
 };
 
-/**
- * What the bindings do with a callback's return value, how the callee takes its closure, and how
- * long that closure has to stay alive.
- */
+/** Callback result, closure ownership, and lifetime options. */
 type CallbackOptions = {
     /** The callee also takes a destroy notify, which frees the closure once it is done with it. */
     hasDestroy?: boolean;
@@ -102,10 +112,7 @@ type CallbackOptions = {
     hasUserData?: boolean;
     /** Position of `user_data` among the callback's own arguments, dropped before the closure is called. */
     userDataIndex?: number;
-    /**
-     * The callback's C signature ends with a `GError**`, which receives a `GError` built from
-     * whatever the JavaScript function throws while the callback returns its failure value.
-     */
+    /** Converts a thrown value to the callback's trailing `GError**`. */
     canThrow?: boolean;
     /** Lifetime of the closure; defaults to `notified` when `hasDestroy` is set and `call` otherwise. */
     scope?: CallbackDescriptor["scope"];
@@ -123,12 +130,10 @@ type ArrayOptions = {
     fixedSize?: number | undefined;
     /** Whether the array carries raw bytes, and so decodes to a `Uint8Array` rather than to numbers. */
     isBytes?: boolean | undefined;
-    /**
-     * Whether the caller supplies the storage for a fixed-length out array: the runtime allocates
-     * a buffer of the element stride times the fixed element count, passes its pointer, and
-     * decodes the elements the callee wrote into it.
-     */
+    /** Allocates and decodes caller-owned storage for a fixed-length out array. */
     isCallerAllocated?: boolean | undefined;
+    /** Adds a zero element after the declared length. */
+    isZeroTerminated?: boolean | undefined;
 };
 
 /** Where a cursor array's base buffer and total length come from. */
@@ -147,6 +152,8 @@ type FundamentalOptions = {
     typeName?: string;
     /** Class a decoded value is wrapped in, instead of the one registered for `typeName`. */
     wrapperClass?: AnyClass;
+    /** Returns the wrapper class of the declared type, used when none is registered for the value's type. */
+    fallbackClass?: () => AnyClass;
     /** The caller owns the storage the callee fills, so a decoded value is borrowed instead of acquired. */
     isCallerAllocated?: boolean;
     /** The value is embedded in the containing struct rather than reached through a pointer. */
@@ -169,6 +176,12 @@ type StructOptions = {
     size?: number;
     /** Class a decoded value is wrapped in, instead of the one registered for its GType. */
     wrapperClass?: AnyClass;
+    /** Library the struct's declared copy and free functions are resolved from; without it neither is used. */
+    sharedLibrary?: string;
+    /** Function duplicating an instance, used instead of a byte copy when the struct declares one. */
+    copyFnName?: string;
+    /** Function releasing an instance, used instead of `g_free` when the struct declares one. */
+    freeFnName?: string;
 };
 
 /** Descriptor for a `gint8`, marshalled as a number. */
@@ -210,15 +223,43 @@ const fundamentalLifecycles: Map<string, FundamentalLifecycle> = new Map();
 const isGtypeDescriptor = (descriptor: Descriptor): descriptor is TypeDescriptor =>
     descriptor.kind === "biguint64" && "type" in descriptor;
 
-/**
- * Builds a descriptor for a C string, whose optional length sizes the caller-allocated buffer
- * used when the string is passed by reference.
- */
-const stringT = (ownership: Ownership = "borrowed", length?: number): StringDescriptor =>
-    length === undefined ? { kind: "string", ownership } : { kind: "string", ownership, length };
+/** Builds a C-string descriptor, including optional buffer length and record-owned storage. */
+const stringT = (
+    ownership: Ownership = "borrowed",
+    length?: number,
+    hasOwnedStorage?: boolean,
+): StringDescriptor => {
+    const result: StringDescriptor = { kind: "string", ownership };
+
+    if (length !== undefined) {
+        result.length = length;
+    }
+
+    if (hasOwnedStorage === true) {
+        result.hasOwnedStorage = true;
+    }
+
+    return result;
+};
+
+/** Builds a runtime-typed `GObject` descriptor with an optional retained fallback class. */
+const objectT = (
+    ownership: Ownership = "borrowed",
+    fallbackClass?: () => AnyClass,
+    typeName?: string,
+): ObjectDescriptor => {
+    const result: ObjectDescriptor = { kind: "object", ownership };
+
+    if (fallbackClass !== undefined) {
+        result.fallbackClass = fallbackClass;
+    }
+
+    if (typeName !== undefined) {
+        result.typeName = typeName;
+    }
 
-/** Builds a descriptor for a `GObject`, wrapped in the class registered for its runtime GType. */
-const objectT = (ownership: Ownership = "borrowed"): ObjectDescriptor => ({ kind: "object", ownership });
+    return result;
+};
 
 /** Wraps a descriptor in a pointer to it, for an output or inout argument. */
 const refT = (innerDescriptor: Descriptor, isInout = false): RefDescriptor =>
@@ -236,19 +277,28 @@ const hashTableT = (
     ownership,
 });
 
-/** Builds a descriptor for an enumeration, resolving its GType from the named `get_type` function. */
-const enumT = (sharedLibrary: string, typeFnName: string, isSigned: boolean): EnumDescriptor => ({
-    kind: "enum",
-    sharedLibrary,
-    getTypeFnName: typeFnName,
-    isSigned,
-});
+/** Builds an enum descriptor from a GType function or an explicit set of members. */
+const enumT = (
+    sharedLibrary: string,
+    typeFnName: string,
+    isSigned: boolean,
+    members?: number[],
+): EnumDescriptor => {
+    const result: EnumDescriptor = {
+        kind: "enum",
+        sharedLibrary,
+        getTypeFnName: typeFnName,
+        isSigned,
+    };
 
-/**
- * Builds a descriptor for a flags type, resolving its GType from the named `get_type` function.
- * For flags without a registered GType, pass empty library and function names and supply `mask`,
- * the union of all valid bits, which invalid combinations are rejected against.
- */
+    if (members !== undefined) {
+        result.members = members;
+    }
+
+    return result;
+};
+
+/** Builds a flags descriptor from a GType function or an explicit bit mask. */
 const flagsT = (sharedLibrary: string, typeFnName: string, isSigned: boolean, mask?: number): FlagsDescriptor => {
     const result: FlagsDescriptor = {
         kind: "flags",
@@ -281,6 +331,10 @@ const applyBoxedNames = (result: BoxedDescriptor, options: BoxedOptions): void =
 const applyBoxedOptions = (result: BoxedDescriptor, options: BoxedOptions): void => {
     applyBoxedNames(result, options);
 
+    if (options.fallbackClass !== undefined) {
+        result.fallbackClass = options.fallbackClass;
+    }
+
     if (options.isCallerAllocated) {
         result.isCallerAllocated = true;
     }
@@ -307,6 +361,22 @@ const boxedT = (typeName: string, options: BoxedOptions = {}): BoxedDescriptor =
     return result;
 };
 
+const applyStructLifecycle = (result: StructDescriptor, options: StructOptions): void => {
+    if (options.sharedLibrary === undefined) {
+        return;
+    }
+
+    result.sharedLibrary = options.sharedLibrary;
+
+    if (options.copyFnName !== undefined) {
+        result.copyFnName = options.copyFnName;
+    }
+
+    if (options.freeFnName !== undefined) {
+        result.freeFnName = options.freeFnName;
+    }
+};
+
 /** Builds a descriptor for a plain C struct. */
 const structT = (ownership: Ownership = "borrowed", options: StructOptions = {}): StructDescriptor => {
     const result: StructDescriptor = { kind: "struct", ownership };
@@ -327,6 +397,8 @@ const structT = (ownership: Ownership = "borrowed", options: StructOptions = {})
         result.isInline = true;
     }
 
+    applyStructLifecycle(result, options);
+
     return result;
 };
 
@@ -339,6 +411,16 @@ const recordFundamentalLifecycle = (typeName: string, lifecycle: FundamentalLife
 const fundamentalLifecycleFor = (typeName: string): FundamentalLifecycle | undefined =>
     fundamentalLifecycles.get(typeName);
 
+const applyFundamentalClasses = (result: FundamentalDescriptor, options: FundamentalOptions): void => {
+    if (options.wrapperClass !== undefined) {
+        result.wrapperClass = options.wrapperClass;
+    }
+
+    if (options.fallbackClass !== undefined) {
+        result.fallbackClass = options.fallbackClass;
+    }
+};
+
 /** Builds a descriptor for a fundamental type whose lifetime is managed by named ref and unref functions. */
 const fundamentalT = (
     sharedLibrary: string,
@@ -354,9 +436,7 @@ const fundamentalT = (
         recordFundamentalLifecycle(options.typeName, { sharedLibrary, refFnName, unrefFnName });
     }
 
-    if (options.wrapperClass !== undefined) {
-        result.wrapperClass = options.wrapperClass;
-    }
+    applyFundamentalClasses(result, options);
 
     if (options.isCallerAllocated) {
         result.isCallerAllocated = true;
@@ -410,6 +490,10 @@ const arrayT = (
         result.isCallerAllocated = true;
     }
 
+    if (options.isZeroTerminated === true) {
+        result.isZeroTerminated = true;
+    }
+
     return result;
 };
 
@@ -453,10 +537,7 @@ const sizedArrayT = (
     options: ArrayOptions = {},
 ): ArrayDescriptor => arrayT(itemDescriptor, "sized", ownership, { ...options, sizeParamIndex });
 
-/**
- * Builds a descriptor for an out pointer into the buffer another argument supplied, decoded as the
- * elements from where it points to the end of that buffer.
- */
+/** Builds an out-array cursor into another argument's buffer. */
 const cursorArrayT = (
     itemDescriptor: Descriptor,
     bounds: CursorBounds,
@@ -559,6 +640,7 @@ export {
     cursorArrayT,
     callbackT,
     type BoxedDescriptor,
+    type ObjectDescriptor,
     type StructDescriptor,
     type FundamentalDescriptor,
     type ArrayDescriptor,

package/src/element-metadata.ts

@@ -0,0 +1,24 @@
+type ElementPropertyEntry = [name: string, flags: number, defaultValue?: unknown];
+
+const registeredElementSignals: Record<string, Record<string, string>> = {};
+const registeredElementProperties: Record<string, Record<string, ElementPropertyEntry>> = {};
+const state = { version: 0 };
+
+const registerElementMetadata = (
+    name: string,
+    _parent: string | undefined,
+    ownSignals: Record<string, string>,
+    ownProperties: Record<string, ElementPropertyEntry>,
+): string => {
+    registeredElementSignals[name] = ownSignals;
+    registeredElementProperties[name] = ownProperties;
+    state.version += 1;
+
+    return name;
+};
+
+const elementMetadataVersion = (): number => state.version;
+
+/** @internal */
+export { type ElementPropertyEntry, registerElementMetadata };
+export { elementMetadataVersion, registeredElementProperties, registeredElementSignals };

package/src/fn.ts

@@ -158,12 +158,33 @@ const isPassThroughPlan = (plan: ArgSpec, index: number): boolean =>
     !plan.carriesGtype &&
     plan.arg.type.kind !== "callback";
 
-const requiredInputIndices = (plans: ArgSpec[]): number[] =>
-    plans.filter((plan) => plan.requiresInput && plan.arg.isRequired === true).map((plan) => plan.inputIndex);
+const KINDS_PASSED_AS_POINTER: ReadonlySet<Descriptor["kind"]> = new Set<Descriptor["kind"]>([
+    "array",
+    "boxed",
+    "buffer",
+    "callback",
+    "fundamental",
+    "hashtable",
+    "object",
+    "string",
+    "struct",
+]);
+
+type RequiredInput = {
+    index: number;
+    rejectsNull: boolean;
+};
+
+const requiredInputs = (plans: ArgSpec[]): RequiredInput[] =>
+    plans
+        .filter((plan) => plan.requiresInput && plan.arg.isRequired === true)
+        .map((plan) => ({ index: plan.inputIndex, rejectsNull: KINDS_PASSED_AS_POINTER.has(plan.arg.type.kind) }));
 
-const assertRequiredInputs = (requiredIndices: number[], inputs: unknown[]): void => {
-    for (const index of requiredIndices) {
-        if (inputs[index] === undefined) {
+const assertRequiredInputs = (required: RequiredInput[], inputs: unknown[]): void => {
+    for (const { index, rejectsNull } of required) {
+        const input = inputs[index];
+
+        if (input === undefined || (rejectsNull && input === null)) {
             throw new TypeError(`Missing required argument at position ${String(index + 1)}`);
         }
     }
@@ -193,10 +214,10 @@ const directCallable = (
     plans: ArgSpec[],
 ): ((...inputs: unknown[]) => unknown) => {
     const argCount = plans.length;
-    const requiredIndices = requiredInputIndices(plans);
+    const required = requiredInputs(plans);
 
     const marshal = (inputs: unknown[]): unknown => {
-        assertRequiredInputs(requiredIndices, inputs);
+        assertRequiredInputs(required, inputs);
 
         return readReturn(call(descriptor, resizeInputs(inputs, argCount)));
     };
@@ -226,14 +247,14 @@ function fromNativeCallable(
         return directCallable(descriptor, readReturn, hasPrimary, plans);
     }
 
-    const requiredIndices = requiredInputIndices(plans);
+    const required = requiredInputs(plans);
 
     const shape = (inputs: unknown[], nativeValues: unknown[], nativeResult: unknown): unknown =>
         packTupleResult(readOutParams(outPlans, inputs, nativeValues), readReturn(nativeResult), hasPrimary);
 
     if (canThrow) {
         return (...inputs) => {
-            assertRequiredInputs(requiredIndices, inputs);
+            assertRequiredInputs(required, inputs);
             const nativeValues = buildNativeValues(plans, inputs, getRefSeeds?.());
             const errorRef: Ref = { value: null };
             nativeValues.push(errorRef);
@@ -245,26 +266,54 @@ function fromNativeCallable(
     }
 
     return (...inputs) => {
-        assertRequiredInputs(requiredIndices, inputs);
+        assertRequiredInputs(required, inputs);
         const nativeValues = buildNativeValues(plans, inputs, getRefSeeds?.());
 
         return shape(inputs, nativeValues, call(descriptor, nativeValues));
     };
 }
 
+const bindNativeCallable = (
+    sharedLibrary: string,
+    symbol: string,
+    spec: FnSpec,
+): ((...inputs: unknown[]) => unknown) => {
+    const nativeArgTypes = buildNativeArgTypes(spec.args, spec.canThrow ?? false);
+    const descriptor = nativeBind(sharedLibrary, symbol, nativeArgTypes, spec.returns, spec.fixedArgCount);
+
+    return fromNativeCallable(descriptor, spec);
+};
+
 /**
  * Binds a symbol in a shared library to a callable that marshals its inputs and packs output
  * arguments into the result. When the spec sets `canThrow`, the reported `GError` is thrown.
  *
+ * A plain spec is bound when `fn` is called, so a malformed descriptor throws at binding time.
+ * Passing a function returning the spec instead defers building the descriptors and the binding
+ * to the first call, so describing such a binding costs nothing until something calls it and a
+ * module full of them loads without touching the shared library.
+ *
  * @param sharedLibrary Shared library the symbol is looked up in.
  * @param symbol Name of the C symbol to bind.
- * @param spec Argument and return descriptors the call is marshalled through.
+ * @param spec Argument and return descriptors the call is marshalled through, or a function
+ * returning them, which defers building the descriptors and the binding to the first call.
  */
-function fn(sharedLibrary: string, symbol: string, spec: FnSpec): (...inputs: unknown[]) => unknown {
-    const nativeArgTypes = buildNativeArgTypes(spec.args, spec.canThrow ?? false);
-    const descriptor = nativeBind(sharedLibrary, symbol, nativeArgTypes, spec.returns, spec.fixedArgCount);
+function fn(
+    sharedLibrary: string,
+    symbol: string,
+    spec: FnSpec | (() => FnSpec),
+): (...inputs: unknown[]) => unknown {
+    if (typeof spec !== "function") {
+        return bindNativeCallable(sharedLibrary, symbol, spec);
+    }
 
-    return fromNativeCallable(descriptor, spec);
+    let bound: ((...inputs: unknown[]) => unknown) | undefined;
+
+    return (...inputs) => {
+        bound ??= bindNativeCallable(sharedLibrary, symbol, spec());
+
+        return bound(...inputs);
+    };
 }
 
 export { buildNativeArgTypes, fn, fromNativeCallable };

package/src/folded-lengths.ts

@@ -28,15 +28,7 @@ const addLengthSource = (sources: LengthSources, index: number | undefined, sour
         return;
     }
 
-    const existing = sources.get(index);
-
-    if (existing === undefined) {
-        sources.set(index, [source]);
-
-        return;
-    }
-
-    existing.push(source);
+    sources.getOrInsertComputed(index, () => []).push(source);
 };
 
 const addOutArgLengthSources = (sources: LengthSources, spec: FoldedLengthSpec): void => {
@@ -52,6 +44,27 @@ const addOutArgLengthSources = (sources: LengthSources, spec: FoldedLengthSpec):
     }
 };
 
+const foldedLengthArgIndices = (spec: FoldedLengthSpec): ReadonlySet<number> => {
+    const indices: Set<number> = new Set();
+
+    const add = (declaredIndex: number | undefined): void => {
+        const argIndex = effectiveArgIndex(declaredIndex, spec.userDataIndex);
+
+        if (argIndex !== undefined) {
+            indices.add(argIndex);
+        }
+    };
+
+    add(sizedArrayLengthIndex(spec.returnDescriptor));
+
+    for (const descriptor of spec.argDescriptors) {
+        add(sizedArrayLengthIndex(descriptor));
+        add(outArgLengthIndex(descriptor));
+    }
+
+    return indices;
+};
+
 const foldedLengthSources = (spec: FoldedLengthSpec): LengthSources => {
     const sources: LengthSources = new Map();
     const returnLengthIndex = effectiveArgIndex(sizedArrayLengthIndex(spec.returnDescriptor), spec.userDataIndex);
@@ -61,4 +74,4 @@ const foldedLengthSources = (spec: FoldedLengthSpec): LengthSources => {
     return sources;
 };
 
-export { foldedLengthSources, type LengthSource, type LengthSources };
+export { foldedLengthArgIndices, foldedLengthSources, type LengthSource, type LengthSources };

package/src/index.ts

@@ -1,22 +1,14 @@
 import "./exit-hook.js";
 
-/** @public */
 export { type ApplicationClass, type CommandLineApplication, createApplication } from "./application-class.js";
-/** @public */
+export { CallbackMarshalError } from "./callback.js";
 export { type ClosureCallback, ClosureMarshalError, toClosure, tryToClosure } from "./closure.js";
-/** @public */
 export { createErrorDomain, type ErrorDomain } from "./error.js";
-/** @public */
 export { type Field, type StridedField } from "./field.js";
-/** @public */
 export { onExit, quit, quitApplication, runApplication, type RunApplicationResult } from "./lifecycle.js";
-/** @public */
 export { offSignal, onceSignal, onSignal } from "./listeners.js";
-/** @public */
 export { installMixins, type Mixin } from "./mixin.js";
-/** @public */
-export { fromNative, toNative } from "./native-value.js";
-/** @public */
+export { fromNative, toHashTableEntries, toNative } from "./native-value.js";
 export {
     type ConstructBinding,
     type ConstructBindings,
@@ -25,27 +17,22 @@ export {
     registerConstructProperties,
     setObjectProperty,
 } from "./object.js";
-/** @public */
 export { getParamSpecFlags, getParamSpecOwnerType, getParamSpecValueType } from "./param-spec.js";
-/** @public */
 export { promisify, trimFinish } from "./promisify.js";
-/** @public */
 export {
     coerceObjectProperty,
     getDeclaredPropertyName,
     isReadableProperty,
     newParamSpecOverride,
 } from "./properties.js";
-/** @public */
 export { matchAllRegex, matchRegex } from "./regex.js";
-/** @public */
 export { type Interface, registerClass, type SignalGType, type SignalSpec } from "./register-class.js";
-/** @public */
 export {
     getClassType,
     getHandle,
     getInstanceType,
     getWrapperClass,
+    installInterfaces,
     peekTypeClass,
     registerClassStruct,
     registerInterface,
@@ -54,9 +41,9 @@ export {
     type StaticBase,
     setHandle,
     wrapHandle,
+    type WrapperClass,
     type WrapperClassResolver,
 } from "./registry.js";
-/** @public */
 export {
     connectSignal,
     disconnectSignal,
@@ -65,9 +52,7 @@ export {
     type SignalHandler,
     signalForHandlerName,
 } from "./signal.js";
-/** @public */
 export { t } from "./t.js";
-/** @public */
 export {
     resolveType,
     TYPE_BOOLEAN,
@@ -95,6 +80,7 @@ export {
     TYPE_UNICHAR,
     TYPE_VARIANT,
     type TypedClass,
+    retainWrapperClasses,
     typeFromName,
     typeInterfaces,
     typeIsA,
@@ -102,7 +88,6 @@ export {
     typeParent,
     valueIsA,
 } from "./type.js";
-/** @public */
 export {
     fromValue,
     getBoxedValue,
@@ -112,7 +97,6 @@ export {
     tryToValueHandle,
     ValueMarshalError,
 } from "./value.js";
-/** @public */
 export {
     type ByteArray,
     type FromVariantOptions,
@@ -123,9 +107,6 @@ export {
     type VariantInput,
     type VariantValue,
 } from "./variant.js";
-/** @public */
 export { callParent, callVfunc } from "./vfunc-call.js";
-/** @public */
 export { alloc, type ExternalObject, type Handle, read, write } from "@gtkx/native";
-/** @public */
 export { type AnyClass } from "@gtkx/utils";

package/src/internal.ts

@@ -1,6 +1,13 @@
-export { checkError, createErrorDomain } from "./error.js";
+/** @internal */
+export { registerElementMetadata } from "./element-metadata.js";
+export {
+    elementMetadataVersion,
+    registeredElementProperties,
+    registeredElementSignals,
+} from "./element-metadata.js";
+export { createErrorDomain } from "./error.js";
 export { type ApplicationInstance, getApplicationInstance } from "./lifecycle.js";
-export { registerClassType, resolveWrapperClass, wrapHandle } from "./registry.js";
+export { getExactWrapperClass, resolveWrapperClass } from "./registry.js";
 export { hasSignalListener } from "./signal.js";
 export { resolveType } from "./type.js";
 export {