@gtkx/runtime 0.0.1 → 1.0.0-rc.1

package/dist/value.js

@@ -0,0 +1,227 @@
+import { alloc, getType, read, write } from "@gtkx/native";
+import { bind, createBindCache } from "./bind.js";
+import { arrayT, bigint64T, biguint64T, booleanT, boxedT, float32T, float64T, int32T, objectT, stringT, uint32T, uint64T, voidT, } from "./descriptors.js";
+import { LIB, PARAM_T, VALUE_SIZE, VALUE_T, VARIANT_T } from "./library.js";
+import { toNative } from "./native-value.js";
+import { getHandle, getWrapperClass, wrapHandle } from "./registry.js";
+import { getStrvType, resolveBoxedType, resolveDescriptorType, resolveFundamentalType, resolveType, TYPE_BOOLEAN, TYPE_BOXED, TYPE_DOUBLE, TYPE_ENUM, TYPE_FLAGS, TYPE_FLOAT, TYPE_GTYPE, TYPE_INT, TYPE_INT64, TYPE_INVALID, TYPE_OBJECT, TYPE_PARAM, TYPE_POINTER, TYPE_STRING, TYPE_UINT, TYPE_UINT64, TYPE_VARIANT, typeFundamental, typeName, } from "./type.js";
+const getBoxedTypeName = (type) => typeName(type) ?? "GBoxed";
+const newValue = () => alloc(VALUE_SIZE, "GValue");
+const setBoxedCache = createBindCache();
+const setStaticBoxedCache = createBindCache();
+const dupBoxedCache = createBindCache();
+const gValueInit = bind(LIB, "g_value_init", [VALUE_T, biguint64T], voidT);
+const gValueCopy = bind(LIB, "g_value_copy", [VALUE_T, VALUE_T], voidT);
+const bindValueType = (symbol, descriptor) => ({
+    set: bind(LIB, `g_value_set_${symbol}`, [VALUE_T, descriptor], voidT),
+    get: bind(LIB, `g_value_get_${symbol}`, [VALUE_T], descriptor),
+});
+const setBoxedBind = (name) => setBoxedCache(name, LIB, "g_value_set_boxed", [VALUE_T, boxedT(name, { sharedLibrary: LIB })], voidT);
+const setStaticBoxedBind = (name) => setStaticBoxedCache(name, LIB, "g_value_set_static_boxed", [VALUE_T, boxedT(name, { sharedLibrary: LIB })], voidT);
+const dupBoxedBind = (name) => dupBoxedCache(name, LIB, "g_value_dup_boxed", [VALUE_T], boxedT(name, { ownership: "full", sharedLibrary: LIB }));
+const booleanValueType = bindValueType("boolean", booleanT);
+const typeValueType = bindValueType("gtype", biguint64T);
+const intValueType = bindValueType("int", int32T);
+const uintValueType = bindValueType("uint", uint32T);
+const int64ValueType = bindValueType("int64", bigint64T);
+const uint64ValueType = bindValueType("uint64", biguint64T);
+const floatValueType = bindValueType("float", float32T);
+const doubleValueType = bindValueType("double", float64T);
+const stringValueType = bindValueType("string", stringT("borrowed"));
+const enumValueType = bindValueType("enum", int32T);
+const flagsValueType = bindValueType("flags", uint32T);
+const objectValueType = bindValueType("object", objectT("borrowed"));
+const paramValueType = bindValueType("param", PARAM_T);
+const variantValueType = bindValueType("variant", VARIANT_T);
+const pointerValueType = bindValueType("pointer", uint64T);
+const strvValueType = {
+    set: bind(LIB, "g_value_set_boxed", [VALUE_T, arrayT(stringT("borrowed"))], voidT),
+    get: bind(LIB, "g_value_get_boxed", [VALUE_T], arrayT(stringT("borrowed"))),
+};
+const boxedValueType = (type) => {
+    const name = getBoxedTypeName(type);
+    return { set: setBoxedBind(name), get: dupBoxedBind(name) };
+};
+const enumOrFlagsValueType = (type) => typeFundamental(type) === TYPE_FLAGS ? flagsValueType : enumValueType;
+const fundamentalValueType = (type) => {
+    switch (typeFundamental(type)) {
+        case TYPE_PARAM:
+            return paramValueType;
+        case TYPE_VARIANT:
+            return variantValueType;
+        case TYPE_BOXED:
+            return boxedValueType(type);
+        default:
+            throw new Error(`Unsupported fundamental type '${typeName(type) ?? String(type)}' for value`);
+    }
+};
+export function getValueType(value) {
+    return read(value, biguint64T, 0);
+}
+export function copyValue(dest, src) {
+    if (getValueType(dest) === TYPE_INVALID) {
+        gValueInit(dest, getValueType(src));
+    }
+    gValueCopy(src, dest);
+}
+const newTypedValue = (type) => {
+    const value = newValue();
+    gValueInit(value, type);
+    return value;
+};
+const newBoxedValue = (descriptor, boxed, resolveSetBind) => {
+    const type = resolveDescriptorType(descriptor);
+    const value = newTypedValue(type);
+    resolveSetBind(getBoxedTypeName(type))(value, getHandle(boxed));
+    return value;
+};
+/**
+ * Reads the boxed pointer out of a GValue and returns it wrapped in its registered
+ * class, or null when the value does not hold a boxed type.
+ */
+export function getBoxedValue(value) {
+    const type = getValueType(value);
+    if (typeFundamental(type) !== TYPE_BOXED)
+        return null;
+    const cls = getWrapperClass(type);
+    const boxed = dupBoxedBind(getBoxedTypeName(type))(value);
+    return wrapHandle(boxed, cls);
+}
+/** Stores a boxed object, or null, into a GValue that holds a boxed type. */
+export function setBoxedValue(value, boxed) {
+    const name = getBoxedTypeName(getValueType(value));
+    setBoxedBind(name)(value, boxed === null ? null : getHandle(boxed));
+}
+const resolveValueType = (descriptor) => {
+    if (descriptor.kind === "biguint64" && "type" in descriptor) {
+        return typeValueType;
+    }
+    switch (descriptor.kind) {
+        case "boolean":
+            return booleanValueType;
+        case "string":
+            return stringValueType;
+        case "int8":
+        case "int16":
+        case "int32":
+            return intValueType;
+        case "uint8":
+        case "uint16":
+        case "uint32":
+            return uintValueType;
+        case "int64":
+        case "bigint64":
+            return int64ValueType;
+        case "uint64":
+        case "biguint64":
+            return uint64ValueType;
+        case "float32":
+            return floatValueType;
+        case "float64":
+            return doubleValueType;
+        case "object":
+            return objectValueType;
+        case "enum":
+        case "flags":
+            return enumOrFlagsValueType(resolveType(descriptor.sharedLibrary, descriptor.getTypeFnName));
+        case "boxed":
+            return boxedValueType(resolveBoxedType(descriptor));
+        case "fundamental":
+            return fundamentalValueType(resolveFundamentalType(descriptor));
+        case "array":
+            if (descriptor.itemDescriptor.kind === "string" && descriptor.arrayKind === "array") {
+                return strvValueType;
+            }
+            throw new Error(`Unsupported array type ${descriptor.arrayKind} of ${descriptor.itemDescriptor.kind}`);
+        default:
+            throw new Error(`Unsupported type descriptor '${descriptor.kind}'`);
+    }
+};
+const resolveValueGetter = (fundamental) => {
+    switch (fundamental) {
+        case TYPE_BOOLEAN:
+            return booleanValueType.get;
+        case TYPE_GTYPE:
+            return typeValueType.get;
+        case TYPE_INT:
+            return intValueType.get;
+        case TYPE_UINT:
+            return uintValueType.get;
+        case TYPE_INT64:
+            return int64ValueType.get;
+        case TYPE_UINT64:
+            return uint64ValueType.get;
+        case TYPE_FLOAT:
+            return floatValueType.get;
+        case TYPE_DOUBLE:
+            return doubleValueType.get;
+        case TYPE_ENUM:
+            return enumValueType.get;
+        case TYPE_FLAGS:
+            return flagsValueType.get;
+        case TYPE_STRING:
+            return (value) => stringValueType.get(value) ?? null;
+        case TYPE_OBJECT:
+            return (value) => wrapHandle(objectValueType.get(value));
+        case TYPE_PARAM:
+            return (value) => wrapHandle(paramValueType.get(value), getWrapperClass(TYPE_PARAM));
+        case TYPE_VARIANT:
+            return (value) => wrapHandle(variantValueType.get(value), getWrapperClass(TYPE_VARIANT));
+        case TYPE_BOXED:
+            return getBoxedValue;
+        case TYPE_POINTER:
+            return (value) => {
+                if (pointerValueType.get(value)) {
+                    throw new Error("G_TYPE_POINTER non-null values cannot be marshalled to JS");
+                }
+                return null;
+            };
+        default:
+            return undefined;
+    }
+};
+export function toValue(descriptor, value) {
+    const isHandleKind = descriptor.kind === "object" || descriptor.kind === "boxed";
+    const nativeValue = isHandleKind
+        ? value == null
+            ? null
+            : getHandle(value)
+        : toNative(descriptor, value);
+    const type = descriptor.kind === "object"
+        ? nativeValue == null
+            ? TYPE_OBJECT
+            : getType(nativeValue)
+        : resolveDescriptorType(descriptor);
+    const gValue = newTypedValue(type);
+    resolveValueType(descriptor).set(gValue, nativeValue);
+    return gValue;
+}
+export function fromValue(value) {
+    const type = getValueType(value);
+    if (type === getStrvType())
+        return strvValueType.get(value);
+    const get = resolveValueGetter(typeFundamental(type));
+    if (get === undefined) {
+        throw new Error(`Unsupported type for fromValue: ${typeName(type) ?? String(type)}`);
+    }
+    return get(value);
+}
+export function newValueForDescriptor(descriptor) {
+    return newTypedValue(resolveDescriptorType(descriptor));
+}
+export function outValueForDescriptor(descriptor, initial) {
+    const storage = alloc(8);
+    write(storage, uint64T, 0, 0);
+    if (initial !== undefined)
+        write(storage, descriptor, 0, initial);
+    const value = newTypedValue(TYPE_POINTER);
+    pointerValueType.set(value, storage);
+    return { value, read: () => read(storage, descriptor, 0) };
+}
+export function outValueForBoxedDescriptor(descriptor, boxed) {
+    return newBoxedValue(descriptor, boxed, setBoxedBind);
+}
+export function inoutValueForBoxedDescriptor(descriptor, boxed) {
+    return newBoxedValue(descriptor, boxed, setStaticBoxedBind);
+}
+//# sourceMappingURL=value.js.map

package/dist/value.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"value.js","sourceRoot":"","sources":["../src/value.ts"],"names":[],"mappings":"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","sourcesContent":["import { alloc, type Descriptor, type ExternalObject, getType, type Handle, read, write } from \"@gtkx/native\";\nimport { bind, createBindCache } from \"./bind.js\";\nimport {\n    arrayT,\n    bigint64T,\n    biguint64T,\n    booleanT,\n    boxedT,\n    float32T,\n    float64T,\n    int32T,\n    objectT,\n    stringT,\n    uint32T,\n    uint64T,\n    voidT,\n} from \"./descriptors.js\";\nimport { LIB, PARAM_T, VALUE_SIZE, VALUE_T, VARIANT_T } from \"./library.js\";\nimport { toNative } from \"./native-value.js\";\nimport { getHandle, getWrapperClass, wrapHandle } from \"./registry.js\";\nimport {\n    getStrvType,\n    resolveBoxedType,\n    resolveDescriptorType,\n    resolveFundamentalType,\n    resolveType,\n    TYPE_BOOLEAN,\n    TYPE_BOXED,\n    TYPE_DOUBLE,\n    TYPE_ENUM,\n    TYPE_FLAGS,\n    TYPE_FLOAT,\n    TYPE_GTYPE,\n    TYPE_INT,\n    TYPE_INT64,\n    TYPE_INVALID,\n    TYPE_OBJECT,\n    TYPE_PARAM,\n    TYPE_POINTER,\n    TYPE_STRING,\n    TYPE_UINT,\n    TYPE_UINT64,\n    TYPE_VARIANT,\n    typeFundamental,\n    typeName,\n} from \"./type.js\";\n\ntype ValueType = {\n    set: (value: ExternalObject<Handle>, nativeValue: unknown) => void;\n    get: (value: ExternalObject<Handle>) => unknown;\n};\n\nconst getBoxedTypeName = (type: bigint): string => typeName(type) ?? \"GBoxed\";\nconst newValue = (): ExternalObject<Handle> => alloc(VALUE_SIZE, \"GValue\");\n\nconst setBoxedCache = createBindCache();\nconst setStaticBoxedCache = createBindCache();\nconst dupBoxedCache = createBindCache();\n\nconst gValueInit = bind(LIB, \"g_value_init\", [VALUE_T, biguint64T], voidT);\nconst gValueCopy = bind(LIB, \"g_value_copy\", [VALUE_T, VALUE_T], voidT);\n\nconst bindValueType = (symbol: string, descriptor: Descriptor): ValueType => ({\n    set: bind(LIB, `g_value_set_${symbol}`, [VALUE_T, descriptor], voidT),\n    get: bind(LIB, `g_value_get_${symbol}`, [VALUE_T], descriptor),\n});\n\nconst setBoxedBind = (name: string) =>\n    setBoxedCache(name, LIB, \"g_value_set_boxed\", [VALUE_T, boxedT(name, { sharedLibrary: LIB })], voidT);\n\nconst setStaticBoxedBind = (name: string) =>\n    setStaticBoxedCache(name, LIB, \"g_value_set_static_boxed\", [VALUE_T, boxedT(name, { sharedLibrary: LIB })], voidT);\n\nconst dupBoxedBind = (name: string) =>\n    dupBoxedCache(name, LIB, \"g_value_dup_boxed\", [VALUE_T], boxedT(name, { ownership: \"full\", sharedLibrary: LIB }));\n\nconst booleanValueType = bindValueType(\"boolean\", booleanT);\nconst typeValueType = bindValueType(\"gtype\", biguint64T);\nconst intValueType = bindValueType(\"int\", int32T);\nconst uintValueType = bindValueType(\"uint\", uint32T);\nconst int64ValueType = bindValueType(\"int64\", bigint64T);\nconst uint64ValueType = bindValueType(\"uint64\", biguint64T);\nconst floatValueType = bindValueType(\"float\", float32T);\nconst doubleValueType = bindValueType(\"double\", float64T);\nconst stringValueType = bindValueType(\"string\", stringT(\"borrowed\"));\nconst enumValueType = bindValueType(\"enum\", int32T);\nconst flagsValueType = bindValueType(\"flags\", uint32T);\nconst objectValueType = bindValueType(\"object\", objectT(\"borrowed\"));\nconst paramValueType = bindValueType(\"param\", PARAM_T);\nconst variantValueType = bindValueType(\"variant\", VARIANT_T);\nconst pointerValueType = bindValueType(\"pointer\", uint64T);\n\nconst strvValueType: ValueType = {\n    set: bind(LIB, \"g_value_set_boxed\", [VALUE_T, arrayT(stringT(\"borrowed\"))], voidT),\n    get: bind(LIB, \"g_value_get_boxed\", [VALUE_T], arrayT(stringT(\"borrowed\"))),\n};\n\nconst boxedValueType = (type: bigint): ValueType => {\n    const name = getBoxedTypeName(type);\n    return { set: setBoxedBind(name), get: dupBoxedBind(name) };\n};\n\nconst enumOrFlagsValueType = (type: bigint): ValueType =>\n    typeFundamental(type) === TYPE_FLAGS ? flagsValueType : enumValueType;\n\nconst fundamentalValueType = (type: bigint): ValueType => {\n    switch (typeFundamental(type)) {\n        case TYPE_PARAM:\n            return paramValueType;\n        case TYPE_VARIANT:\n            return variantValueType;\n        case TYPE_BOXED:\n            return boxedValueType(type);\n        default:\n            throw new Error(`Unsupported fundamental type '${typeName(type) ?? String(type)}' for value`);\n    }\n};\n\nexport function getValueType(value: ExternalObject<Handle>): bigint {\n    return read(value, biguint64T, 0) as bigint;\n}\n\nexport function copyValue(dest: ExternalObject<Handle>, src: ExternalObject<Handle>): void {\n    if (getValueType(dest) === TYPE_INVALID) {\n        gValueInit(dest, getValueType(src));\n    }\n    gValueCopy(src, dest);\n}\n\nconst newTypedValue = (type: bigint): ExternalObject<Handle> => {\n    const value = newValue();\n    gValueInit(value, type);\n    return value;\n};\n\nconst newBoxedValue = (\n    descriptor: Descriptor,\n    boxed: object,\n    resolveSetBind: (name: string) => ValueType[\"set\"],\n): ExternalObject<Handle> => {\n    const type = resolveDescriptorType(descriptor);\n    const value = newTypedValue(type);\n    resolveSetBind(getBoxedTypeName(type))(value, getHandle(boxed));\n    return value;\n};\n\n/**\n * Reads the boxed pointer out of a GValue and returns it wrapped in its registered\n * class, or null when the value does not hold a boxed type.\n */\nexport function getBoxedValue(value: ExternalObject<Handle>): object | null {\n    const type = getValueType(value);\n    if (typeFundamental(type) !== TYPE_BOXED) return null;\n    const cls = getWrapperClass(type);\n    const boxed = dupBoxedBind(getBoxedTypeName(type))(value) as ExternalObject<Handle> | null;\n    return wrapHandle(boxed, cls);\n}\n\n/** Stores a boxed object, or null, into a GValue that holds a boxed type. */\nexport function setBoxedValue(value: ExternalObject<Handle>, boxed: object | null): void {\n    const name = getBoxedTypeName(getValueType(value));\n    setBoxedBind(name)(value, boxed === null ? null : getHandle(boxed));\n}\n\nconst resolveValueType = (descriptor: Descriptor): ValueType => {\n    if (descriptor.kind === \"biguint64\" && \"type\" in descriptor) {\n        return typeValueType;\n    }\n    switch (descriptor.kind) {\n        case \"boolean\":\n            return booleanValueType;\n        case \"string\":\n            return stringValueType;\n        case \"int8\":\n        case \"int16\":\n        case \"int32\":\n            return intValueType;\n        case \"uint8\":\n        case \"uint16\":\n        case \"uint32\":\n            return uintValueType;\n        case \"int64\":\n        case \"bigint64\":\n            return int64ValueType;\n        case \"uint64\":\n        case \"biguint64\":\n            return uint64ValueType;\n        case \"float32\":\n            return floatValueType;\n        case \"float64\":\n            return doubleValueType;\n        case \"object\":\n            return objectValueType;\n        case \"enum\":\n        case \"flags\":\n            return enumOrFlagsValueType(resolveType(descriptor.sharedLibrary, descriptor.getTypeFnName));\n        case \"boxed\":\n            return boxedValueType(resolveBoxedType(descriptor));\n        case \"fundamental\":\n            return fundamentalValueType(resolveFundamentalType(descriptor));\n        case \"array\":\n            if (descriptor.itemDescriptor.kind === \"string\" && descriptor.arrayKind === \"array\") {\n                return strvValueType;\n            }\n            throw new Error(`Unsupported array type ${descriptor.arrayKind} of ${descriptor.itemDescriptor.kind}`);\n        default:\n            throw new Error(`Unsupported type descriptor '${descriptor.kind}'`);\n    }\n};\n\nconst resolveValueGetter = (fundamental: bigint): ((value: ExternalObject<Handle>) => unknown) | undefined => {\n    switch (fundamental) {\n        case TYPE_BOOLEAN:\n            return booleanValueType.get;\n        case TYPE_GTYPE:\n            return typeValueType.get;\n        case TYPE_INT:\n            return intValueType.get;\n        case TYPE_UINT:\n            return uintValueType.get;\n        case TYPE_INT64:\n            return int64ValueType.get;\n        case TYPE_UINT64:\n            return uint64ValueType.get;\n        case TYPE_FLOAT:\n            return floatValueType.get;\n        case TYPE_DOUBLE:\n            return doubleValueType.get;\n        case TYPE_ENUM:\n            return enumValueType.get;\n        case TYPE_FLAGS:\n            return flagsValueType.get;\n        case TYPE_STRING:\n            return (value) => stringValueType.get(value) ?? null;\n        case TYPE_OBJECT:\n            return (value) => wrapHandle(objectValueType.get(value) as ExternalObject<Handle> | null);\n        case TYPE_PARAM:\n            return (value) =>\n                wrapHandle(paramValueType.get(value) as ExternalObject<Handle> | null, getWrapperClass(TYPE_PARAM));\n        case TYPE_VARIANT:\n            return (value) =>\n                wrapHandle(variantValueType.get(value) as ExternalObject<Handle> | null, getWrapperClass(TYPE_VARIANT));\n        case TYPE_BOXED:\n            return getBoxedValue;\n        case TYPE_POINTER:\n            return (value) => {\n                if (pointerValueType.get(value)) {\n                    throw new Error(\"G_TYPE_POINTER non-null values cannot be marshalled to JS\");\n                }\n                return null;\n            };\n        default:\n            return undefined;\n    }\n};\n\nexport function toValue(descriptor: Descriptor, value: unknown): ExternalObject<Handle> {\n    const isHandleKind = descriptor.kind === \"object\" || descriptor.kind === \"boxed\";\n    const nativeValue = isHandleKind\n        ? value == null\n            ? null\n            : getHandle(value as object)\n        : toNative(descriptor, value);\n    const type =\n        descriptor.kind === \"object\"\n            ? nativeValue == null\n                ? TYPE_OBJECT\n                : getType(nativeValue as ExternalObject<Handle>)\n            : resolveDescriptorType(descriptor);\n    const gValue = newTypedValue(type);\n    resolveValueType(descriptor).set(gValue, nativeValue);\n    return gValue;\n}\n\nexport function fromValue(value: ExternalObject<Handle>): unknown {\n    const type = getValueType(value);\n    if (type === getStrvType()) return strvValueType.get(value);\n    const get = resolveValueGetter(typeFundamental(type));\n    if (get === undefined) {\n        throw new Error(`Unsupported type for fromValue: ${typeName(type) ?? String(type)}`);\n    }\n    return get(value);\n}\n\nexport function newValueForDescriptor(descriptor: Descriptor): ExternalObject<Handle> {\n    return newTypedValue(resolveDescriptorType(descriptor));\n}\n\nexport function outValueForDescriptor(\n    descriptor: Descriptor,\n    initial?: unknown,\n): { value: ExternalObject<Handle>; read: () => unknown } {\n    const storage = alloc(8);\n    write(storage, uint64T, 0, 0);\n    if (initial !== undefined) write(storage, descriptor, 0, initial);\n    const value = newTypedValue(TYPE_POINTER);\n    pointerValueType.set(value, storage);\n    return { value, read: () => read(storage, descriptor, 0) };\n}\n\nexport function outValueForBoxedDescriptor(descriptor: Descriptor, boxed: object): ExternalObject<Handle> {\n    return newBoxedValue(descriptor, boxed, setBoxedBind);\n}\n\nexport function inoutValueForBoxedDescriptor(descriptor: Descriptor, boxed: object): ExternalObject<Handle> {\n    return newBoxedValue(descriptor, boxed, setStaticBoxedBind);\n}\n"]}

package/package.json

@@ -1,16 +1,59 @@
 {
-    "name": "@gtkx/runtime",
-    "version": "0.0.1",
-    "description": "Runtime library for GTKX generated bindings. This name is reserved; the package ships with GTKX 1.0.",
-    "homepage": "https://gtkx.dev",
-    "license": "MPL-2.0",
-    "author": "Eugenio Depalo <eugeniodepalo@gmail.com>",
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/gtkx-org/gtkx.git",
-        "directory": "packages/runtime"
+  "name": "@gtkx/runtime",
+  "version": "1.0.0-rc.1",
+  "description": "FFI runtime the generated GTKX bindings call into: type descriptors, GValue marshalling, signals, GObject lifecycle",
+  "keywords": [
+    "gtkx",
+    "gtk",
+    "gtk4",
+    "ffi",
+    "bindings",
+    "typescript",
+    "linux",
+    "desktop"
+  ],
+  "homepage": "https://gtkx.dev",
+  "bugs": {
+    "url": "https://github.com/gtkx-org/gtkx/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gtkx-org/gtkx.git",
+    "directory": "packages/runtime"
+  },
+  "license": "MPL-2.0",
+  "author": "Eugenio Depalo <eugeniodepalo@gmail.com>",
+  "type": "module",
+  "sideEffects": true,
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     },
-    "publishConfig": {
-        "access": "public"
+    "./internal": {
+      "types": "./dist/internal.d.ts",
+      "default": "./dist/internal.js"
     }
-}
+  },
+  "files": [
+    "dist",
+    "src",
+    "!**/*.tsbuildinfo"
+  ],
+  "engines": {
+    "node": ">=24"
+  },
+  "dependencies": {
+    "@gtkx/native": "1.0.0-rc.1",
+    "@gtkx/utils": "1.0.0-rc.1"
+  },
+  "devDependencies": {
+    "@gtkx/vitest": "1.0.0-rc.1"
+  },
+  "scripts": {
+    "build": "tsc -b tsconfig.lib.json",
+    "typecheck": "tsc -b --emitDeclarationOnly",
+    "release": "tsx ../../scripts/release-package.ts"
+  }
+}

package/src/arg.ts

@@ -0,0 +1,13 @@
+import type { Descriptor } from "@gtkx/native";
+
+export type Arg = {
+    type: Descriptor;
+    direction?: "out" | "inout";
+    callerAllocated?: boolean;
+    consumed?: boolean;
+};
+
+export const isOutputArg = (arg: Arg): boolean => arg.direction !== undefined;
+export const isInoutArg = (arg: Arg): boolean => arg.direction === "inout";
+export const isCallerAllocatedArg = (arg: Arg): boolean => arg.callerAllocated === true;
+export const isRefArg = (arg: Arg): boolean => arg.direction !== undefined && arg.callerAllocated !== true;

package/src/bind.ts

@@ -0,0 +1,22 @@
+import { call, type Descriptor, bind as nativeBind } from "@gtkx/native";
+
+export function bind(
+    sharedLibrary: string,
+    symbol: string,
+    argDescriptors: Descriptor[],
+    returnDescriptor: Descriptor,
+): (...values: unknown[]) => unknown {
+    const descriptor = nativeBind(sharedLibrary, symbol, argDescriptors, returnDescriptor);
+    return (...values) => call(descriptor, values);
+}
+
+export function createBindCache(): (key: string, ...args: Parameters<typeof bind>) => ReturnType<typeof bind> {
+    const cache = new Map<string, ReturnType<typeof bind>>();
+    return (key, ...args) => {
+        const existing = cache.get(key);
+        if (existing !== undefined) return existing;
+        const bound = bind(...args);
+        cache.set(key, bound);
+        return bound;
+    };
+}

package/src/callback.ts

@@ -0,0 +1,87 @@
+import { copy, type Descriptor } from "@gtkx/native";
+import type { CallbackDescriptor } from "./descriptors.js";
+import { fromNative, toNative } from "./native-value.js";
+import { getHandle } from "./registry.js";
+import { splitTupleResult } from "./tuple.js";
+import { copyValue } from "./value.js";
+
+type Callback = (...args: unknown[]) => unknown;
+type CallbackReceiver = "this" | "emitter" | "none";
+type OutParam = { value: unknown; descriptor: Descriptor };
+
+type CallbackSpec = {
+    argDescriptors: Descriptor[];
+    returnDescriptor: Descriptor;
+    userDataIndex?: number;
+};
+
+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 partitionCallbackArgs = (
+    effectiveTypes: Descriptor[],
+    wrapped: unknown[],
+    start: number,
+): { 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]);
+        }
+    }
+    return { inputs, outParams };
+};
+
+const writeOutParams = (outParams: OutParam[], outValues: unknown[]): void => {
+    outParams.forEach((outParam, position) => {
+        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);
+        }
+    });
+};
+
+export 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);
+    };
+}