@gtkx/runtime 1.0.0-rc.4 → 1.1.0

package/dist/vfunc-call.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vfunc-call.js","sourceRoot":"","sources":["../src/vfunc-call.ts"],"names":[],"mappings":"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","sourcesContent":["import type { BindVfuncOptions } from \"@gtkx/native\";\nimport type { AnyClass } from \"@gtkx/utils\";\nimport { bindVfunc } from \"@gtkx/native\";\nimport { type Arg, isCallerAllocatedArg, requiresInputArg } from \"./arg.js\";\nimport { buildNativeArgTypes, fromNativeCallable } from \"./fn.js\";\nimport { toNative } from \"./native-value.js\";\nimport {\n    getClassType,\n    getHandle,\n    getInterfaceVfuncRegistry,\n    getVfuncRegistry,\n    instanceClassName,\n    resolveWrapperType,\n    type VfuncDescriptor,\n} from \"./registry.js\";\nimport { TYPE_INVALID, typeInterfaces, typeIsA, typeParent } from \"./type.js\";\nimport { type RefSeeds, seedsFor } from \"./vfunc-seeds.js\";\nimport { findClassVfuncDescriptor, findInterfaceVfuncDescriptor, vfuncArgs } from \"./vfunc.js\";\n\ntype Invoker = (instance: object, inputs: unknown[]) => unknown;\ntype InvokerCache = WeakMap<AnyClass, Map<string, Invoker>>;\ntype ResolvedSlot = { descriptor: VfuncDescriptor; interfaceType?: bigint };\n\nconst NO_BASELINE = -1;\n\nconst SEEDED_SLOTS: Record<string, RefSeeds> = {\n    \"LayoutManagerClass.measure\": new Map([[6, NO_BASELINE], [7, NO_BASELINE]]),\n    \"WidgetClass.measure\": new Map([[5, NO_BASELINE], [6, NO_BASELINE]]),\n};\n\nconst parentInvokers: InvokerCache = new WeakMap();\nconst vfuncInvokers: InvokerCache = new WeakMap();\n\nfunction toNativeInput(arg: Arg, input: unknown): unknown {\n    return isCallerAllocatedArg(arg) ? input : toNative(arg.type, input);\n}\n\nfunction bindOptionsFor(\n    slot: ResolvedSlot,\n    instanceType: bigint | undefined,\n    args: Arg[],\n    label: string,\n): BindVfuncOptions {\n    const { descriptor, interfaceType } = slot;\n\n    const options: BindVfuncOptions = {\n        byteOffset: descriptor.byteOffset,\n        label,\n        argDescriptors: buildNativeArgTypes(args, descriptor.canThrow === true),\n        returnDescriptor: descriptor.returnDescriptor,\n    };\n\n    if (descriptor.vtableSize !== undefined) {\n        options.vtableSize = descriptor.vtableSize;\n    }\n\n    if (instanceType !== undefined) {\n        options.instanceType = instanceType;\n    }\n\n    if (interfaceType !== undefined) {\n        options.interfaceType = interfaceType;\n    }\n\n    return options;\n}\n\nfunction buildInvoker(slot: ResolvedSlot, instanceType: bigint | undefined, caller: string): Invoker {\n    const { descriptor } = slot;\n    const args = vfuncArgs(descriptor);\n    const canThrow = descriptor.canThrow === true;\n    const label = `${descriptor.className}.${descriptor.vfuncName}`;\n    const [, ...inputArgs] = args.filter(requiresInputArg);\n    let pendingSeeds: RefSeeds | undefined;\n\n    const takeRefSeeds = (): RefSeeds | undefined => {\n        const seeds = pendingSeeds;\n        pendingSeeds = undefined;\n\n        return seeds;\n    };\n\n    const shaped = fromNativeCallable(\n        bindVfunc(bindOptionsFor(slot, instanceType, args, label)),\n        {\n            args,\n            returns: descriptor.returnDescriptor,\n            canThrow,\n        },\n        takeRefSeeds,\n    );\n\n    return (instance, inputs) => {\n        if (inputs.length !== inputArgs.length) {\n            throw new Error(\n                `${caller}: ${label} expects ${String(inputArgs.length)} arguments, ` +\n                `received ${String(inputs.length)}`,\n            );\n        }\n\n        const nativeInputs = inputArgs.map((arg, index) => toNativeInput(arg, inputs[index]));\n        pendingSeeds = SEEDED_SLOTS[label] ?? seedsFor(descriptor.argDescriptors, instance);\n\n        return shaped(getHandle(instance), ...nativeInputs);\n    };\n}\n\nfunction cachedInvoker(cache: InvokerCache, owner: AnyClass, key: string, build: () => Invoker): Invoker {\n    let byKey = cache.get(owner);\n\n    if (byKey === undefined) {\n        byKey = new Map();\n        cache.set(owner, byKey);\n    }\n\n    let invoker = byKey.get(key);\n\n    if (invoker === undefined) {\n        invoker = build();\n        byKey.set(key, invoker);\n    }\n\n    return invoker;\n}\n\nfunction resolveParentSlot(klass: AnyClass, parentType: bigint, methodName: string): ResolvedSlot | undefined {\n    const classDescriptor = findClassVfuncDescriptor(klass, methodName);\n\n    if (classDescriptor) {\n        return { descriptor: classDescriptor };\n    }\n\n    for (const interfaceType of typeInterfaces(parentType)) {\n        const descriptor = findInterfaceVfuncDescriptor(interfaceType, methodName);\n\n        if (descriptor) {\n            return { descriptor, interfaceType };\n        }\n    }\n\n    return undefined;\n}\n\nfunction resolveParentType(klass: AnyClass, methodName: string): bigint {\n    const gtype = getClassType(klass);\n\n    if (gtype === TYPE_INVALID) {\n        throw new Error(\n            `callParent: cannot call '${methodName}' because ${klass.name} was never passed to registerClass`,\n        );\n    }\n\n    return typeParent(gtype);\n}\n\nfunction buildParentInvoker(klass: AnyClass, methodName: string): Invoker {\n    const parentType = resolveParentType(klass, methodName);\n    const slot = resolveParentSlot(klass, parentType, methodName);\n\n    if (!slot) {\n        throw new Error(`callParent: ${klass.name} inherits no '${methodName}' vtable slot`);\n    }\n\n    return buildInvoker(slot, parentType, \"callParent\");\n}\n\n/**\n * Calls the implementation of a virtual function that the parent type of `klass` provides, so an\n * override can chain up to the behavior it replaces. `klass` is the class whose override is\n * running, named lexically rather than taken from `instance`, so each level of a hierarchy reaches\n * exactly one level up. Arguments and the return value follow the same convention the override\n * itself uses: pure out parameters are left out and returned instead, and a slot with several\n * outputs returns them as a tuple. Throws if `klass` was never registered, inherits no such slot,\n * or the parent type leaves the slot empty.\n *\n * @param klass The registered class whose override is chaining up.\n * @param methodName Name of the overridden method, such as `vfuncMeasure`.\n * @param instance The instance the override was invoked on.\n * @param inputs The arguments the override received.\n */\nfunction callParent(klass: AnyClass, methodName: string, instance: object, ...inputs: unknown[]): unknown {\n    const invoker = cachedInvoker(parentInvokers, klass, methodName, () => buildParentInvoker(klass, methodName));\n\n    return invoker(instance, inputs);\n}\n\nfunction resolveOwnerSlot(owner: AnyClass, key: string): ResolvedSlot {\n    const classDescriptor = getVfuncRegistry(owner)?.[key];\n\n    if (classDescriptor !== undefined) {\n        return { descriptor: classDescriptor };\n    }\n\n    const interfaceType = getClassType(owner);\n    const descriptor = getInterfaceVfuncRegistry(interfaceType)?.[key];\n\n    if (descriptor === undefined) {\n        throw new Error(`callVfunc: ${owner.name} declares no '${key}' vtable slot`);\n    }\n\n    return { descriptor, interfaceType };\n}\n\nfunction requiresDefaultVtable(slot: ResolvedSlot, instanceType: bigint): boolean {\n    return slot.interfaceType !== undefined && !typeIsA(instanceType, slot.interfaceType);\n}\n\nfunction resolveInstanceType(key: string, instance: object, slot: ResolvedSlot): bigint | undefined {\n    const instanceType = resolveWrapperType(instance);\n\n    if (instanceType === TYPE_INVALID) {\n        const name = instanceClassName(instance);\n        throw new Error(`callVfunc: cannot call '${key}' because ${name} descends from no registered wrapper class`);\n    }\n\n    return requiresDefaultVtable(slot, instanceType) ? undefined : instanceType;\n}\n\n/**\n * Calls the implementation of a virtual function a wrapper class or interface declares, backing the\n * `vfunc`-prefixed members the generated bindings emit. The slot is read from the nearest generated\n * wrapper class in the instance's class chain rather than from the instance's own type, so an\n * override reaching it through `super` runs the implementation it replaced instead of re-entering\n * itself. When that wrapper class does not carry the interface the slot belongs to, because a class\n * registered below it adopted the interface, the slot comes from the interface's own default vtable\n * instead, which holds exactly what the adopting class replaced. Arguments and the return value\n * follow the same convention an override uses: pure out parameters are left out and returned\n * instead, and a slot with several outputs returns them as a tuple. Throws if the owner declares no\n * such slot, the instance descends from no wrapper class, or the resolved vtable leaves the slot\n * empty.\n *\n * @param owner The wrapper class or interface declaring the slot.\n * @param key Name of the generated member, such as `vfuncMeasure`.\n * @param instance The instance to invoke the slot on.\n * @param inputs The arguments the slot receives.\n */\nfunction callVfunc(owner: AnyClass, key: string, instance: object, inputs: unknown[]): unknown {\n    const slot = resolveOwnerSlot(owner, key);\n    const instanceType = resolveInstanceType(key, instance, slot);\n\n    const invoker = cachedInvoker(vfuncInvokers, owner, `${key}:${String(instanceType)}`, () =>\n        buildInvoker(slot, instanceType, \"callVfunc\"));\n\n    return invoker(instance, inputs);\n}\n\nexport { callParent, callVfunc };\n"]}

package/dist/vfunc-seeds.d.ts

@@ -0,0 +1,12 @@
+import type { Descriptor } from "@gtkx/native";
+type RefSeeds = Map<number, unknown>;
+type SeedFrame = {
+    argDescriptors: Descriptor[];
+    instance: unknown;
+    seeds: RefSeeds;
+};
+declare const pushSeedFrame: (frame: SeedFrame) => void;
+declare const popSeedFrame: () => void;
+declare const seedsFor: (argDescriptors: Descriptor[], instance: unknown) => RefSeeds | undefined;
+export { popSeedFrame, pushSeedFrame, type RefSeeds, seedsFor };
+//# sourceMappingURL=vfunc-seeds.d.ts.map

package/dist/vfunc-seeds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vfunc-seeds.d.ts","sourceRoot":"","sources":["../src/vfunc-seeds.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C,KAAK,QAAQ,GAAG,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAErC,KAAK,SAAS,GAAG;IACb,cAAc,EAAE,UAAU,EAAE,CAAC;IAC7B,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,EAAE,QAAQ,CAAC;CACnB,CAAC;AAIF,QAAA,MAAM,aAAa,GAAI,OAAO,SAAS,KAAG,IAEzC,CAAC;AAEF,QAAA,MAAM,YAAY,QAAO,IAExB,CAAC;AAKF,QAAA,MAAM,QAAQ,GAAI,gBAAgB,UAAU,EAAE,EAAE,UAAU,OAAO,KAAG,QAAQ,GAAG,SAU9E,CAAC;AAEF,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,KAAK,QAAQ,EAAE,QAAQ,EAAE,CAAC"}

package/dist/vfunc-seeds.js

@@ -0,0 +1,19 @@
+const frames = [];
+const pushSeedFrame = (frame) => {
+    frames.push(frame);
+};
+const popSeedFrame = () => {
+    frames.pop();
+};
+const isMatchingFrame = (frame, argDescriptors, instance) => frame.argDescriptors === argDescriptors && frame.instance === instance;
+const seedsFor = (argDescriptors, instance) => {
+    for (let index = frames.length - 1; index >= 0; index--) {
+        const frame = frames[index];
+        if (frame !== undefined && isMatchingFrame(frame, argDescriptors, instance)) {
+            return frame.seeds;
+        }
+    }
+    return undefined;
+};
+export { popSeedFrame, pushSeedFrame, seedsFor };
+//# sourceMappingURL=vfunc-seeds.js.map

package/dist/vfunc-seeds.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vfunc-seeds.js","sourceRoot":"","sources":["../src/vfunc-seeds.ts"],"names":[],"mappings":"AAUA,MAAM,MAAM,GAAgB,EAAE,CAAC;AAE/B,MAAM,aAAa,GAAG,CAAC,KAAgB,EAAQ,EAAE;IAC7C,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AACvB,CAAC,CAAC;AAEF,MAAM,YAAY,GAAG,GAAS,EAAE;IAC5B,MAAM,CAAC,GAAG,EAAE,CAAC;AACjB,CAAC,CAAC;AAEF,MAAM,eAAe,GAAG,CAAC,KAAgB,EAAE,cAA4B,EAAE,QAAiB,EAAW,EAAE,CACnG,KAAK,CAAC,cAAc,KAAK,cAAc,IAAI,KAAK,CAAC,QAAQ,KAAK,QAAQ,CAAC;AAE3E,MAAM,QAAQ,GAAG,CAAC,cAA4B,EAAE,QAAiB,EAAwB,EAAE;IACvF,KAAK,IAAI,KAAK,GAAG,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC;QACtD,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QAE5B,IAAI,KAAK,KAAK,SAAS,IAAI,eAAe,CAAC,KAAK,EAAE,cAAc,EAAE,QAAQ,CAAC,EAAE,CAAC;YAC1E,OAAO,KAAK,CAAC,KAAK,CAAC;QACvB,CAAC;IACL,CAAC;IAED,OAAO,SAAS,CAAC;AACrB,CAAC,CAAC;AAEF,OAAO,EAAE,YAAY,EAAE,aAAa,EAAiB,QAAQ,EAAE,CAAC","sourcesContent":["import type { Descriptor } from \"@gtkx/native\";\n\ntype RefSeeds = Map<number, unknown>;\n\ntype SeedFrame = {\n    argDescriptors: Descriptor[];\n    instance: unknown;\n    seeds: RefSeeds;\n};\n\nconst frames: SeedFrame[] = [];\n\nconst pushSeedFrame = (frame: SeedFrame): void => {\n    frames.push(frame);\n};\n\nconst popSeedFrame = (): void => {\n    frames.pop();\n};\n\nconst isMatchingFrame = (frame: SeedFrame, argDescriptors: Descriptor[], instance: unknown): boolean =>\n    frame.argDescriptors === argDescriptors && frame.instance === instance;\n\nconst seedsFor = (argDescriptors: Descriptor[], instance: unknown): RefSeeds | undefined => {\n    for (let index = frames.length - 1; index >= 0; index--) {\n        const frame = frames[index];\n\n        if (frame !== undefined && isMatchingFrame(frame, argDescriptors, instance)) {\n            return frame.seeds;\n        }\n    }\n\n    return undefined;\n};\n\nexport { popSeedFrame, pushSeedFrame, type RefSeeds, seedsFor };\n"]}

package/dist/vfunc.d.ts

@@ -0,0 +1,8 @@
+import { type AnyClass } from "@gtkx/utils";
+import type { Arg } from "./arg.js";
+import { type VfuncDescriptor } from "./registry.js";
+declare function findClassVfuncDescriptor(klass: AnyClass, methodName: string): VfuncDescriptor | null;
+declare function findInterfaceVfuncDescriptor(interfaceGtype: bigint, methodName: string): VfuncDescriptor | undefined;
+declare function vfuncArgs(descriptor: VfuncDescriptor): Arg[];
+export { findClassVfuncDescriptor, findInterfaceVfuncDescriptor, vfuncArgs };
+//# sourceMappingURL=vfunc.d.ts.map

package/dist/vfunc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vfunc.d.ts","sourceRoot":"","sources":["../src/vfunc.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,QAAQ,EAAkC,MAAM,aAAa,CAAC;AAC5E,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAGpC,OAAO,EAA+C,KAAK,eAAe,EAAE,MAAM,eAAe,CAAC;AAElG,iBAAS,wBAAwB,CAAC,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAE7F;AAED,iBAAS,4BAA4B,CAAC,cAAc,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS,CAE7G;AAkBD,iBAAS,SAAS,CAAC,UAAU,EAAE,eAAe,GAAG,GAAG,EAAE,CAIrD;AAED,OAAO,EAAE,wBAAwB,EAAE,4BAA4B,EAAE,SAAS,EAAE,CAAC"}

package/dist/vfunc.js

@@ -0,0 +1,29 @@
+import { getParentClass, walkClassChain } from "@gtkx/utils";
+import { isCallerAllocatedOut } from "./callback.js";
+import { foldedLengthSources } from "./folded-lengths.js";
+import { getInterfaceVfuncRegistry, getVfuncRegistry } from "./registry.js";
+function findClassVfuncDescriptor(klass, methodName) {
+    return walkClassChain(getParentClass(klass), (cls) => getVfuncRegistry(cls)?.[methodName]) ?? null;
+}
+function findInterfaceVfuncDescriptor(interfaceGtype, methodName) {
+    return getInterfaceVfuncRegistry(interfaceGtype)?.[methodName];
+}
+function vfuncArg(descriptor, isFoldedLength) {
+    if (descriptor.kind === "ref") {
+        return {
+            type: descriptor.innerDescriptor,
+            direction: descriptor.inout === true ? "inout" : "out",
+            isConsumed: isFoldedLength,
+        };
+    }
+    if (isCallerAllocatedOut(descriptor)) {
+        return { type: descriptor, direction: "out", isCallerAllocated: true };
+    }
+    return { type: descriptor };
+}
+function vfuncArgs(descriptor) {
+    const lengths = foldedLengthSources(descriptor);
+    return descriptor.argDescriptors.map((argDescriptor, index) => vfuncArg(argDescriptor, lengths.has(index)));
+}
+export { findClassVfuncDescriptor, findInterfaceVfuncDescriptor, vfuncArgs };
+//# sourceMappingURL=vfunc.js.map

package/dist/vfunc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vfunc.js","sourceRoot":"","sources":["../src/vfunc.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,cAAc,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAE5E,OAAO,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EAAE,yBAAyB,EAAE,gBAAgB,EAAwB,MAAM,eAAe,CAAC;AAElG,SAAS,wBAAwB,CAAC,KAAe,EAAE,UAAkB;IACjE,OAAO,cAAc,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,gBAAgB,CAAC,GAAG,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC,IAAI,IAAI,CAAC;AACvG,CAAC;AAED,SAAS,4BAA4B,CAAC,cAAsB,EAAE,UAAkB;IAC5E,OAAO,yBAAyB,CAAC,cAAc,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC;AACnE,CAAC;AAED,SAAS,QAAQ,CAAC,UAAsB,EAAE,cAAuB;IAC7D,IAAI,UAAU,CAAC,IAAI,KAAK,KAAK,EAAE,CAAC;QAC5B,OAAO;YACH,IAAI,EAAE,UAAU,CAAC,eAAe;YAChC,SAAS,EAAE,UAAU,CAAC,KAAK,KAAK,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK;YACtD,UAAU,EAAE,cAAc;SAC7B,CAAC;IACN,CAAC;IAED,IAAI,oBAAoB,CAAC,UAAU,CAAC,EAAE,CAAC;QACnC,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,KAAK,EAAE,iBAAiB,EAAE,IAAI,EAAE,CAAC;IAC3E,CAAC;IAED,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC;AAChC,CAAC;AAED,SAAS,SAAS,CAAC,UAA2B;IAC1C,MAAM,OAAO,GAAG,mBAAmB,CAAC,UAAU,CAAC,CAAC;IAEhD,OAAO,UAAU,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,aAAa,EAAE,KAAK,EAAE,EAAE,CAAC,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AAChH,CAAC;AAED,OAAO,EAAE,wBAAwB,EAAE,4BAA4B,EAAE,SAAS,EAAE,CAAC","sourcesContent":["import type { Descriptor } from \"@gtkx/native\";\nimport { type AnyClass, getParentClass, walkClassChain } from \"@gtkx/utils\";\nimport type { Arg } from \"./arg.js\";\nimport { isCallerAllocatedOut } from \"./callback.js\";\nimport { foldedLengthSources } from \"./folded-lengths.js\";\nimport { getInterfaceVfuncRegistry, getVfuncRegistry, type VfuncDescriptor } from \"./registry.js\";\n\nfunction findClassVfuncDescriptor(klass: AnyClass, methodName: string): VfuncDescriptor | null {\n    return walkClassChain(getParentClass(klass), (cls) => getVfuncRegistry(cls)?.[methodName]) ?? null;\n}\n\nfunction findInterfaceVfuncDescriptor(interfaceGtype: bigint, methodName: string): VfuncDescriptor | undefined {\n    return getInterfaceVfuncRegistry(interfaceGtype)?.[methodName];\n}\n\nfunction vfuncArg(descriptor: Descriptor, isFoldedLength: boolean): Arg {\n    if (descriptor.kind === \"ref\") {\n        return {\n            type: descriptor.innerDescriptor,\n            direction: descriptor.inout === true ? \"inout\" : \"out\",\n            isConsumed: isFoldedLength,\n        };\n    }\n\n    if (isCallerAllocatedOut(descriptor)) {\n        return { type: descriptor, direction: \"out\", isCallerAllocated: true };\n    }\n\n    return { type: descriptor };\n}\n\nfunction vfuncArgs(descriptor: VfuncDescriptor): Arg[] {\n    const lengths = foldedLengthSources(descriptor);\n\n    return descriptor.argDescriptors.map((argDescriptor, index) => vfuncArg(argDescriptor, lengths.has(index)));\n}\n\nexport { findClassVfuncDescriptor, findInterfaceVfuncDescriptor, vfuncArgs };\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gtkx/runtime",
-  "version": "1.0.0-rc.4",
+  "version": "1.1.0",
   "description": "FFI runtime the generated GTKX bindings call into: type descriptors, GValue marshalling, signals, GObject lifecycle",
   "keywords": [
     "gtkx",
@@ -41,15 +41,25 @@
     "src",
     "!**/*.tsbuildinfo"
   ],
+  "nx": {
+    "targets": {
+      "lint": {
+        "options": {
+          "cwd": ".",
+          "command": "eslint {projectRoot}"
+        }
+      }
+    }
+  },
   "engines": {
     "node": ">=24"
   },
   "dependencies": {
-    "@gtkx/native": "1.0.0-rc.4",
-    "@gtkx/utils": "1.0.0-rc.4"
+    "@gtkx/native": "1.1.0",
+    "@gtkx/utils": "1.1.0"
   },
   "devDependencies": {
-    "@gtkx/vitest": "1.0.0-rc.4"
+    "@gtkx/vitest": "1.1.0"
   },
   "scripts": {
     "release": "tsx ../../scripts/release-package.ts"

package/src/application-class.ts

@@ -0,0 +1,126 @@
+import { type AnyClass, getOrInsert } from "@gtkx/utils";
+import { releaseDefaultApplication } from "./default-application.js";
+import { registerClass } from "./register-class.js";
+import { getClassType } from "./registry.js";
+import { typeName } from "./type.js";
+import { callParent } from "./vfunc-call.js";
+
+type CommandLineResult = [boolean, string[], number];
+
+/**
+ * The GIO application surface {@link createApplication} builds on, which `Gio.Application` and
+ * every subclass of it satisfies structurally.
+ */
+type CommandLineApplication = {
+    /** Marks the application as quitting, so GLib's own `run` returns without driving a main loop. */
+    quit(): void;
+};
+
+type LocalCommandLineApplication = {
+    runLocalCommandLine(argv: string[]): CommandLineResult;
+};
+
+type ShutdownApplication = {
+    run(argv: string[]): number;
+};
+
+/** An application class together with the construct properties it accepts. */
+type ApplicationClass<T extends CommandLineApplication, P> = AnyClass<T> & (new (props: P) => T);
+
+const derivedClasses: WeakMap<AnyClass, AnyClass> = new WeakMap();
+const derivedApplicationClasses: Set<AnyClass> = new Set();
+const quitApplications: WeakSet<object> = new WeakSet();
+const shuttingDownApplications: WeakSet<object> = new WeakSet();
+
+const derivedTypeName = (base: AnyClass): string => `Gtkx${typeName(getClassType(base)) ?? base.name}`;
+
+const buildApplicationClass = (base: AnyClass<CommandLineApplication>): AnyClass<CommandLineApplication> => {
+    class DerivedApplication extends base {
+        runLocalCommandLine(argv: string[]): CommandLineResult {
+            return this.vfuncLocalCommandLine(argv);
+        }
+
+        protected vfuncLocalCommandLine(argv: string[]): CommandLineResult {
+            if (shuttingDownApplications.has(this)) {
+                this.quit();
+
+                return [true, argv, 0];
+            }
+
+            return callParent(DerivedApplication, "vfuncLocalCommandLine", this, argv) as CommandLineResult;
+        }
+
+        protected vfuncNameLost(): boolean {
+            quitApplications.add(this);
+
+            return callParent(DerivedApplication, "vfuncNameLost", this) as boolean;
+        }
+
+        override quit(): void {
+            quitApplications.add(this);
+            super.quit();
+        }
+    }
+
+    const derived = registerClass(DerivedApplication, { typeName: derivedTypeName(base) });
+    derivedApplicationClasses.add(derived);
+
+    return derived;
+};
+
+const isDerivedApplication = (application: object): application is LocalCommandLineApplication => {
+    for (const derived of derivedApplicationClasses) {
+        if (application instanceof derived) {
+            return true;
+        }
+    }
+
+    return false;
+};
+
+const shutDownThroughRun = (application: ShutdownApplication): void => {
+    if (!isDerivedApplication(application) || quitApplications.has(application)) {
+        return;
+    }
+
+    shuttingDownApplications.add(application);
+
+    try {
+        application.run([]);
+    } finally {
+        shuttingDownApplications.delete(application);
+    }
+};
+
+const deriveApplicationClass = <T extends CommandLineApplication>(base: AnyClass<T>): AnyClass<T> =>
+    getOrInsert(derivedClasses, base, () => buildApplicationClass(base)) as AnyClass<T>;
+
+/**
+ * Constructs an application GTKX can shut down. GLib parses an application's command line at most
+ * once per instance and crashes on a second parse, so {@link runApplication} and
+ * {@link quitApplication} only accept an application built here.
+ *
+ * Whatever `g_application_constructed` assigned to the process-wide default is handed straight back,
+ * so merely building an application never makes it what `Gio.Application.getDefault()` returns.
+ * {@link runApplication} is the only place that claims that default, which keeps it pointing at an
+ * application GTKX has actually started rather than at one that is still unregistered.
+ *
+ * @param base The application class to construct, such as `Gtk.Application`.
+ * @param props Construct properties, passed through unchanged.
+ * @returns An instance of a class derived from `base`, registered once per base class as its own GType.
+ */
+const createApplication = <T extends CommandLineApplication, P>(base: ApplicationClass<T, P>, props: P): T => {
+    const application = new (deriveApplicationClass(base) as new (props: P) => T)(props);
+    releaseDefaultApplication(application);
+
+    return application;
+};
+
+export {
+    createApplication,
+    isDerivedApplication,
+    shutDownThroughRun,
+    type ApplicationClass,
+    type CommandLineApplication,
+    type LocalCommandLineApplication,
+};

package/src/arg.ts

@@ -16,5 +16,6 @@ const isOutputArg = (arg: Arg): boolean => arg.direction !== undefined;
 const isInoutArg = (arg: Arg): boolean => arg.direction === "inout";
 const isCallerAllocatedArg = (arg: Arg): boolean => arg.isCallerAllocated === true;
 const isRefArg = (arg: Arg): boolean => arg.direction !== undefined && arg.isCallerAllocated !== true;
+const requiresInputArg = (arg: Arg): boolean => !isRefArg(arg) || isInoutArg(arg);
 
-export { isOutputArg, isInoutArg, isCallerAllocatedArg, isRefArg, type Arg };
+export { isOutputArg, isInoutArg, isCallerAllocatedArg, isRefArg, requiresInputArg, type Arg };

package/src/bind.ts

@@ -1,5 +1,16 @@
 import { call, type Descriptor, bind as nativeBind } from "@gtkx/native";
 
+/**
+ * Precompiles a call to a C function, marshalling the values it is given through the argument
+ * descriptors and the result through the return one. The symbol is resolved in the shared library
+ * on the first call.
+ *
+ * @param sharedLibrary The shared library to resolve the symbol in.
+ * @param symbol The name of the C function to bind.
+ * @param argDescriptors Describe the C arguments, in declaration order.
+ * @param returnDescriptor Describes the C return value.
+ * @returns A function calling the bound symbol.
+ */
 function bind(
     sharedLibrary: string,
     symbol: string,

package/src/callback.ts

@@ -1,13 +1,19 @@
 import { copy, type Descriptor } from "@gtkx/native";
 import type { CallbackDescriptor, RefDescriptor } from "./descriptors.js";
+import { foldedLengthSources, type LengthSource, type LengthSources } from "./folded-lengths.js";
 import { fromNative, toNative } from "./native-value.js";
 import { getHandle } from "./registry.js";
 import { splitTupleResult } from "./tuple.js";
 import { copyValue } from "./value.js";
+import { popSeedFrame, pushSeedFrame, type RefSeeds } from "./vfunc-seeds.js";
 
 type Callback = (...args: unknown[]) => unknown;
-type CallbackReceiver = "this" | "emitter" | "none";
-type OutParam = { value: unknown; descriptor: Descriptor };
+type CallbackKind = "vfunc" | "signal" | "callback";
+type CallbackTraits = { isInstanceBound: boolean; hasInstanceArg: boolean; hasFoldedLengths: boolean };
+type OutParam = { value: unknown; descriptor: Descriptor; argIndex: number };
+type LengthLink = { target: OutParam; sources: LengthSource[] };
+type OutParamGroups = { lengthLinks: LengthLink[]; valueParams: OutParam[] };
+type OutValues = Map<number, unknown>;
 
 type CallbackSpec = {
     argDescriptors: Descriptor[];
@@ -19,8 +25,18 @@ type CallbackPlan = {
     fn: Callback;
     effectiveTypes: Descriptor[];
     returnDescriptor: Descriptor;
+    hasPrimary: boolean;
     start: number;
-    receiver: CallbackReceiver;
+    isInstanceBound: boolean;
+    lengthSources: LengthSources;
+    hasOutParams: boolean;
+    hasRefOutParams: boolean;
+};
+
+const CALLBACK_TRAITS: Record<CallbackKind, CallbackTraits> = {
+    callback: { isInstanceBound: false, hasInstanceArg: false, hasFoldedLengths: true },
+    signal: { isInstanceBound: false, hasInstanceArg: true, hasFoldedLengths: false },
+    vfunc: { isInstanceBound: true, hasInstanceArg: true, hasFoldedLengths: true },
 };
 
 const fillCallerAllocatedBuffer = (descriptor: Descriptor, target: object, source: object): void => {
@@ -46,23 +62,23 @@ const collectRefArg = (
     descriptor: RefDescriptor,
     wrappedValue: unknown,
     inputs: unknown[],
-    outParams: OutParam[],
+    out: { params: OutParam[]; argIndex: number },
 ): void => {
     if (descriptor.inout === true) {
         inputs.push((wrappedValue as { value: unknown }).value);
     }
 
-    outParams.push({ value: wrappedValue, descriptor });
+    out.params.push({ value: wrappedValue, descriptor, argIndex: out.argIndex });
 };
 
 const collectCallbackArg = (
     descriptor: Descriptor | undefined,
     wrappedValue: unknown,
     inputs: unknown[],
-    outParams: OutParam[],
+    out: { params: OutParam[]; argIndex: number },
 ): void => {
     if (descriptor?.kind === "ref") {
-        collectRefArg(descriptor, wrappedValue, inputs, outParams);
+        collectRefArg(descriptor, wrappedValue, inputs, out);
 
         return;
     }
@@ -70,7 +86,7 @@ const collectCallbackArg = (
     inputs.push(wrappedValue);
 
     if (descriptor !== undefined && isCallerAllocatedOut(descriptor)) {
-        outParams.push({ value: wrappedValue, descriptor });
+        out.params.push({ value: wrappedValue, descriptor, argIndex: out.argIndex });
     }
 };
 
@@ -80,47 +96,167 @@ const partitionCallbackArgs = (
     start: number,
 ): { inputs: unknown[]; outParams: OutParam[] } => {
     const inputs: unknown[] = [];
-    const outParams: OutParam[] = [];
+    const params: OutParam[] = [];
+    const collected = { params, argIndex: start };
 
     for (let i = start; i < effectiveTypes.length; i++) {
-        collectCallbackArg(effectiveTypes[i], wrapped[i], inputs, outParams);
+        collected.argIndex = i;
+        collectCallbackArg(effectiveTypes[i], wrapped[i], inputs, collected);
+    }
+
+    return { inputs, outParams: params };
+};
+
+const hasOutParamArg = (descriptor: Descriptor | undefined): boolean =>
+    descriptor !== undefined && (descriptor.kind === "ref" || isCallerAllocatedOut(descriptor));
+
+const hasRefOutParamArg = (descriptor: Descriptor | undefined): boolean =>
+    descriptor?.kind === "ref" && descriptor.inout !== true;
+
+const haveOutParamArgs = (effectiveTypes: Descriptor[], start: number): boolean =>
+    effectiveTypes.slice(start).some((descriptor) => hasOutParamArg(descriptor));
+
+const haveRefOutParamArgs = (effectiveTypes: Descriptor[], start: number): boolean =>
+    effectiveTypes.slice(start).some((descriptor) => hasRefOutParamArg(descriptor));
+
+const groupOutParams = (outParams: OutParam[], lengthSources: LengthSources): OutParamGroups => {
+    const groups: OutParamGroups = { lengthLinks: [], valueParams: [] };
+
+    for (const outParam of outParams) {
+        const sources = lengthSources.get(outParam.argIndex);
+
+        if (sources === undefined) {
+            groups.valueParams.push(outParam);
+        } else {
+            groups.lengthLinks.push({ target: outParam, sources });
+        }
+    }
+
+    return groups;
+};
+
+const getLength = (value: unknown): number => {
+    const length = (value as { length?: unknown } | null | undefined)?.length;
+
+    return typeof length === "number" ? length : 0;
+};
+
+const lengthSourceValue = (source: LengthSource, outValues: OutValues, primary: unknown): unknown =>
+    source.kind === "return" ? primary : outValues.get(source.argIndex);
+
+const foldedLength = (sources: LengthSource[], outValues: OutValues, primary: unknown): number =>
+    Math.min(...sources.map((source) => getLength(lengthSourceValue(source, outValues, primary))));
+
+const resolveOutValues = (groups: OutParamGroups, values: unknown[], primary: unknown): OutValues => {
+    const outValues: OutValues = new Map();
+
+    for (const [position, outParam] of groups.valueParams.entries()) {
+        outValues.set(outParam.argIndex, values[position]);
+    }
+
+    for (const link of groups.lengthLinks) {
+        outValues.set(link.target.argIndex, foldedLength(link.sources, outValues, primary));
     }
 
-    return { inputs, outParams };
+    return outValues;
 };
 
-const writeOutParams = (outParams: OutParam[], outValues: unknown[]): void => {
-    for (const [position, outParam] of outParams.entries()) {
-        const outValue = outValues[position];
+const writeOutParams = (outParams: OutParam[], outValues: OutValues): void => {
+    for (const outParam of outParams) {
+        const { descriptor } = outParam;
+        const outValue = outValues.get(outParam.argIndex);
 
-        if (outParam.descriptor.kind === "ref") {
-            (outParam.value as { value: unknown }).value = outValue;
+        if (descriptor.kind === "ref") {
+            (outParam.value as { value: unknown }).value = toNative(descriptor.innerDescriptor, outValue);
         } else if (outValue != null && outParam.value != null) {
-            fillCallerAllocatedBuffer(outParam.descriptor, outParam.value, outValue);
+            fillCallerAllocatedBuffer(descriptor, outParam.value, outValue);
         }
     }
 };
 
-const getThisArg = (receiver: CallbackReceiver, wrapped: unknown[]): unknown =>
-    receiver === "this" ? (wrapped[0] ?? null) : null;
+const collectRefSeeds = (outParams: OutParam[]): RefSeeds => {
+    const seeds: RefSeeds = new Map();
+
+    for (const outParam of outParams) {
+        const seed = (outParam.value as { value?: unknown } | null)?.value;
+
+        if (seed != null && hasRefOutParamArg(outParam.descriptor)) {
+            seeds.set(outParam.argIndex, seed);
+        }
+    }
+
+    return seeds;
+};
+
+const applyCallback = (plan: CallbackPlan, thisArg: unknown, inputs: unknown[], outParams: OutParam[]): unknown => {
+    if (!plan.hasRefOutParams) {
+        return plan.fn.apply(thisArg, inputs);
+    }
+
+    pushSeedFrame({ argDescriptors: plan.effectiveTypes, instance: thisArg, seeds: collectRefSeeds(outParams) });
+
+    try {
+        return plan.fn.apply(thisArg, inputs);
+    } finally {
+        popSeedFrame();
+    }
+};
+
+const getThisArg = (isInstanceBound: boolean, wrapped: unknown[]): unknown =>
+    isInstanceBound ? (wrapped[0] ?? null) : null;
+
+const wrapCallbackArgs = (effectiveTypes: Descriptor[], rawArgs: unknown[]): void => {
+    let index = 0;
+
+    for (const descriptor of effectiveTypes) {
+        rawArgs[index] = fromNative(descriptor, rawArgs[index]);
+        index += 1;
+    }
+};
+
+const trimCallbackInputs = (plan: CallbackPlan, wrapped: unknown[]): unknown[] => {
+    const count = plan.effectiveTypes.length;
+
+    if (wrapped.length > count) {
+        wrapped.length = count;
+    }
+
+    for (let index = 0; index < plan.start; index++) {
+        wrapped.shift();
+    }
+
+    return wrapped;
+};
+
+const nativeReturn = (plan: CallbackPlan, primary: unknown): unknown =>
+    toNative(plan.returnDescriptor, plan.hasPrimary ? primary : undefined);
 
 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);
+    const { effectiveTypes } = plan;
+    wrapCallbackArgs(effectiveTypes, rawArgs);
+    const thisArg = getThisArg(plan.isInstanceBound, rawArgs);
+
+    if (!plan.hasOutParams) {
+        return nativeReturn(plan, plan.fn.apply(thisArg, trimCallbackInputs(plan, rawArgs)));
+    }
+
+    const { inputs, outParams } = partitionCallbackArgs(effectiveTypes, rawArgs, plan.start);
+    const result = applyCallback(plan, thisArg, inputs, outParams);
 
     if (outParams.length === 0) {
-        return toNative(returnDescriptor, result);
+        return nativeReturn(plan, result);
     }
 
-    const { primary, outValues } = splitTupleResult(result, returnDescriptor.kind !== "void", outParams.length);
-    writeOutParams(outParams, outValues);
+    const groups = groupOutParams(outParams, plan.lengthSources);
+    const { primary, outValues } = splitTupleResult(result, plan.hasPrimary, groups.valueParams.length);
+    writeOutParams(outParams, resolveOutValues(groups, outValues, primary));
 
-    return toNative(returnDescriptor, primary);
+    return nativeReturn(plan, primary);
 };
 
+const planLengthSources = (spec: CallbackSpec, hasFoldedLengths: boolean): LengthSources =>
+    hasFoldedLengths ? foldedLengthSources(spec) : new Map<number, LengthSource[]>();
+
 const getEffectiveTypes = (spec: CallbackSpec): Descriptor[] => {
     const { userDataIndex } = spec;
 
@@ -132,18 +268,26 @@ const getEffectiveTypes = (spec: CallbackSpec): Descriptor[] => {
 };
 
 const wrapCallbackValue = (spec: CallbackDescriptor, callback: unknown): unknown =>
-    callback == null ? callback : wrapCallback(callback as Callback, spec, "none");
+    callback == null ? callback : wrapCallback(callback as Callback, spec, "callback");
+
+function wrapCallback(fn: Callback, spec: CallbackSpec, kind: CallbackKind): Callback {
+    const effectiveTypes = getEffectiveTypes(spec);
+    const { isInstanceBound, hasInstanceArg, hasFoldedLengths } = CALLBACK_TRAITS[kind];
+    const start = hasInstanceArg ? 1 : 0;
 
-function wrapCallback(fn: Callback, spec: CallbackSpec, receiver: CallbackReceiver): Callback {
     const plan: CallbackPlan = {
         fn,
-        effectiveTypes: getEffectiveTypes(spec),
+        effectiveTypes,
         returnDescriptor: spec.returnDescriptor,
-        start: receiver === "none" ? 0 : 1,
-        receiver,
+        hasPrimary: spec.returnDescriptor.kind !== "void",
+        start,
+        isInstanceBound,
+        lengthSources: planLengthSources(spec, hasFoldedLengths),
+        hasOutParams: haveOutParamArgs(effectiveTypes, start),
+        hasRefOutParams: haveRefOutParamArgs(effectiveTypes, start),
     };
 
     return (...rawArgs: unknown[]): unknown => runCallback(plan, rawArgs);
 }
 
-export { wrapCallbackValue, wrapCallback };
+export { isCallerAllocatedOut, wrapCallbackValue, wrapCallback };