@gtkx/runtime 1.0.0-rc.1 → 1.0.0-rc.2

package/src/callback.ts

@@ -1,5 +1,5 @@
 import { copy, type Descriptor } from "@gtkx/native";
-import type { CallbackDescriptor } from "./descriptors.js";
+import type { CallbackDescriptor, RefDescriptor } from "./descriptors.js";
 import { fromNative, toNative } from "./native-value.js";
 import { getHandle } from "./registry.js";
 import { splitTupleResult } from "./tuple.js";
@@ -15,18 +15,65 @@ type CallbackSpec = {
     userDataIndex?: number;
 };
 
+type CallbackPlan = {
+    fn: Callback;
+    effectiveTypes: Descriptor[];
+    returnDescriptor: Descriptor;
+    start: number;
+    receiver: CallbackReceiver;
+};
+
 const fillCallerAllocatedBuffer = (descriptor: Descriptor, target: object, source: object): void => {
     if (descriptor.kind === "boxed" && descriptor.typeName === "GValue") {
         copyValue(getHandle(target), getHandle(source));
+
         return;
     }
+
     if ((descriptor.kind === "boxed" || descriptor.kind === "struct") && descriptor.size !== undefined) {
         copy(getHandle(target), getHandle(source), descriptor.size);
+
         return;
     }
+
     throw new Error(`Cannot write caller-allocated ${descriptor.kind} out-parameter: no known byte size`);
 };
 
+const isCallerAllocatedOut = (descriptor: Descriptor): boolean =>
+    (descriptor.kind === "boxed" || descriptor.kind === "struct") && descriptor.callerAllocated === true;
+
+const collectRefArg = (
+    descriptor: RefDescriptor,
+    wrappedValue: unknown,
+    inputs: unknown[],
+    outParams: OutParam[],
+): void => {
+    if (descriptor.inout === true) {
+        inputs.push((wrappedValue as { value: unknown }).value);
+    }
+
+    outParams.push({ value: wrappedValue, descriptor });
+};
+
+const collectCallbackArg = (
+    descriptor: Descriptor | undefined,
+    wrappedValue: unknown,
+    inputs: unknown[],
+    outParams: OutParam[],
+): void => {
+    if (descriptor?.kind === "ref") {
+        collectRefArg(descriptor, wrappedValue, inputs, outParams);
+
+        return;
+    }
+
+    inputs.push(wrappedValue);
+
+    if (descriptor !== undefined && isCallerAllocatedOut(descriptor)) {
+        outParams.push({ value: wrappedValue, descriptor });
+    }
+};
+
 const partitionCallbackArgs = (
     effectiveTypes: Descriptor[],
     wrapped: unknown[],
@@ -34,54 +81,69 @@ const partitionCallbackArgs = (
 ): { inputs: unknown[]; outParams: OutParam[] } => {
     const inputs: unknown[] = [];
     const outParams: OutParam[] = [];
+
     for (let i = start; i < effectiveTypes.length; i++) {
-        const descriptor = effectiveTypes[i];
-        if (descriptor !== undefined && descriptor.kind === "ref") {
-            if (descriptor.inout === true) inputs.push((wrapped[i] as { value: unknown }).value);
-            outParams.push({ value: wrapped[i], descriptor });
-        } else if (
-            descriptor !== undefined &&
-            (descriptor.kind === "boxed" || descriptor.kind === "struct") &&
-            descriptor.callerAllocated === true
-        ) {
-            inputs.push(wrapped[i]);
-            outParams.push({ value: wrapped[i], descriptor });
-        } else {
-            inputs.push(wrapped[i]);
-        }
+        collectCallbackArg(effectiveTypes[i], wrapped[i], inputs, outParams);
     }
+
     return { inputs, outParams };
 };
 
 const writeOutParams = (outParams: OutParam[], outValues: unknown[]): void => {
-    outParams.forEach((outParam, position) => {
+    for (const [position, outParam] of outParams.entries()) {
         const outValue = outValues[position];
+
         if (outParam.descriptor.kind === "ref") {
             (outParam.value as { value: unknown }).value = outValue;
         } else if (outValue != null && outParam.value != null) {
-            fillCallerAllocatedBuffer(outParam.descriptor, outParam.value as object, outValue as object);
+            fillCallerAllocatedBuffer(outParam.descriptor, outParam.value, outValue);
         }
-    });
+    }
+};
+
+const getThisArg = (receiver: CallbackReceiver, wrapped: unknown[]): unknown =>
+    receiver === "this" ? (wrapped[0] ?? null) : null;
+
+const runCallback = (plan: CallbackPlan, rawArgs: unknown[]): unknown => {
+    const { effectiveTypes, returnDescriptor } = plan;
+    const wrapped = effectiveTypes.map((descriptor, i) => fromNative(descriptor, rawArgs[i]));
+    const thisArg = getThisArg(plan.receiver, wrapped);
+    const { inputs, outParams } = partitionCallbackArgs(effectiveTypes, wrapped, plan.start);
+    const result = plan.fn.apply(thisArg, inputs);
+
+    if (outParams.length === 0) {
+        return toNative(returnDescriptor, result);
+    }
+
+    const { primary, outValues } = splitTupleResult(result, returnDescriptor.kind !== "void", outParams.length);
+    writeOutParams(outParams, outValues);
+
+    return toNative(returnDescriptor, primary);
+};
+
+const getEffectiveTypes = (spec: CallbackSpec): Descriptor[] => {
+    const { userDataIndex } = spec;
+
+    if (userDataIndex === undefined) {
+        return spec.argDescriptors;
+    }
+
+    return spec.argDescriptors.filter((_, i) => i !== userDataIndex);
 };
 
-export const wrapCallbackValue = (spec: CallbackDescriptor, callback: unknown): unknown =>
+const wrapCallbackValue = (spec: CallbackDescriptor, callback: unknown): unknown =>
     callback == null ? callback : wrapCallback(callback as Callback, spec, "none");
 
-export function wrapCallback(fn: Callback, spec: CallbackSpec, receiver: CallbackReceiver): Callback {
-    const { returnDescriptor, userDataIndex } = spec;
-    const effectiveTypes =
-        userDataIndex === undefined ? spec.argDescriptors : spec.argDescriptors.filter((_, i) => i !== userDataIndex);
-    const start = receiver === "none" ? 0 : 1;
-    return (...rawArgs: unknown[]): unknown => {
-        const wrapped = effectiveTypes.map((descriptor, i) => fromNative(descriptor, rawArgs[i]));
-        const thisArg = receiver === "this" ? (wrapped[0] ?? null) : null;
-        const { inputs, outParams } = partitionCallbackArgs(effectiveTypes, wrapped, start);
-        const result = (fn as (this: unknown, ...args: unknown[]) => unknown).apply(thisArg, inputs);
-        if (outParams.length === 0) {
-            return toNative(returnDescriptor, result);
-        }
-        const { primary, outValues } = splitTupleResult(result, returnDescriptor.kind !== "void", outParams.length);
-        writeOutParams(outParams, outValues);
-        return toNative(returnDescriptor, primary);
+function wrapCallback(fn: Callback, spec: CallbackSpec, receiver: CallbackReceiver): Callback {
+    const plan: CallbackPlan = {
+        fn,
+        effectiveTypes: getEffectiveTypes(spec),
+        returnDescriptor: spec.returnDescriptor,
+        start: receiver === "none" ? 0 : 1,
+        receiver,
     };
+
+    return (...rawArgs: unknown[]): unknown => runCallback(plan, rawArgs);
 }
+
+export { wrapCallbackValue, wrapCallback };

package/src/descriptors.ts

@@ -1,37 +1,38 @@
 import type { ArrayKind, Descriptor, Ownership } from "@gtkx/native";
 import type { AnyClass } from "@gtkx/utils";
 
-export type Int8Descriptor = Extract<Descriptor, { kind: "int8" }>;
-export type Uint8Descriptor = Extract<Descriptor, { kind: "uint8" }>;
-export type Int16Descriptor = Extract<Descriptor, { kind: "int16" }>;
-export type Uint16Descriptor = Extract<Descriptor, { kind: "uint16" }>;
-export type Int32Descriptor = Extract<Descriptor, { kind: "int32" }>;
-export type Uint32Descriptor = Extract<Descriptor, { kind: "uint32" }>;
-export type Int64Descriptor = Extract<Descriptor, { kind: "int64" }>;
-export type Uint64Descriptor = Extract<Descriptor, { kind: "uint64" }>;
-export type BigInt64Descriptor = Extract<Descriptor, { kind: "bigint64" }>;
-export type BigUint64Descriptor = Extract<Descriptor, { kind: "biguint64" }>;
-export type Float32Descriptor = Extract<Descriptor, { kind: "float32" }>;
-export type Float64Descriptor = Extract<Descriptor, { kind: "float64" }>;
-export type EnumDescriptor = Extract<Descriptor, { kind: "enum" }>;
-export type FlagsDescriptor = Extract<Descriptor, { kind: "flags" }>;
-export type BooleanDescriptor = Extract<Descriptor, { kind: "boolean" }>;
-export type StringDescriptor = Extract<Descriptor, { kind: "string" }>;
-export type ObjectDescriptor = Extract<Descriptor, { kind: "object" }>;
-export type UnicharDescriptor = Extract<Descriptor, { kind: "unichar" }>;
-export type VoidDescriptor = Extract<Descriptor, { kind: "void" }>;
-export type BufferDescriptor = Extract<Descriptor, { kind: "buffer" }>;
-export type BoxedDescriptor = Extract<Descriptor, { kind: "boxed" }>;
-export type StructDescriptor = Extract<Descriptor, { kind: "struct" }> & { wrapperClass?: AnyClass };
-export type FundamentalDescriptor = Extract<Descriptor, { kind: "fundamental" }> & { wrapperClass?: AnyClass };
-export type ArrayDescriptor = Extract<Descriptor, { kind: "array" }>;
-export type HashTableDescriptor = Extract<Descriptor, { kind: "hashtable" }>;
-export type CallbackDescriptor = Extract<Descriptor, { kind: "callback" }>;
-export type RefDescriptor = Extract<Descriptor, { kind: "ref" }>;
-export type TypeDescriptor = BigUint64Descriptor & { type: true };
+type Int8Descriptor = Extract<Descriptor, { kind: "int8" }>;
+type Uint8Descriptor = Extract<Descriptor, { kind: "uint8" }>;
+type Int16Descriptor = Extract<Descriptor, { kind: "int16" }>;
+type Uint16Descriptor = Extract<Descriptor, { kind: "uint16" }>;
+type Int32Descriptor = Extract<Descriptor, { kind: "int32" }>;
+type Uint32Descriptor = Extract<Descriptor, { kind: "uint32" }>;
+type Int64Descriptor = Extract<Descriptor, { kind: "int64" }>;
+type Uint64Descriptor = Extract<Descriptor, { kind: "uint64" }>;
+type BigInt64Descriptor = Extract<Descriptor, { kind: "bigint64" }>;
+type BigUint64Descriptor = Extract<Descriptor, { kind: "biguint64" }>;
+type Float32Descriptor = Extract<Descriptor, { kind: "float32" }>;
+type Float64Descriptor = Extract<Descriptor, { kind: "float64" }>;
+type EnumDescriptor = Extract<Descriptor, { kind: "enum" }>;
+type FlagsDescriptor = Extract<Descriptor, { kind: "flags" }>;
+type BooleanDescriptor = Extract<Descriptor, { kind: "boolean" }>;
+type StringDescriptor = Extract<Descriptor, { kind: "string" }>;
+type ObjectDescriptor = Extract<Descriptor, { kind: "object" }>;
+type UnicharDescriptor = Extract<Descriptor, { kind: "unichar" }>;
+type VoidDescriptor = Extract<Descriptor, { kind: "void" }>;
+type BufferDescriptor = Extract<Descriptor, { kind: "buffer" }>;
+type BoxedDescriptor = Extract<Descriptor, { kind: "boxed" }>;
+type StructDescriptor = Extract<Descriptor, { kind: "struct" }> & { wrapperClass?: AnyClass };
+type FundamentalDescriptor = Extract<Descriptor, { kind: "fundamental" }> & { wrapperClass?: AnyClass };
+type ArrayDescriptor = Extract<Descriptor, { kind: "array" }>;
+type HashTableDescriptor = Extract<Descriptor, { kind: "hashtable" }>;
+type CallbackDescriptor = Extract<Descriptor, { kind: "callback" }>;
+type RefDescriptor = Extract<Descriptor, { kind: "ref" }>;
+type TypeDescriptor = BigUint64Descriptor & { type: true };
 
 type BoxedOptions = {
     callerAllocated?: boolean;
+    inline?: boolean;
     ownership?: Ownership;
     sharedLibrary?: string;
     getTypeFnName?: string;
@@ -55,41 +56,43 @@ type FundamentalOptions = {
     ownership?: Ownership;
     typeName?: string;
     wrapperClass?: AnyClass;
+    inline?: boolean;
 };
 
 type StructOptions = {
     callerAllocated?: boolean;
+    inline?: boolean;
     size?: number;
     wrapperClass?: AnyClass;
 };
 
-export const int8T: Int8Descriptor = { kind: "int8" };
-export const uint8T: Uint8Descriptor = { kind: "uint8" };
-export const int16T: Int16Descriptor = { kind: "int16" };
-export const uint16T: Uint16Descriptor = { kind: "uint16" };
-export const int32T: Int32Descriptor = { kind: "int32" };
-export const uint32T: Uint32Descriptor = { kind: "uint32" };
-export const int64T: Int64Descriptor = { kind: "int64" };
-export const uint64T: Uint64Descriptor = { kind: "uint64" };
-export const bigint64T: BigInt64Descriptor = { kind: "bigint64" };
-export const biguint64T: BigUint64Descriptor = { kind: "biguint64" };
-export const gtypeT: TypeDescriptor = { kind: "biguint64", type: true };
-export const float32T: Float32Descriptor = { kind: "float32" };
-export const float64T: Float64Descriptor = { kind: "float64" };
-export const booleanT: BooleanDescriptor = { kind: "boolean" };
-export const voidT: VoidDescriptor = { kind: "void" };
-export const unicharT: UnicharDescriptor = { kind: "unichar" };
-export const bufferT: BufferDescriptor = { kind: "buffer" };
-
-export const stringT = (ownership: Ownership = "borrowed", length?: number): StringDescriptor =>
+const int8T: Int8Descriptor = { kind: "int8" };
+const uint8T: Uint8Descriptor = { kind: "uint8" };
+const int16T: Int16Descriptor = { kind: "int16" };
+const uint16T: Uint16Descriptor = { kind: "uint16" };
+const int32T: Int32Descriptor = { kind: "int32" };
+const uint32T: Uint32Descriptor = { kind: "uint32" };
+const int64T: Int64Descriptor = { kind: "int64" };
+const uint64T: Uint64Descriptor = { kind: "uint64" };
+const bigint64T: BigInt64Descriptor = { kind: "bigint64" };
+const biguint64T: BigUint64Descriptor = { kind: "biguint64" };
+const gtypeT: TypeDescriptor = { kind: "biguint64", type: true };
+const float32T: Float32Descriptor = { kind: "float32" };
+const float64T: Float64Descriptor = { kind: "float64" };
+const booleanT: BooleanDescriptor = { kind: "boolean" };
+const voidT: VoidDescriptor = { kind: "void" };
+const unicharT: UnicharDescriptor = { kind: "unichar" };
+const bufferT: BufferDescriptor = { kind: "buffer" };
+
+const stringT = (ownership: Ownership = "borrowed", length?: number): StringDescriptor =>
     length === undefined ? { kind: "string", ownership } : { kind: "string", ownership, length };
 
-export const objectT = (ownership: Ownership = "borrowed"): ObjectDescriptor => ({ kind: "object", ownership });
+const objectT = (ownership: Ownership = "borrowed"): ObjectDescriptor => ({ kind: "object", ownership });
 
-export const refT = (innerDescriptor: Descriptor, inout = false): RefDescriptor =>
-    inout ? { kind: "ref", innerDescriptor, inout: true } : { kind: "ref", innerDescriptor };
+const refT = (innerDescriptor: Descriptor, isInout = false): RefDescriptor =>
+    isInout ? { kind: "ref", innerDescriptor, inout: true } : { kind: "ref", innerDescriptor };
 
-export const hashTableT = (
+const hashTableT = (
     keyDescriptor: Descriptor,
     valueDescriptor: Descriptor,
     ownership: Ownership = "borrowed",
@@ -100,43 +103,85 @@ export const hashTableT = (
     ownership,
 });
 
-export const enumT = (sharedLibrary: string, getTypeFnName: string, signed: boolean): EnumDescriptor => ({
+const enumT = (sharedLibrary: string, typeFnName: string, isSigned: boolean): EnumDescriptor => ({
     kind: "enum",
     sharedLibrary,
-    getTypeFnName,
-    signed,
+    getTypeFnName: typeFnName,
+    signed: isSigned,
 });
 
-export const flagsT = (sharedLibrary: string, getTypeFnName: string, signed: boolean): FlagsDescriptor => ({
+const flagsT = (sharedLibrary: string, typeFnName: string, isSigned: boolean): FlagsDescriptor => ({
     kind: "flags",
     sharedLibrary,
-    getTypeFnName,
-    signed,
+    getTypeFnName: typeFnName,
+    signed: isSigned,
 });
 
-export const boxedT = (typeName: string, options: BoxedOptions = {}): BoxedDescriptor => {
+const applyBoxedNames = (result: BoxedDescriptor, options: BoxedOptions): void => {
+    if (options.sharedLibrary !== undefined) {
+        result.sharedLibrary = options.sharedLibrary;
+    }
+
+    if (options.getTypeFnName !== undefined) {
+        result.getTypeFnName = options.getTypeFnName;
+    }
+
+    if (options.freeFnName !== undefined) {
+        result.freeFnName = options.freeFnName;
+    }
+};
+
+const applyBoxedOptions = (result: BoxedDescriptor, options: BoxedOptions): void => {
+    applyBoxedNames(result, options);
+
+    if (options.callerAllocated) {
+        result.callerAllocated = true;
+    }
+
+    if (options.inline) {
+        result.inline = true;
+    }
+
+    if (options.size !== undefined) {
+        result.size = options.size;
+    }
+};
+
+const boxedT = (typeName: string, options: BoxedOptions = {}): BoxedDescriptor => {
     const result: BoxedDescriptor = {
         kind: "boxed",
         ownership: options.ownership ?? "borrowed",
         typeName,
     };
-    if (options.sharedLibrary !== undefined) result.sharedLibrary = options.sharedLibrary;
-    if (options.getTypeFnName !== undefined) result.getTypeFnName = options.getTypeFnName;
-    if (options.freeFnName !== undefined) result.freeFnName = options.freeFnName;
-    if (options.callerAllocated) result.callerAllocated = true;
-    if (options.size !== undefined) result.size = options.size;
+
+    applyBoxedOptions(result, options);
+
     return result;
 };
 
-export const structT = (ownership: Ownership = "borrowed", options: StructOptions = {}): StructDescriptor => {
+const structT = (ownership: Ownership = "borrowed", options: StructOptions = {}): StructDescriptor => {
     const result: StructDescriptor = { kind: "struct", ownership };
-    if (options.size !== undefined) result.size = options.size;
-    if (options.wrapperClass !== undefined) result.wrapperClass = options.wrapperClass;
-    if (options.callerAllocated) result.callerAllocated = true;
+
+    if (options.size !== undefined) {
+        result.size = options.size;
+    }
+
+    if (options.wrapperClass !== undefined) {
+        result.wrapperClass = options.wrapperClass;
+    }
+
+    if (options.callerAllocated) {
+        result.callerAllocated = true;
+    }
+
+    if (options.inline) {
+        result.inline = true;
+    }
+
     return result;
 };
 
-export const fundamentalT = (
+const fundamentalT = (
     sharedLibrary: string,
     refFnName: string,
     unrefFnName: string,
@@ -144,65 +189,162 @@ export const fundamentalT = (
 ): FundamentalDescriptor => {
     const ownership = options.ownership ?? "borrowed";
     const result: FundamentalDescriptor = { kind: "fundamental", ownership, sharedLibrary, refFnName, unrefFnName };
-    if (options.typeName !== undefined) result.typeName = options.typeName;
-    if (options.wrapperClass !== undefined) result.wrapperClass = options.wrapperClass;
+
+    if (options.typeName !== undefined) {
+        result.typeName = options.typeName;
+    }
+
+    if (options.wrapperClass !== undefined) {
+        result.wrapperClass = options.wrapperClass;
+    }
+
+    if (options.inline) {
+        result.inline = true;
+    }
+
     return result;
 };
 
-export const arrayT = (
+const arrayT = (
     itemDescriptor: Descriptor,
     arrayKind: ArrayKind = "array",
     ownership: Ownership = "borrowed",
     options?: ArrayOptions,
 ): ArrayDescriptor => {
     const result: ArrayDescriptor = { kind: "array", itemDescriptor, arrayKind, ownership };
-    if (options?.elementSize !== undefined) result.elementSize = options.elementSize;
-    if (options?.sizeParamIndex !== undefined) result.sizeParamIndex = options.sizeParamIndex;
-    if (options?.fixedSize !== undefined) result.fixedSize = options.fixedSize;
+
+    if (options?.elementSize !== undefined) {
+        result.elementSize = options.elementSize;
+    }
+
+    if (options?.sizeParamIndex !== undefined) {
+        result.sizeParamIndex = options.sizeParamIndex;
+    }
+
+    if (options?.fixedSize !== undefined) {
+        result.fixedSize = options.fixedSize;
+    }
+
     return result;
 };
 
-export const listT = (itemDescriptor: Descriptor, ownership: Ownership = "borrowed"): ArrayDescriptor =>
+const listT = (itemDescriptor: Descriptor, ownership: Ownership = "borrowed"): ArrayDescriptor =>
     arrayT(itemDescriptor, "glist", ownership);
 
-export const slistT = (itemDescriptor: Descriptor, ownership: Ownership = "borrowed"): ArrayDescriptor =>
+const slistT = (itemDescriptor: Descriptor, ownership: Ownership = "borrowed"): ArrayDescriptor =>
     arrayT(itemDescriptor, "gslist", ownership);
 
-export const ptrArrayT = (itemDescriptor: Descriptor, ownership: Ownership = "borrowed"): ArrayDescriptor =>
+const ptrArrayT = (itemDescriptor: Descriptor, ownership: Ownership = "borrowed"): ArrayDescriptor =>
     arrayT(itemDescriptor, "gptrarray", ownership);
 
-export const gArrayT = (
+const gArrayT = (
     itemDescriptor: Descriptor,
     ownership: Ownership = "borrowed",
     elementSize?: number,
 ): ArrayDescriptor =>
     arrayT(itemDescriptor, "garray", ownership, elementSize === undefined ? undefined : { elementSize });
 
-export const byteArrayT = (ownership: Ownership = "borrowed"): ArrayDescriptor =>
+const byteArrayT = (ownership: Ownership = "borrowed"): ArrayDescriptor =>
     arrayT(uint8T, "gbytearray", ownership);
 
-export const sizedArrayT = (
+const sizedArrayT = (
     itemDescriptor: Descriptor,
     sizeParamIndex: number,
     ownership: Ownership = "borrowed",
     elementSize?: number,
 ): ArrayDescriptor => arrayT(itemDescriptor, "sized", ownership, { sizeParamIndex, elementSize });
 
-export const fixedArrayT = (
+const fixedArrayT = (
     itemDescriptor: Descriptor,
     fixedSize: number,
     ownership: Ownership = "borrowed",
     elementSize?: number,
 ): ArrayDescriptor => arrayT(itemDescriptor, "fixed", ownership, { fixedSize, elementSize });
 
-export const callbackT = (
+const callbackT = (
     argDescriptors: Descriptor[],
     returnDescriptor: Descriptor,
     options?: CallbackOptions,
 ): CallbackDescriptor => {
     const result: CallbackDescriptor = { kind: "callback", argDescriptors, returnDescriptor };
-    if (options?.hasDestroy !== undefined) result.hasDestroy = options.hasDestroy;
-    if (options?.userDataIndex !== undefined) result.userDataIndex = options.userDataIndex;
-    if (options?.scope !== undefined) result.scope = options.scope;
+
+    if (options?.hasDestroy !== undefined) {
+        result.hasDestroy = options.hasDestroy;
+    }
+
+    if (options?.userDataIndex !== undefined) {
+        result.userDataIndex = options.userDataIndex;
+    }
+
+    if (options?.scope !== undefined) {
+        result.scope = options.scope;
+    }
+
     return result;
 };
+
+export {
+    int8T,
+    uint8T,
+    int16T,
+    uint16T,
+    int32T,
+    uint32T,
+    int64T,
+    uint64T,
+    bigint64T,
+    biguint64T,
+    gtypeT,
+    float32T,
+    float64T,
+    booleanT,
+    voidT,
+    unicharT,
+    bufferT,
+    stringT,
+    objectT,
+    refT,
+    hashTableT,
+    enumT,
+    flagsT,
+    boxedT,
+    structT,
+    fundamentalT,
+    arrayT,
+    listT,
+    slistT,
+    ptrArrayT,
+    gArrayT,
+    byteArrayT,
+    sizedArrayT,
+    fixedArrayT,
+    callbackT,
+    type Int8Descriptor,
+    type Uint8Descriptor,
+    type Int16Descriptor,
+    type Uint16Descriptor,
+    type Int32Descriptor,
+    type Uint32Descriptor,
+    type Int64Descriptor,
+    type Uint64Descriptor,
+    type BigInt64Descriptor,
+    type BigUint64Descriptor,
+    type Float32Descriptor,
+    type Float64Descriptor,
+    type EnumDescriptor,
+    type FlagsDescriptor,
+    type BooleanDescriptor,
+    type StringDescriptor,
+    type ObjectDescriptor,
+    type UnicharDescriptor,
+    type VoidDescriptor,
+    type BufferDescriptor,
+    type BoxedDescriptor,
+    type StructDescriptor,
+    type FundamentalDescriptor,
+    type ArrayDescriptor,
+    type HashTableDescriptor,
+    type CallbackDescriptor,
+    type RefDescriptor,
+    type TypeDescriptor,
+};

package/src/error.ts

@@ -2,26 +2,29 @@ import type { ExternalObject, Handle, Ref } from "@gtkx/native";
 import { getWrapperClass, wrapHandle } from "./registry.js";
 import { getErrorType, isTypedClass } from "./type.js";
 
-type ErrorLike = {
+type ErrorLike = Error & {
     domain: number;
     code: number;
-    message: string;
 };
 
 /**
  * An error enum object carrying its member codes plus an `instanceof` check that
  * matches wrapped GLib errors belonging to a specific error domain.
  */
-export type ErrorDomain<T extends Record<string, number>> = T & {
+type ErrorDomain<T extends Record<string, number>> = T & {
     [Symbol.hasInstance]: (value: unknown) => value is ErrorLike;
 };
 
-export function checkError(error: Ref): void {
-    if (error.value !== null) {
-        const gerror = wrapHandle<ErrorLike>(error.value as ExternalObject<Handle>, getWrapperClass(getErrorType()));
-        Error.captureStackTrace(gerror, checkError);
-        throw gerror;
+function checkError(error: Ref): void {
+    if (error.value === null) {
+        return;
     }
+
+    const gerror = wrapHandle(error.value as ExternalObject<Handle>, getWrapperClass(getErrorType())) as ErrorLike;
+    const callSite = new Error("gtkx call site");
+    const callerFrames = (callSite.stack ?? "").split("\n").slice(2);
+    gerror.stack = [`${gerror.name}: ${gerror.message}`, ...callerFrames].join("\n");
+    throw gerror;
 }
 
 const isError = (value: unknown): value is ErrorLike => isTypedClass(value) && value.__type__ === getErrorType();
@@ -34,16 +37,22 @@ const isError = (value: unknown): value is ErrorLike => isTypedClass(value) && v
  * @param resolveDomain Called once, on first `instanceof` check, to obtain the domain quark.
  * @param members The error code enum members to expose on the returned object.
  */
-export function createErrorDomain<const T extends Record<string, number>>(
+function createErrorDomain<const T extends Record<string, number>>(
     resolveDomain: () => number,
     members: T,
 ): ErrorDomain<T> {
     let domain: number | undefined;
+
     const hasInstance = (value: unknown): value is ErrorLike => {
         domain ??= resolveDomain();
+
         return isError(value) && value.domain === domain;
     };
+
     const enumObject: Record<string, unknown> = { ...members };
     Object.defineProperty(enumObject, Symbol.hasInstance, { value: hasInstance });
+
     return enumObject as ErrorDomain<T>;
 }
+
+export { checkError, createErrorDomain, type ErrorDomain };

package/src/exit-hook.ts

@@ -0,0 +1,3 @@
+import { quit } from "./lifecycle.js";
+
+process.on("exit", quit);