@gtkx/codegen 1.0.0-rc.4 → 1.1.0

package/overrides/graphene/structs.ts.ejs

@@ -1,37 +1,92 @@
 import { Point as GeneratedPoint, Rect as GeneratedRect, Size as GeneratedSize } from "../graphene.js";
 
+/**
+ * Allocates a new `Point` and initializes it to the given coordinates.
+ *
+ * @param x the X coordinate
+ * @param y the Y coordinate
+ * @returns the initialized point
+ */
 const createPoint = (x: number, y: number): GeneratedPoint => {
     const point = GeneratedPoint.alloc();
     point.init(x, y);
     return point;
 };
 
+/**
+ * Allocates a new `Rect` and initializes it to the given origin and size.
+ *
+ * @param x the X coordinate of the origin
+ * @param y the Y coordinate of the origin
+ * @param width the width of the rectangle
+ * @param height the height of the rectangle
+ * @returns the initialized rectangle
+ */
 const createRect = (x: number, y: number, width: number, height: number): GeneratedRect => {
     const rect = GeneratedRect.alloc();
     rect.init(x, y, width, height);
     return rect;
 };
 
+/**
+ * Allocates a new `Size` and initializes it to the given width and height.
+ *
+ * @param width the width
+ * @param height the height
+ * @returns the initialized size
+ */
 const createSize = (width: number, height: number): GeneratedSize => {
     const size = GeneratedSize.alloc();
     size.init(width, height);
     return size;
 };
 
+/** A point with two coordinates. */
 export const Point: typeof GeneratedPoint & { create: typeof createPoint } = Object.assign(GeneratedPoint, {
     create: createPoint,
 });
 
+/** A point with two coordinates. */
 export type Point = GeneratedPoint;
 
+/**
+ * The location and size of a rectangle region.
+ *
+ * The width and height of a `graphene_rect_t` can be negative; for instance,
+ * a `graphene_rect_t` with an origin of [ 0, 0 ] and a size of [ 10, 10 ] is
+ * equivalent to a `graphene_rect_t` with an origin of [ 10, 10 ] and a size
+ * of [ -10, -10 ].
+ *
+ * Application code can normalize rectangles using `graphene_rect_normalize()`;
+ * this function will ensure that the width and height of a rectangle are
+ * positive values. All functions taking a `graphene_rect_t` as an argument
+ * will internally operate on a normalized copy; all functions returning a
+ * `graphene_rect_t` will always return a normalized rectangle.
+ */
 export const Rect: typeof GeneratedRect & { create: typeof createRect } = Object.assign(GeneratedRect, {
     create: createRect,
 });
 
+/**
+ * The location and size of a rectangle region.
+ *
+ * The width and height of a `graphene_rect_t` can be negative; for instance,
+ * a `graphene_rect_t` with an origin of [ 0, 0 ] and a size of [ 10, 10 ] is
+ * equivalent to a `graphene_rect_t` with an origin of [ 10, 10 ] and a size
+ * of [ -10, -10 ].
+ *
+ * Application code can normalize rectangles using `graphene_rect_normalize()`;
+ * this function will ensure that the width and height of a rectangle are
+ * positive values. All functions taking a `graphene_rect_t` as an argument
+ * will internally operate on a normalized copy; all functions returning a
+ * `graphene_rect_t` will always return a normalized rectangle.
+ */
 export type Rect = GeneratedRect;
 
+/** A size. */
 export const Size: typeof GeneratedSize & { create: typeof createSize } = Object.assign(GeneratedSize, {
     create: createSize,
 });
 
+/** A size. */
 export type Size = GeneratedSize;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gtkx/codegen",
-  "version": "1.0.0-rc.4",
+  "version": "1.1.0",
   "description": "Generates the typed GTKX bindings and API reference from GIR and OpenGL registry data",
   "keywords": [
     "gtkx",
@@ -40,15 +40,26 @@
     "overrides",
     "src"
   ],
+  "nx": {
+    "targets": {
+      "lint": {
+        "options": {
+          "cwd": ".",
+          "command": "eslint {projectRoot}"
+        }
+      }
+    }
+  },
   "engines": {
     "node": ">=24"
   },
   "dependencies": {
-    "@types/node": "^26.1.2",
+    "@types/node": "^26.2.0",
     "fast-xml-parser": "^5.10.1",
+    "fast-xml-validator": "^1.4.1",
     "typescript": "^6.0.3",
-    "@gtkx/react": "1.0.0-rc.4",
-    "@gtkx/utils": "1.0.0-rc.4"
+    "@gtkx/react": "1.1.0",
+    "@gtkx/utils": "1.1.0"
   },
   "scripts": {
     "release": "tsx ../../scripts/release-package.ts"

package/src/analysis/descriptor-render.ts

@@ -1,10 +1,11 @@
-import { sourceStringLiteral } from "@gtkx/utils";
+import { sanitizeTypeIdentifier, sourceStringLiteral } from "@gtkx/utils";
 import type { GirCallback } from "../gir/callback.js";
 import type { Library } from "../gir/library.js";
 import type { PrimitiveCategory } from "../gir/primitives.js";
 import type { EntityType, GirType } from "../gir/type.js";
 import type { ModuleContext } from "../writer/context.js";
 import {
+    type GirCursorBounds,
     type GirParameter,
     type GirReturnValue,
     isCallerAllocatedOut,
@@ -20,7 +21,7 @@ import {
     type TypeId,
 } from "../gir/type-id.js";
 import { isRecordInout } from "../store/gi/param-marshal.js";
-import { computeRecordFieldSlots } from "../store/gi/record-layout.js";
+import { computeRecordFieldSlots, recordInlineSize } from "../store/gi/record-layout.js";
 import { isValueMarshalable } from "../store/gi/value-marshalable.js";
 import {
     type ListDescriptorName,
@@ -30,6 +31,7 @@ import {
     tBoxed,
     tByteArray,
     tCallback,
+    tCursorArray,
     tEnum,
     tFixedArray,
     tFlags,
@@ -48,18 +50,23 @@ import {
     tUint64,
     tVoid,
 } from "./descriptor.js";
+import { carrayFor, isUnboundedArray, primitiveCategoryFor } from "./type-shape.js";
 
-type RenderDescriptorOptions = {
-    argIndexOffset?: number;
-    argIndexMap?: Map<number, number> | undefined;
-    isCallerAllocated?: boolean;
-    isInline?: boolean;
-    isNewlyCreated?: boolean;
-};
+type PrimaryReturnKind = "surfaced" | "void" | "skipped";
 
 type ArgIndexOptions = {
     argIndexOffset: number;
     argIndexMap: Map<number, number> | undefined;
+    cursor: GirCursorBounds | undefined;
+    hasOutIndirection: boolean;
+};
+
+type CursorArgIndexOptions = ArgIndexOptions & { cursor: GirCursorBounds };
+
+type RenderDescriptorOptions = Partial<ArgIndexOptions> & {
+    isCallerAllocated?: boolean;
+    isInline?: boolean;
+    isNewlyCreated?: boolean;
 };
 
 type RecordPlacement = {
@@ -88,6 +95,7 @@ type ResolvedRecord = Extract<EntityType, { kind: "record" }>["value"];
 
 type FundamentalRecordOptions = {
     resolved: Extract<EntityType, { kind: "record" }>;
+    lib: string;
     refFunc: string;
     unrefFunc: string;
     ownership: Ownership;
@@ -122,21 +130,35 @@ const transferOwnership = (transfer: ParameterTransfer): Ownership => {
 const deriveElementTransfer = (transfer: ParameterTransfer): ParameterTransfer =>
     transfer === "container" ? "none" : transfer;
 
-const isVoidRef = (library: Library, ref: TypeId | undefined): boolean => {
-    if (ref === undefined) {
-        return true;
-    }
-
-    const type = library.typeFor(ref);
-
-    return type?.kind === "primitive" && type.category === "void";
-};
+const isVoidRef = (library: Library, ref: TypeId | undefined): boolean =>
+    ref === undefined || primitiveCategoryFor(library, ref) === "void";
 
 const isInlineCallbackRef = (library: Library, ref: TypeId | undefined): boolean =>
     ref !== undefined && library.typeFor(ref)?.kind === "callback" && library.nameFor(ref) === undefined;
 
+const primaryReturnKind = (library: Library, returnValue: GirReturnValue): PrimaryReturnKind => {
+    if (isVoidRef(library, returnValue.type)) {
+        return "void";
+    }
+
+    return returnValue.skip ? "skipped" : "surfaced";
+};
+
 const shouldOmitPrimaryReturn = (library: Library, returnValue: GirReturnValue): boolean =>
-    isVoidRef(library, returnValue.type) || returnValue.skip;
+    primaryReturnKind(library, returnValue) !== "surfaced";
+
+const isSkippedPrimaryReturn = (library: Library, returnValue: GirReturnValue): boolean =>
+    primaryReturnKind(library, returnValue) === "skipped";
+
+const isVoidPrimaryReturn = (library: Library, returnValue: GirReturnValue): boolean =>
+    primaryReturnKind(library, returnValue) === "void";
+
+const argIndexOptions = (options: RenderDescriptorOptions): ArgIndexOptions => ({
+    argIndexOffset: options.argIndexOffset ?? 0,
+    argIndexMap: options.argIndexMap,
+    cursor: options.cursor,
+    hasOutIndirection: options.hasOutIndirection === true,
+});
 
 const renderDescriptor = (
     context: ModuleContext,
@@ -148,8 +170,7 @@ const renderDescriptor = (
         return tVoid;
     }
 
-    const { argIndexOffset = 0 } = options;
-    const indexOptions: ArgIndexOptions = { argIndexOffset, argIndexMap: options.argIndexMap };
+    const indexOptions = argIndexOptions(options);
     const ownership = transferOwnership(transfer);
     const type = context.library.typeFor(ref);
 
@@ -255,8 +276,19 @@ const isScalarRef = (library: Library, ref: TypeId | undefined): boolean => {
     return type !== undefined && isScalarType(library, type);
 };
 
+const isStrvRef = (library: Library, ref: TypeId | undefined): boolean => {
+    const type = carrayFor(library, ref);
+
+    if (type === undefined) {
+        return false;
+    }
+
+    return isUnboundedArray(type) && primitiveCategoryFor(library, type.element) === "string";
+};
+
 const isCellInout = (library: Library, parameter: GirParameter): boolean =>
-    isInoutParameter(parameter) && isScalarRef(library, parameter.type);
+    isInoutParameter(parameter) &&
+    (isScalarRef(library, parameter.type) || isStrvRef(library, parameter.type));
 
 const renderParamDescriptor = (
     context: ModuleContext,
@@ -264,12 +296,14 @@ const renderParamDescriptor = (
     ref: TypeId | undefined,
     argIndex: Partial<ArgIndexOptions> = {},
 ): string => {
+    const behindRef: RenderDescriptorOptions = { ...argIndex, cursor: parameter.cursor, hasOutIndirection: true };
+
     if (isCellInout(context.library, parameter)) {
-        return tRef(renderDescriptor(context, ref, parameter.transferOwnership, argIndex), true);
+        return tRef(renderDescriptor(context, ref, parameter.transferOwnership, behindRef), true);
     }
 
     if (isOutParameter(parameter)) {
-        return tRef(renderDescriptor(context, ref, parameter.transferOwnership, argIndex));
+        return tRef(renderDescriptor(context, ref, parameter.transferOwnership, behindRef));
     }
 
     return renderDescriptor(context, ref, parameter.transferOwnership, {
@@ -296,13 +330,17 @@ const findUserDataIndex = (parameters: GirParameter[]): number | undefined => {
     return declared?.closureIndex ?? userDataIndexByName(parameters);
 };
 
-const callbackOptionsArg = (owningParameter: GirParameter, userDataIndex: number | undefined): string | undefined => {
+const callbackOptionsArg = (owningParameter: GirParameter, userDataIndex: number | undefined): string[] => {
     const options: string[] = [];
 
     if (owningParameter.destroyIndex !== undefined) {
         options.push("hasDestroy: true");
     }
 
+    if (owningParameter.closureIndex !== undefined) {
+        options.push("hasUserData: true");
+    }
+
     if (userDataIndex !== undefined) {
         options.push(`userDataIndex: ${String(userDataIndex)}`);
     }
@@ -311,7 +349,7 @@ const callbackOptionsArg = (owningParameter: GirParameter, userDataIndex: number
         options.push(`scope: ${sourceStringLiteral(owningParameter.scope)}`);
     }
 
-    return options.length > 0 ? `{ ${options.join(", ")} }` : undefined;
+    return options;
 };
 
 const renderCallbackType = (
@@ -330,15 +368,13 @@ const renderCallbackType = (
         (parameter, index) => argOverrides?.get(index) ?? renderParamDescriptor(context, parameter, parameter.type),
     );
 
-    const returnRef = callback.returnValue.type;
-
-    const returnType = isVoidRef(context.library, returnRef)
-        ? tVoid
-        : renderDescriptor(context, returnRef, callback.returnValue.transferOwnership);
+    const { returnValue } = callback;
 
-    const optionsArg = callbackOptionsArg(owningParameter, findUserDataIndex(callback.parameters));
-
-    return tCallback(argTypes, returnType, optionsArg);
+    return tCallback({
+        argTypes,
+        returns: renderDescriptor(context, returnValue.type, returnValue.transferOwnership),
+        options: callbackOptionsArg(owningParameter, findUserDataIndex(callback.parameters)),
+    });
 };
 
 const primitiveExpression = (category: PrimitiveCategory, ownership: Ownership): string => {
@@ -406,13 +442,14 @@ const getFundamental = (
     node: Extract<EntityType, { kind: "class" | "interface" }>,
 ): AncestorFundamental | undefined => {
     const cls = node.value;
+    const lib = node.namespace.sharedLibrary;
 
-    if (!cls.fundamental || cls.glibRefFunc === undefined || cls.glibUnrefFunc === undefined) {
+    if (lib === undefined || !cls.fundamental || cls.glibRefFunc === undefined || cls.glibUnrefFunc === undefined) {
         return undefined;
     }
 
     return {
-        lib: node.namespace.sharedLibrary ?? "",
+        lib,
         refFunc: cls.glibRefFunc,
         unrefFunc: cls.glibUnrefFunc,
         typeName: cls.glibTypeName,
@@ -458,10 +495,11 @@ const fundamentalAncestor = (
 const classSelfDescriptor = (
     context: ModuleContext,
     type: Extract<EntityType, { kind: "class" | "interface" }>,
+    ownership: Ownership,
 ): string => {
     const ancestor = fundamentalAncestor(context, type);
 
-    return ancestor === undefined ? tObject("borrowed") : renderFundamental({ ...ancestor, ownership: "borrowed" });
+    return ancestor === undefined ? tObject(ownership) : renderFundamental({ ...ancestor, ownership });
 };
 
 const renderSelfDescriptor = (context: ModuleContext, instance: GirParameter): string => {
@@ -478,7 +516,7 @@ const renderSelfDescriptor = (context: ModuleContext, instance: GirParameter): s
     }
 
     if (isClassOrInterface(type)) {
-        return classSelfDescriptor(context, type);
+        return classSelfDescriptor(context, type, transferOwnership(instance.transferOwnership));
     }
 
     if (type.kind === "record") {
@@ -510,7 +548,7 @@ const structExpression = (
     options: { isCallerAllocated: boolean; isInline: boolean },
 ): string => {
     const { size } = computeRecordFieldSlots(context, resolved.value.fields, resolved.value.isUnion);
-    const wrapperClass = context.qualify(resolved.namespace.name, resolved.value.name);
+    const wrapperClass = context.qualify(resolved.namespace.name, sanitizeTypeIdentifier(resolved.value.name));
     const isCopyable = isValueMarshalable(context, resolved.namespace.name, resolved.value);
 
     return tStruct(ownership, {
@@ -522,10 +560,10 @@ const structExpression = (
 };
 
 const fundamentalRecordExpression = (options: FundamentalRecordOptions): string => {
-    const { resolved, refFunc, unrefFunc, ownership, wrapperClass, isInline } = options;
+    const { resolved, lib, refFunc, unrefFunc, ownership, wrapperClass, isInline } = options;
 
     return renderFundamental({
-        lib: resolved.namespace.sharedLibrary ?? "",
+        lib,
         refFunc,
         unrefFunc,
         typeName: resolved.value.glibTypeName,
@@ -586,14 +624,16 @@ const recordExpression = (
 ): string => {
     const record = resolved.value;
     const { refFunc, unrefFunc } = recordRefPair(record);
+    const lib = resolved.namespace.sharedLibrary;
 
-    if (refFunc !== undefined && unrefFunc !== undefined) {
+    if (refFunc !== undefined && unrefFunc !== undefined && lib !== undefined) {
         const wrapperClass = requiresFallbackClass(record)
-            ? context.qualify(resolved.namespace.name, record.name)
+            ? context.qualify(resolved.namespace.name, sanitizeTypeIdentifier(record.name))
             : undefined;
 
         return fundamentalRecordExpression({
             resolved,
+            lib,
             refFunc,
             unrefFunc,
             ownership,
@@ -610,13 +650,12 @@ const rawEnumDescriptor = (isSigned: boolean): string => (isSigned ? tInt32 : tU
 const enumExpression = (resolved: Extract<EntityType, { kind: "enum" }>): string => {
     const getter = resolved.value.glibGetType;
     const isSigned = resolved.value.members.some((member) => member.value.startsWith("-"));
+    const lib = resolved.namespace.sharedLibrary;
 
-    if (getter === undefined || getter === "") {
+    if (getter === undefined || getter === "" || lib === undefined) {
         return rawEnumDescriptor(isSigned);
     }
 
-    const lib = resolved.namespace.sharedLibrary ?? "";
-
     return resolved.value.kind === "bitfield" ? tFlags(lib, getter, isSigned) : tEnum(lib, getter, isSigned);
 };
 
@@ -648,19 +687,53 @@ const expressionForResolved = (
     }
 };
 
+const elementExpression = (
+    context: ModuleContext,
+    ref: CArrayType,
+    transfer: ParameterTransfer,
+    options: ArgIndexOptions,
+): string =>
+    renderDescriptor(context, ref.element, deriveElementTransfer(transfer), {
+        ...options,
+        cursor: undefined,
+        hasOutIndirection: false,
+    });
+
+const cursorArrayExpression = (
+    context: ModuleContext,
+    ref: CArrayType,
+    transfer: ParameterTransfer,
+    options: CursorArgIndexOptions,
+): string =>
+    tCursorArray(
+        elementExpression(context, ref, transfer, options),
+        {
+            baseIndex: mapArgIndex(options, options.cursor.baseIndex),
+            lengthIndex: mapArgIndex(options, options.cursor.lengthIndex),
+        },
+        transferOwnership(transfer),
+        inlineElementSize(context, ref, options.hasOutIndirection),
+    );
+
 const arrayExpression = (
     context: ModuleContext,
     ref: CArrayType,
     transfer: ParameterTransfer,
     options: ArgIndexOptions,
 ): string => {
+    const { cursor } = options;
+
+    if (cursor !== undefined) {
+        return cursorArrayExpression(context, ref, transfer, { ...options, cursor });
+    }
+
     if (hasUnknownArrayLength(ref)) {
         return tUint64;
     }
 
     const ownership = transferOwnership(transfer);
-    const element = renderDescriptor(context, ref.element, deriveElementTransfer(transfer), options);
-    const size = inlineElementSize(context, ref.element, ref.elementCType);
+    const element = elementExpression(context, ref, transfer, options);
+    const size = inlineElementSize(context, ref, options.hasOutIndirection);
 
     if (ref.lengthParameterIndex !== undefined) {
         return tSizedArray(element, mapArgIndex(options, ref.lengthParameterIndex), ownership, size);
@@ -673,30 +746,18 @@ const arrayExpression = (
     return tArray(element, ownership, size);
 };
 
-const recordInlineSize = (context: ModuleContext, record: ResolvedRecord): number | undefined => {
-    if (record.opaque || record.disguised || record.fields.length === 0) {
-        return undefined;
-    }
-
-    const { size } = computeRecordFieldSlots(context, record.fields, record.isUnion);
+const elementPointerDepth = (elementCType: string | undefined, hasOutIndirection: boolean): number => {
+    const declared = elementCType === undefined ? 0 : elementCType.split("*").length - 1;
 
-    return size > 0 ? size : undefined;
+    return hasOutIndirection ? declared - 1 : declared;
 };
 
-const inlineElementSize = (
-    context: ModuleContext,
-    element: TypeId | undefined,
-    elementCType: string | undefined,
-): number | undefined => {
-    if (element === undefined) {
-        return undefined;
-    }
-
-    if (elementCType?.includes("*")) {
+const inlineElementSize = (context: ModuleContext, ref: CArrayType, hasOutIndirection: boolean): number | undefined => {
+    if (elementPointerDepth(ref.elementCType, hasOutIndirection) > 0) {
         return undefined;
     }
 
-    const type = context.library.typeFor(element);
+    const type = context.library.typeFor(ref.element);
 
     if (type?.kind !== "record") {
         return undefined;
@@ -720,6 +781,9 @@ const aliasExpression = (
 
 export {
     isInlineCallbackRef,
+    isSkippedPrimaryReturn,
+    isVoidPrimaryReturn,
+    primaryReturnKind,
     shouldOmitPrimaryReturn,
     renderDescriptor,
     isScalarRef,

package/src/analysis/descriptor.ts

@@ -1,4 +1,5 @@
 import { sourceStringLiteral } from "@gtkx/utils";
+import type { GirCursorBounds } from "../gir/parameter.js";
 import { joinArgs } from "../writer/emit.js";
 
 type Ownership = "borrowed" | "full";
@@ -39,6 +40,7 @@ type DescriptorName =
     "byteArray" |
     "sizedArray" |
     "fixedArray" |
+    "cursorArray" |
     "callback" |
     "fn";
 
@@ -92,6 +94,21 @@ type BindArgs = {
     returnType: string;
 };
 
+type FnSpecParts = {
+    args: string;
+    returns: string;
+    isReturnSkipped: boolean;
+    canThrow: boolean;
+};
+
+type CallbackSpecParts = {
+    argTypes: string[];
+    returns: string;
+    options: string[];
+};
+
+const SKIPPED_RETURN_ENTRY = "isReturnSkipped: true";
+
 const T: DescriptorNames = {
     bind: "t.bind",
     int8: "t.int8",
@@ -128,6 +145,7 @@ const T: DescriptorNames = {
     byteArray: "t.byteArray",
     sizedArray: "t.sizedArray",
     fixedArray: "t.fixedArray",
+    cursorArray: "t.cursorArray",
     callback: "t.callback",
     fn: "t.fn",
 };
@@ -235,6 +253,14 @@ const tSizedArray = (
         elementSize === undefined ? undefined : String(elementSize),
     ]);
 
+const tCursorArray = (element: string, bounds: GirCursorBounds, ownership?: Ownership, elementSize?: number): string =>
+    call("cursorArray", [
+        element,
+        `{ baseParamIndex: ${String(bounds.baseIndex)}, sizeParamIndex: ${String(bounds.lengthIndex)} }`,
+        ownership === undefined ? undefined : sourceStringLiteral(ownership),
+        elementSize === undefined ? undefined : String(elementSize),
+    ]);
+
 const tFixedArray = (element: string, length: number, ownership?: Ownership, elementSize?: number): string =>
     call("fixedArray", [
         element,
@@ -243,23 +269,23 @@ const tFixedArray = (element: string, length: number, ownership?: Ownership, ele
         elementSize === undefined ? undefined : String(elementSize),
     ]);
 
-const tCallback = (argTypes: string[], returnType: string, options?: string): string =>
-    call("callback", [`[${argTypes.join(", ")}]`, returnType, options]);
+const tCallback = (spec: CallbackSpecParts): string => {
+    const optionsArg = spec.options.length > 0 ? `{ ${spec.options.join(", ")} }` : undefined;
+
+    return call("callback", [`[${spec.argTypes.join(", ")}]`, spec.returns, optionsArg]);
+};
 
 const tBind = (args: BindArgs): string =>
     call("bind", [args.libExpr, args.symbolExpr, args.argList, args.returnType]);
 
-const tFn = (
-    lib: string,
-    cIdentifier: string,
-    spec: { args: string; returns: string; canThrow: boolean },
-): string => {
+const tFn = (lib: string, cIdentifier: string, spec: FnSpecParts): string => {
+    const skipEntry = spec.isReturnSkipped ? `, ${SKIPPED_RETURN_ENTRY}` : "";
     const throwsEntry = spec.canThrow ? ", canThrow: true" : "";
 
     return call("fn", [
         sourceStringLiteral(lib),
         sourceStringLiteral(cIdentifier),
-        `{ args: ${spec.args}, returns: ${spec.returns}${throwsEntry} }`,
+        `{ args: ${spec.args}, returns: ${spec.returns}${skipEntry}${throwsEntry} }`,
     ]);
 };
 
@@ -288,13 +314,11 @@ export {
     tArray,
     tSizedArray,
     tFixedArray,
+    tCursorArray,
     tCallback,
     tBind,
     tFn,
     type Ownership,
     type ScalarDescriptorName,
-    type BoxedOptions,
-    type StructOptions,
-    type FundamentalOptions,
     type ListDescriptorName,
 };