@gtkx/codegen 1.0.0 → 1.2.0

package/dist/xml.js.map

@@ -1 +1 @@
-{"version":3,"file":"xml.js","sourceRoot":"","sources":["../src/xml.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE7D,MAAM,eAAe,GAAG,CAAC,OAA4B,EAAa,EAAE,CAChE,IAAI,SAAS,CAAC;IACV,gBAAgB,EAAE,KAAK;IACvB,mBAAmB,EAAE,IAAI;IACzB,mBAAmB,EAAE,KAAK;IAC1B,aAAa,EAAE,KAAK;IACpB,GAAG,OAAO;CACb,CAAC,CAAC;AAEP,OAAO,EAAE,eAAe,EAAE,CAAC","sourcesContent":["import { type X2jOptions, XMLParser } from \"fast-xml-parser\";\n\nconst createXmlParser = (options: Partial<X2jOptions>): XMLParser =>\n    new XMLParser({\n        ignoreAttributes: false,\n        attributeNamePrefix: \"@_\",\n        parseAttributeValue: false,\n        parseTagValue: false,\n        ...options,\n    });\n\nexport { createXmlParser };\n"]}
+{"version":3,"file":"xml.js","sourceRoot":"","sources":["../src/xml.ts"],"names":[],"mappings":"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","sourcesContent":["import { errorMessage, isRecord } from \"@gtkx/utils\";\nimport { type X2jOptions, XMLParser } from \"fast-xml-parser\";\nimport { SyntaxValidator } from \"fast-xml-validator\";\nimport { readFileSync } from \"node:fs\";\n\ntype XmlFileInput = {\n    parser: XMLParser;\n    label: string;\n    path: string;\n    malformedRemedy?: string;\n};\n\nconst HIGHEST_CONTROL_CODE = 0x1F;\nconst LEGAL_CONTROL_CODES: Set<number> = new Set([0x09, 0x0A, 0x0D]);\n\nconst createXmlParser = (options: Partial<X2jOptions>): XMLParser =>\n    new XMLParser({\n        ignoreAttributes: false,\n        attributeNamePrefix: \"@_\",\n        parseAttributeValue: false,\n        parseTagValue: false,\n        ...options,\n    });\n\nconst xmlFileError = (input: XmlFileInput, action: string, error: unknown): Error =>\n    new Error(`Cannot ${action} the ${input.label} at ${input.path}: ${errorMessage(error)}`, { cause: error });\n\nconst readXmlFile = (input: XmlFileInput): string => {\n    try {\n        return readFileSync(input.path, \"utf8\");\n    } catch (error) {\n        throw xmlFileError(input, \"read\", error);\n    }\n};\n\nconst isLocated = (line: unknown, col: unknown): boolean =>\n    typeof line === \"number\" && typeof col === \"number\" && (line > 1 || col > 1);\n\nconst positionSuffix = (error: unknown): string => {\n    if (!isRecord(error)) {\n        return \"\";\n    }\n\n    const { line, col } = error;\n\n    if (!isLocated(line, col)) {\n        return \"\";\n    }\n\n    return ` (line ${String(line)}, column ${String(col)})`;\n};\n\nconst isIllegalControlCode = (code: number): boolean =>\n    code <= HIGHEST_CONTROL_CODE && !LEGAL_CONTROL_CODES.has(code);\n\nconst escapedCode = (code: number): string => `[U+${code.toString(16).toUpperCase().padStart(4, \"0\")}]`;\n\nconst escapeControlCodes = (text: string): string => {\n    let escaped = \"\";\n\n    for (const character of text) {\n        const code = character.codePointAt(0) ?? 0;\n        escaped += isIllegalControlCode(code) ? escapedCode(code) : character;\n    }\n\n    return escaped;\n};\n\nconst offendingLine = (xml: string, error: unknown): string => {\n    const line = isRecord(error) ? error.line : undefined;\n\n    if (typeof line !== \"number\") {\n        return \"\";\n    }\n\n    const text = xml.split(\"\\n\")[line - 1];\n\n    if (text === undefined) {\n        return \"\";\n    }\n\n    return `\\n    ${escapeControlCodes(text.replace(/^[ \\t]+/, \"\").replace(/\\r$/, \"\"))}`;\n};\n\nconst remedySuffix = (input: XmlFileInput, xml: string, error: unknown): string => {\n    const remedy = input.malformedRemedy;\n\n    return remedy === undefined ? \"\" : `${offendingLine(xml, error)}\\n${remedy}`;\n};\n\nconst assertWellFormed = (input: XmlFileInput, xml: string): void => {\n    try {\n        SyntaxValidator.validate(xml);\n    } catch (error) {\n        throw new Error(\n            `The ${input.label} at ${input.path} is not well-formed XML: ` +\n            `${errorMessage(error)}${positionSuffix(error)}${remedySuffix(input, xml, error)}`,\n            { cause: error },\n        );\n    }\n};\n\nconst parseXmlFile = (input: XmlFileInput): unknown => {\n    const xml = readXmlFile(input);\n    assertWellFormed(input, xml);\n\n    try {\n        return input.parser.parse(xml);\n    } catch (error) {\n        throw xmlFileError(input, \"parse\", error);\n    }\n};\n\nexport { createXmlParser, parseXmlFile };\n"]}

package/overrides/gobject/object.ts.ejs

@@ -52,6 +52,7 @@ declare module "../gobject.js" {
          * @param callback Handler invoked on each emission.
          * @param isAfter Run the handler after the default handler rather than before it.
          * @returns The same object, so calls chain.
+         * @deprecated Since 1.2. Use `on` instead. Removed in v2.
          */
         addEventListener(sigName: string, callback: (...args: unknown[]) => unknown, isAfter?: boolean): Object;
 
@@ -61,6 +62,7 @@ declare module "../gobject.js" {
          * @param sigName Signal the handler was connected to.
          * @param callback The handler that was connected.
          * @returns The same object, so calls chain.
+         * @deprecated Since 1.2. Use `off` instead. Removed in v2.
          */
         removeEventListener(sigName: string, callback: (...args: unknown[]) => unknown): Object;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gtkx/codegen",
-  "version": "1.0.0",
+  "version": "1.2.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.2.0",
     "fast-xml-parser": "^5.10.1",
+    "fast-xml-validator": "^1.4.1",
     "typescript": "^6.0.3",
-    "@gtkx/utils": "1.0.0",
-    "@gtkx/react": "1.0.0"
+    "@gtkx/react": "1.2.0",
+    "@gtkx/utils": "1.2.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,16 +21,19 @@ 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 ArrayLayout,
     type ListDescriptorName,
     type Ownership,
     type ScalarDescriptorName,
     tArray,
+    tBiguint64,
     tBoxed,
     tByteArray,
     tCallback,
+    tCursorArray,
     tEnum,
     tFixedArray,
     tFlags,
@@ -38,6 +42,7 @@ import {
     tHashTable,
     tInt32,
     tList,
+    tNumericByteArray,
     tObject,
     tRef,
     tScalar,
@@ -48,23 +53,25 @@ import {
     tUint64,
     tVoid,
 } from "./descriptor.js";
-import { carrayFor, isUnboundedArray, primitiveCategoryFor } from "./type-shape.js";
+import { carrayFor, isByteSequence, isUnboundedArray, primitiveCategoryFor } from "./type-shape.js";
 
-type RenderDescriptorOptions = {
-    argIndexOffset?: number;
-    argIndexMap?: Map<number, number> | undefined;
-    hasOutIndirection?: boolean;
-    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 = {
     isCallerAllocated?: boolean;
     isInline?: boolean;
@@ -91,6 +98,7 @@ type ResolvedRecord = Extract<EntityType, { kind: "record" }>["value"];
 
 type FundamentalRecordOptions = {
     resolved: Extract<EntityType, { kind: "record" }>;
+    lib: string;
     refFunc: string;
     unrefFunc: string;
     ownership: Ownership;
@@ -131,12 +139,27 @@ const isVoidRef = (library: Library, ref: TypeId | undefined): boolean =>
 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,
 });
 
@@ -200,7 +223,7 @@ const listExpression = (
     const ownership = transferOwnership(transfer);
 
     if (type.flavor === "gbytearray") {
-        return tByteArray(ownership);
+        return context.library.isByteArrayTyped ? tByteArray(ownership) : tNumericByteArray(ownership);
     }
 
     const element = renderDescriptor(context, type.element, deriveElementTransfer(transfer), indexOptions);
@@ -276,7 +299,7 @@ const renderParamDescriptor = (
     ref: TypeId | undefined,
     argIndex: Partial<ArgIndexOptions> = {},
 ): string => {
-    const behindRef: RenderDescriptorOptions = { ...argIndex, hasOutIndirection: true };
+    const behindRef: RenderDescriptorOptions = { ...argIndex, cursor: parameter.cursor, hasOutIndirection: true };
 
     if (isCellInout(context.library, parameter)) {
         return tRef(renderDescriptor(context, ref, parameter.transferOwnership, behindRef), true);
@@ -310,7 +333,7 @@ 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) {
@@ -329,7 +352,7 @@ const callbackOptionsArg = (owningParameter: GirParameter, userDataIndex: number
         options.push(`scope: ${sourceStringLiteral(owningParameter.scope)}`);
     }
 
-    return options.length > 0 ? `{ ${options.join(", ")} }` : undefined;
+    return options;
 };
 
 const renderCallbackType = (
@@ -348,15 +371,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 => {
@@ -369,7 +390,7 @@ const primitiveExpression = (category: PrimitiveCategory, ownership: Ownership):
     }
 
     if (category === "pointer") {
-        return tUint64;
+        return tBiguint64;
     }
 
     if (category === "gtype") {
@@ -424,13 +445,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,
@@ -529,7 +551,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, {
@@ -541,10 +563,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,
@@ -605,14 +627,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,
@@ -629,13 +653,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);
 };
 
@@ -667,40 +690,69 @@ 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 & { layout: ArrayLayout },
+): string =>
+    tCursorArray(
+        elementExpression(context, ref, transfer, options),
+        {
+            baseIndex: mapArgIndex(options, options.cursor.baseIndex),
+            lengthIndex: mapArgIndex(options, options.cursor.lengthIndex),
+        },
+        transferOwnership(transfer),
+        options.layout,
+    );
+
+const arrayLayout = (context: ModuleContext, ref: CArrayType, options: ArgIndexOptions): ArrayLayout => ({
+    elementSize: inlineElementSize(context, ref, options.hasOutIndirection),
+    isBytes:
+        context.library.isByteArrayTyped && !hasUnknownArrayLength(ref) && isByteSequence(context.library, ref),
+});
+
 const arrayExpression = (
     context: ModuleContext,
     ref: CArrayType,
     transfer: ParameterTransfer,
     options: ArgIndexOptions,
 ): string => {
+    const { cursor } = options;
+    const layout = arrayLayout(context, ref, options);
+
+    if (cursor !== undefined) {
+        return cursorArrayExpression(context, ref, transfer, { ...options, cursor, layout });
+    }
+
     if (hasUnknownArrayLength(ref)) {
         return tUint64;
     }
 
     const ownership = transferOwnership(transfer);
-    const elementOptions: ArgIndexOptions = { ...options, hasOutIndirection: false };
-    const element = renderDescriptor(context, ref.element, deriveElementTransfer(transfer), elementOptions);
-    const size = inlineElementSize(context, ref, options.hasOutIndirection);
+    const element = elementExpression(context, ref, transfer, options);
 
     if (ref.lengthParameterIndex !== undefined) {
-        return tSizedArray(element, mapArgIndex(options, ref.lengthParameterIndex), ownership, size);
+        return tSizedArray(element, mapArgIndex(options, ref.lengthParameterIndex), ownership, layout);
     }
 
     if (ref.fixedSize !== undefined) {
-        return tFixedArray(element, ref.fixedSize, ownership, size);
+        return tFixedArray(element, ref.fixedSize, ownership, layout);
     }
 
-    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);
-
-    return size > 0 ? size : undefined;
+    return tArray(element, ownership, layout);
 };
 
 const elementPointerDepth = (elementCType: string | undefined, hasOutIndirection: boolean): number => {
@@ -738,11 +790,13 @@ const aliasExpression = (
 
 export {
     isInlineCallbackRef,
+    isSkippedPrimaryReturn,
+    isVoidPrimaryReturn,
+    primaryReturnKind,
     shouldOmitPrimaryReturn,
     renderDescriptor,
     isScalarRef,
     isCellInout,
-    recordInlineSize,
     renderParamDescriptor,
     renderCallbackType,
     renderSelfDescriptor,

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";
 
@@ -85,6 +87,11 @@ type FundamentalOptions = {
 
 type ListDescriptorName = "list" | "slist" | "ptrArray" | "gArray";
 
+type ArrayLayout = {
+    elementSize?: number | undefined;
+    isBytes: boolean;
+};
+
 type BindArgs = {
     libExpr: string;
     symbolExpr: string;
@@ -92,6 +99,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 +150,7 @@ const T: DescriptorNames = {
     byteArray: "t.byteArray",
     sizedArray: "t.sizedArray",
     fixedArray: "t.fixedArray",
+    cursorArray: "t.cursorArray",
     callback: "t.callback",
     fn: "t.fn",
 };
@@ -138,6 +161,7 @@ const tUint8: string = T.uint8;
 const tUint32: string = T.uint32;
 const tInt32: string = T.int32;
 const tUint64: string = T.uint64;
+const tBiguint64: string = T.biguint64;
 const tGtype: string = T.gtype;
 const tBuffer: string = T.buffer;
 
@@ -211,55 +235,88 @@ const tFlags = (lib: string, typeFnName: string, isSigned: boolean): string =>
 
 const tByteArray = (ownership: Ownership): string => call("byteArray", [sourceStringLiteral(ownership)]);
 
+const tNumericByteArray = (ownership: Ownership): string =>
+    call("array", [
+        tUint8,
+        sourceStringLiteral("gbytearray"),
+        sourceStringLiteral(ownership),
+    ]);
+
 const tList = (name: ListDescriptorName, element: string, ownership: Ownership): string =>
     call(name, [element, sourceStringLiteral(ownership)]);
 
-const tArray = (element: string, ownership?: Ownership, elementSize?: number): string =>
+const arrayLayoutArg = (ownership: Ownership | undefined, layout: ArrayLayout): string | undefined => {
+    if (ownership === undefined) {
+        return undefined;
+    }
+
+    const entries = [
+        layout.elementSize === undefined ? undefined : `elementSize: ${String(layout.elementSize)}`,
+        layout.isBytes ? "isBytes: true" : undefined,
+    ].filter((entry): entry is string => entry !== undefined);
+
+    return entries.length === 0 ? undefined : `{ ${entries.join(", ")} }`;
+};
+
+const tArray = (element: string, ownership: Ownership | undefined, layout: ArrayLayout): string =>
     call("array", [
         element,
         ownership === undefined ? undefined : sourceStringLiteral("array"),
         ownership === undefined ? undefined : sourceStringLiteral(ownership),
-        elementSize === undefined ? undefined : `{ elementSize: ${String(elementSize)} }`,
+        arrayLayoutArg(ownership, layout),
     ]);
 
 const tSizedArray = (
     element: string,
     lengthIndex: number,
-    ownership?: Ownership,
-    elementSize?: number,
+    ownership: Ownership | undefined,
+    layout: ArrayLayout,
 ): string =>
     call("sizedArray", [
         element,
         String(lengthIndex),
         ownership === undefined ? undefined : sourceStringLiteral(ownership),
-        elementSize === undefined ? undefined : String(elementSize),
+        arrayLayoutArg(ownership, layout),
     ]);
 
-const tFixedArray = (element: string, length: number, ownership?: Ownership, elementSize?: number): string =>
+const tCursorArray = (
+    element: string,
+    bounds: GirCursorBounds,
+    ownership: Ownership | undefined,
+    layout: ArrayLayout,
+): string =>
+    call("cursorArray", [
+        element,
+        `{ baseParamIndex: ${String(bounds.baseIndex)}, sizeParamIndex: ${String(bounds.lengthIndex)} }`,
+        ownership === undefined ? undefined : sourceStringLiteral(ownership),
+        arrayLayoutArg(ownership, layout),
+    ]);
+
+const tFixedArray = (element: string, length: number, ownership: Ownership | undefined, layout: ArrayLayout): string =>
     call("fixedArray", [
         element,
         String(length),
         ownership === undefined ? undefined : sourceStringLiteral(ownership),
-        elementSize === undefined ? undefined : String(elementSize),
+        arrayLayoutArg(ownership, layout),
     ]);
 
-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} }`,
     ]);
 };
 
@@ -270,6 +327,7 @@ export {
     tUint32,
     tInt32,
     tUint64,
+    tBiguint64,
     tGtype,
     tBuffer,
     tScalar,
@@ -284,13 +342,16 @@ export {
     tEnum,
     tFlags,
     tByteArray,
+    tNumericByteArray,
     tList,
     tArray,
     tSizedArray,
     tFixedArray,
+    tCursorArray,
     tCallback,
     tBind,
     tFn,
+    type ArrayLayout,
     type Ownership,
     type ScalarDescriptorName,
     type ListDescriptorName,