@gtkx/runtime 1.0.0 → 1.1.0

package/src/param-spec.ts

@@ -13,6 +13,7 @@ import {
     TYPE_ENUM,
     TYPE_FLAGS,
     TYPE_FLOAT,
+    TYPE_GTYPE,
     TYPE_INT,
     TYPE_INT64,
     TYPE_INTERFACE,
@@ -51,7 +52,6 @@ const UINT32_MAXIMUM = 4_294_967_295;
 const INT64_MINIMUM = -(2n ** 63n);
 const INT64_MAXIMUM = 2n ** 63n - 1n;
 const UINT64_MAXIMUM = 2n ** 64n - 1n;
-const FLOAT_MAXIMUM = 3.4028234663852886e38;
 
 const WRAPPED_FUNDAMENTALS: Set<bigint> = new Set([
     TYPE_BOXED,
@@ -61,6 +61,8 @@ const WRAPPED_FUNDAMENTALS: Set<bigint> = new Set([
     TYPE_VARIANT,
 ]);
 
+const isWideUnsignedValue: ValueGuard = wideIntegerGuardFor(0n, UINT64_MAXIMUM);
+
 const SCALAR_GUARDS: Map<bigint, ValueGuard> = new Map([
     [TYPE_BOOLEAN, isBooleanValue],
     [TYPE_STRING, isStringValue],
@@ -71,11 +73,11 @@ const SCALAR_GUARDS: Map<bigint, ValueGuard> = new Map([
     [TYPE_ENUM, integerGuardFor(INT32_MINIMUM, INT32_MAXIMUM)],
     [TYPE_FLAGS, integerGuardFor(0, UINT32_MAXIMUM)],
     [TYPE_LONG, wideIntegerGuardFor(INT64_MINIMUM, INT64_MAXIMUM)],
-    [TYPE_ULONG, wideIntegerGuardFor(0n, UINT64_MAXIMUM)],
+    [TYPE_ULONG, isWideUnsignedValue],
     [TYPE_INT64, wideIntegerGuardFor(INT64_MINIMUM, INT64_MAXIMUM)],
-    [TYPE_UINT64, wideIntegerGuardFor(0n, UINT64_MAXIMUM)],
-    [TYPE_FLOAT, isFloatValue],
-    [TYPE_DOUBLE, isDoubleValue],
+    [TYPE_UINT64, isWideUnsignedValue],
+    [TYPE_FLOAT, isNumberValue],
+    [TYPE_DOUBLE, isNumberValue],
     [TYPE_POINTER, isNullValue],
 ]);
 
@@ -115,12 +117,8 @@ function isStrvValue(value: unknown): boolean {
     return value == null || (Array.isArray(value) && value.every((item) => typeof item === "string"));
 }
 
-function isDoubleValue(value: unknown): boolean {
-    return value == null || (typeof value === "number" && Number.isFinite(value));
-}
-
-function isFloatValue(value: unknown): boolean {
-    return isDoubleValue(value) && (value == null || Math.abs(value as number) <= FLOAT_MAXIMUM);
+function isNumberValue(value: unknown): boolean {
+    return typeof value === "number";
 }
 
 function isAnyValue(): boolean {
@@ -131,12 +129,8 @@ function isNullValue(value: unknown): boolean {
     return value == null;
 }
 
-function isIntegerWithin(value: unknown, minimum: number, maximum: number): boolean {
-    return Number.isSafeInteger(value) && (value as number) >= minimum && (value as number) <= maximum;
-}
-
 function integerGuardFor(minimum: number, maximum: number): ValueGuard {
-    return (value) => value == null || isIntegerWithin(value, minimum, maximum);
+    return (value) => Number.isSafeInteger(value) && (value as number) >= minimum && (value as number) <= maximum;
 }
 
 function toWideInteger(value: unknown): bigint | undefined {
@@ -149,10 +143,6 @@ function toWideInteger(value: unknown): bigint | undefined {
 
 function wideIntegerGuardFor(minimum: bigint, maximum: bigint): ValueGuard {
     return (value) => {
-        if (value == null) {
-            return true;
-        }
-
         const wide = toWideInteger(value);
 
         return wide !== undefined && wide >= minimum && wide <= maximum;
@@ -173,11 +163,20 @@ function wrappedGuardFor(valueType: bigint): ValueGuard {
     return (value) => value == null || typeIsA(resolveGtype(value), valueType);
 }
 
+function exactGuardFor(valueType: bigint): ValueGuard | undefined {
+    if (valueType === TYPE_GTYPE) {
+        return isWideUnsignedValue;
+    }
+
+    return valueType === getStrvType() ? isStrvValue : undefined;
+}
+
 function valueGuardFor(valueType: bigint): ValueGuard {
     assertParamLayout();
+    const exact = exactGuardFor(valueType);
 
-    if (valueType === getStrvType()) {
-        return isStrvValue;
+    if (exact !== undefined) {
+        return exact;
     }
 
     const fundamental = typeFundamental(valueType);

package/src/properties.ts

@@ -16,7 +16,14 @@ import {
 } from "./param-spec.js";
 import { getHandle, getInterfaceProperties, instanceClassName, type InterfaceProperty } from "./registry.js";
 import { typeName } from "./type.js";
-import { fromValue, intoValue, newValueForType, type ValueWriter, valueWriterFor } from "./value.js";
+import {
+    fromValue,
+    newValueForType,
+    type ValueNarrower,
+    valueNarrowerFor,
+    type ValueWriter,
+    valueWriterFor,
+} from "./value.js";
 
 type PropertyCheck = {
     name: string;
@@ -25,6 +32,7 @@ type PropertyCheck = {
     flags: number;
     valueType: bigint;
     canHoldValue: ValueGuard;
+    narrowValue: ValueNarrower;
     write?: ValueWriter;
     scratch?: ExternalObject<Handle>;
 };
@@ -80,6 +88,8 @@ const typeLabel = (type: bigint): string => typeName(type) ?? String(type);
 const defaultValueFor = (handle: ExternalObject<Handle>): ExternalObject<Handle> =>
     paramSpecDefaultValue(handle) as ExternalObject<Handle>;
 
+const heldValue = (value: unknown): unknown => value ?? null;
+
 const holdsReason = (check: PropertyCheck): string =>
     `the property holds values of type '${typeLabel(check.valueType)}'`;
 
@@ -93,6 +103,7 @@ function checkFor(handle: ExternalObject<Handle>, name: string): PropertyCheck {
         flags: getParamFlags(handle),
         valueType,
         canHoldValue: valueGuardFor(valueType),
+        narrowValue: valueNarrowerFor(valueType),
     };
 }
 
@@ -168,6 +179,11 @@ function assertWritable(instance: object, check: PropertyCheck, value: unknown):
     throw new TypeError(propertyMessage(instance, check, refusalTail(check, value, READ_ONLY_REASON)));
 }
 
+function writeHeld(check: PropertyCheck, gValue: ExternalObject<Handle>, value: unknown): void {
+    check.write ??= valueWriterFor(check.valueType);
+    check.write(gValue, check.narrowValue(value));
+}
+
 function fillCheckedValue(
     instance: object,
     check: PropertyCheck,
@@ -175,8 +191,7 @@ function fillCheckedValue(
     value: unknown,
 ): void {
     assertValueFits(instance, check, value);
-    check.write ??= valueWriterFor(check.valueType);
-    check.write(gValue, value);
+    writeHeld(check, gValue, value);
     assertValueValidates(instance, check, value, gValue);
 }
 
@@ -224,11 +239,11 @@ function readStored(instance: Record<symbol, unknown>, accessor: PropertyAccesso
 }
 
 function storeValue(instance: Record<symbol, unknown>, accessor: PropertyAccessor, value: unknown): void {
-    instance[accessor.storage] = value;
+    instance[accessor.storage] = heldValue(value);
 }
 
 function writeStored(instance: Record<symbol, unknown>, accessor: PropertyAccessor, value: unknown): void {
-    if (readStored(instance, accessor) === value) {
+    if (readStored(instance, accessor) === heldValue(value)) {
         return;
     }
 
@@ -239,13 +254,12 @@ function writeStored(instance: Record<symbol, unknown>, accessor: PropertyAccess
 function writeProperty(instance: object, accessor: PropertyAccessor, value: unknown): void {
     const stored = instance as Record<symbol, unknown>;
 
-    if (readStored(stored, accessor) === value) {
+    if (readStored(stored, accessor) === heldValue(value)) {
         return;
     }
 
     assertValueAccepted(instance, accessor, value);
-    storeValue(stored, accessor, value);
-    (instance as NotifyingObject).notify?.(accessor.propertyName);
+    writeStored(stored, accessor, accessor.narrowValue(value));
 }
 
 function storedGetter(accessor: PropertyAccessor): (this: object) => unknown {
@@ -431,7 +445,7 @@ function makeGetProperty(dispatch: PropertyDispatch) {
         const accessor = resolveAccessor(dispatch, propertyId, pspec);
         const current = readCurrent(this, accessor);
         assertValueServes(this, accessor, current);
-        intoValue(getHandle(value), current);
+        writeHeld(accessor, getHandle(value), current);
     };
 }
 

package/src/register-class.ts

@@ -134,6 +134,36 @@ type RegisterClassOptions<TInstance extends object, TProperties extends Record<s
      * which a `freeze_notify` batch collects; a write of the value the property already holds is
      * dropped and emits none.
      *
+     * `null` and `undefined` both mean NULL, and mean it only where the ParamSpec's own type holds
+     * NULL, which is a string, string-array, boxed, object, interface, param, variant or pointer
+     * property. Such a property holds the `null` either spelling wrote, so the member, the type's
+     * `get_property` slot and `g_object_get_property` serve the same thing, and writing the other
+     * spelling over it emits no `notify`. Every other property, so every integer, floating-point,
+     * boolean, enum, flags and GType one, refuses both with the same `TypeError` it refuses a
+     * string with, and keeps the value it already holds. It refuses them for what it holds rather
+     * than for its range, whatever that range is: the type is checked before the range, so a
+     * `gint` whose range excludes 0 answers a nullish with that same `TypeError` and never with
+     * the `RangeError` that names the value GObject would put in its place. The one place
+     * `undefined` means something else is the constructor, which reads it as the property not
+     * being given at all and leaves it at the ParamSpec's default, so a property is never handed a
+     * value it cannot serve back.
+     *
+     * A floating-point property takes every JavaScript number, `NaN` and both infinities
+     * included, and its ParamSpec alone rules on which of them the range admits: a `gdouble`
+     * bounded by `-Infinity` and `Infinity` holds either infinity, and a magnitude a bounded
+     * one excludes, like any `NaN`, comes back as the `RangeError` that names what GObject
+     * would put in its place rather than as the `TypeError` a type the property cannot hold
+     * earns. A `gfloat` property holds what GObject narrows the double to, so it serves `0.1`
+     * back as `0.10000000149011612` and a finite magnitude no `gfloat` reaches as an infinity,
+     * which the range then rules on in turn. That narrowing belongs to the property alone: the
+     * same magnitude written to a `gfloat` through a generated binding, a signal argument or a
+     * closure return is refused outright rather than narrowed.
+     *
+     * A generated property of a wrapped type answers a nullish differently, and the two halves of
+     * the API disagree here: that property marshals what it is written through its descriptor
+     * rather than through the checks above, so `new Gtk.Label({ widthRequest: null })` and a later
+     * write of `null` to that member both land 0, where a `gint` installed here refuses both.
+     *
      * A class that defines the camelCase member itself owns the property: its own accessor decides
      * what a write means, the other two spellings forward to it, and the type's property slots read
      * and write it rather than the generated storage.
@@ -166,7 +196,11 @@ type PropertyVfuncSpec = {
     makeDispatch: (dispatch: PropertyDispatch) => VfuncFn;
 };
 
+type ArgPatch = { isCallerAllocated: true } | { isCallScoped: true };
+
+const INSTANCE_ARG_INDEX = 0;
 const VALUE_ARG_INDEX = 2;
+const TEARDOWN_VFUNC_NAMES: Set<string> = new Set(["dispose", "finalize"]);
 
 const PROPERTY_VFUNC_SPECS: PropertyVfuncSpec[] = [
     { methodName: GET_PROPERTY_VFUNC, isValueOut: true, makeDispatch: makeGetProperty },
@@ -345,10 +379,13 @@ function buildDiscoveredVfunc(
         return undefined;
     }
 
+    const argDescriptors = slotArgDescriptors(descriptor);
+
     return {
         ...descriptor,
         methodName,
-        fn: wrapVfunc(fn, descriptor.argDescriptors, descriptor.returnDescriptor),
+        argDescriptors,
+        fn: wrapVfunc(fn, argDescriptors, descriptor),
     };
 }
 
@@ -381,9 +418,13 @@ function discoverClassVfuncs(klass: AnyClass, methods: MethodTable): DiscoveredV
 function wrapVfunc(
     fn: VfuncFn,
     argDescriptors: NativeRegisterClassVfunc["argDescriptors"],
-    returnDescriptor: NativeRegisterClassVfunc["returnDescriptor"],
+    descriptor: VfuncDescriptor,
 ): VfuncFn {
-    return wrapCallback(fn as (...args: unknown[]) => unknown, { argDescriptors, returnDescriptor }, "this");
+    return wrapCallback(
+        fn as (...args: unknown[]) => unknown,
+        { argDescriptors, returnDescriptor: descriptor.returnDescriptor },
+        "vfunc",
+    );
 }
 
 function discoverInterfaceBindings(
@@ -443,9 +484,23 @@ function propertyVfuncs(source: PropertyVfuncSource): DiscoveredVfunc[] {
     );
 }
 
-function markValueCallerAllocated(argDescriptors: Descriptor[]): Descriptor[] {
-    return argDescriptors.map((arg, index) =>
-        index === VALUE_ARG_INDEX ? { ...arg, isCallerAllocated: true } : arg);
+function markArg(argDescriptors: Descriptor[], index: number, patch: ArgPatch): Descriptor[] {
+    return argDescriptors.map((arg, at) => (at === index ? { ...arg, ...patch } : arg));
+}
+
+function isTeardownSlot(descriptor: VfuncDescriptor): boolean {
+    return (
+        TEARDOWN_VFUNC_NAMES.has(descriptor.vfuncName) &&
+        descriptor.argDescriptors[INSTANCE_ARG_INDEX]?.kind === "object"
+    );
+}
+
+function slotArgDescriptors(descriptor: VfuncDescriptor): Descriptor[] {
+    if (!isTeardownSlot(descriptor)) {
+        return descriptor.argDescriptors;
+    }
+
+    return markArg(descriptor.argDescriptors, INSTANCE_ARG_INDEX, { isCallScoped: true });
 }
 
 function buildPropertyVfunc(
@@ -461,14 +516,14 @@ function buildPropertyVfunc(
     }
 
     const argDescriptors = isValueOut
-        ? markValueCallerAllocated(descriptor.argDescriptors)
+        ? markArg(descriptor.argDescriptors, VALUE_ARG_INDEX, { isCallerAllocated: true })
         : descriptor.argDescriptors;
 
     return {
         ...descriptor,
         methodName,
         argDescriptors,
-        fn: wrapVfunc(fn, argDescriptors, descriptor.returnDescriptor),
+        fn: wrapVfunc(fn, argDescriptors, descriptor),
     };
 }
 

package/src/registry.ts

@@ -12,10 +12,12 @@ import { TYPE_INVALID, type TypedClass, typeInterfaces, typeIsA, typeName, typeP
 
 /**
  * Static side of class `C` with its construct signature preserved but the member
- * named `K` (default `"new"`) removed.
+ * named `K` (default `"new"`) removed. The signature is kept abstract so an abstract
+ * `C` survives it: a subclass extends the result, and only the subclass's own
+ * declaration decides whether `new` reaches it.
  */
 type StaticBase<C, K extends PropertyKey = "new"> = Omit<C, K> &
-    (C extends new (...args: infer A) => infer R ? new (...args: A) => R : never);
+    (C extends abstract new (...args: infer A) => infer R ? abstract new (...args: A) => R : never);
 
 /** One overridable vtable slot: where it sits in the vtable struct and how it is marshalled. */
 type VfuncDescriptor = {
@@ -35,6 +37,12 @@ type VfuncDescriptor = {
     argDescriptors: NativeRegisterClassVfunc["argDescriptors"];
     /** Descriptor for the value the slot returns. */
     returnDescriptor: NativeRegisterClassVfunc["returnDescriptor"];
+    /**
+     * GIR marks the slot's return value as one the bindings do not surface, so a call through the
+     * slot drops it and an implementation of the slot reports success in its place, while
+     * `VfuncDescriptor.returnDescriptor` keeps the C type the slot is called against either way.
+     */
+    isReturnSkipped?: boolean;
     /**
      * The slot takes a trailing `GError**` that `VfuncDescriptor.argDescriptors` leaves out, the
      * way GIR leaves it out of a callable's parameters. A call through the slot has to append it
@@ -48,6 +56,7 @@ type VfuncDescriptor = {
  * overrides each one.
  */
 type VfuncRegistry = Record<string, VfuncDescriptor>;
+type WrapperBinding = (handle: ExternalObject<Handle>, instance: object) => void;
 
 /**
  * How one property an interface declares reaches the vtable, given as the interface's own accessor
@@ -320,24 +329,18 @@ function resolveComposedClass(runtimeType: bigint): AnyClass | null {
 }
 
 function wrapObject(value: unknown): object | null {
-    if (value == null) {
-        return null;
-    }
-
-    return getOrCreateWrapper(value as ExternalObject<Handle>);
+    return value == null ? null : getOrCreateWrapper(value as ExternalObject<Handle>);
 }
 
-function getOrCreateWrapper(handle: ExternalObject<Handle>): object {
-    if (handleMap.has(handle)) {
-        return handle;
-    }
-
-    const existing = getWrapper(handle);
+function wrapCallScopedObject(value: unknown): object | null {
+    return value == null ? null : wrapperFor(value as ExternalObject<Handle>, bindCallScopedWrapper);
+}
 
-    if (existing) {
-        return existing;
-    }
+function existingWrapperFor(handle: ExternalObject<Handle>): object | null {
+    return handleMap.has(handle) ? handle : getWrapper(handle);
+}
 
+function createWrapper(handle: ExternalObject<Handle>): object {
     const runtimeType: bigint = getType(handle);
 
     if (runtimeType === TYPE_INVALID) {
@@ -350,12 +353,26 @@ function getOrCreateWrapper(handle: ExternalObject<Handle>): object {
         throw new Error(`Expected registered GLib type, got type ${String(runtimeType)}`);
     }
 
-    const instance: object = Object.create(cls.prototype) as object;
-    registerWrapper(handle, instance);
+    return Object.create(cls.prototype) as object;
+}
+
+function wrapperFor(handle: ExternalObject<Handle>, bind: WrapperBinding): object {
+    const existing = existingWrapperFor(handle);
+
+    if (existing) {
+        return existing;
+    }
+
+    const instance = createWrapper(handle);
+    bind(handle, instance);
 
     return instance;
 }
 
+function getOrCreateWrapper(handle: ExternalObject<Handle>): object {
+    return wrapperFor(handle, registerWrapper);
+}
+
 function instanceClassName(instance: object): string {
     return (instance as { constructor?: { name?: string } }).constructor?.name ?? "object";
 }
@@ -376,6 +393,10 @@ function setHandle(instance: object, handle: ExternalObject<Handle>): void {
     handleMap.set(instance, handle);
 }
 
+function bindCallScopedWrapper(handle: ExternalObject<Handle>, instance: object): void {
+    setHandle(instance, handle);
+}
+
 function registerWrapper(handle: ExternalObject<Handle>, instance: object): void {
     setHandle(instance, handle);
     setWrapper(handle, instance);
@@ -416,6 +437,7 @@ export {
     instanceClassName,
     registerWrapper,
     resolveWrapperType,
+    wrapCallScopedObject,
     wrapObject,
     type InterfaceProperty,
     type StaticBase,

package/src/signal.ts

@@ -43,6 +43,11 @@ type SignalConnectSpec = {
     isAfter: boolean;
 };
 
+type EmitValues = {
+    values: ExternalObject<Handle>[];
+    reads: (() => unknown)[];
+};
+
 /** One argument of a signal emission: how to marshal it, plus the value to marshal. */
 type EmitArg = Arg & {
     /**
@@ -194,7 +199,7 @@ function connectBind(type: bigint, signal: string, callback: CallbackDescriptor)
  */
 function connectSignal(instance: object, signal: string, spec: SignalConnectSpec): number {
     const { callback, handler, isAfter } = spec;
-    const wrapped = wrapCallback(handler, callback, "emitter");
+    const wrapped = wrapCallback(handler, callback, "signal");
     const type: bigint = (instance as TypedClass).__type__;
     const connect = connectBind(type, signal, callback);
     const handlerId = connect(getHandle(instance), signal, wrapped, isAfter ? 1 : 0) as number;
@@ -221,47 +226,46 @@ const createEmitValue = (arg: EmitArg): { value: ExternalObject<Handle>; read?:
     return isInoutArg(arg) ? outValueForDescriptor(arg.type, arg.value) : outValueForDescriptor(arg.type);
 };
 
+const collectEmitValues = (instance: object, args: EmitArg[]): EmitValues => {
+    const collected: EmitValues = { values: [toValue(objectT("full"), instance)], reads: [] };
+
+    for (const arg of args) {
+        const { value, read } = createEmitValue(arg);
+        collected.values.push(value);
+
+        if (read) {
+            collected.reads.push(read);
+        }
+    }
+
+    return collected;
+};
+
+const readEmitOutputs = (reads: (() => unknown)[]): unknown[] => reads.map((read) => read());
+
 /**
  * Emits a signal on an instance with the given arguments and returns its result
  * combined with any output-argument values.
  * @param instance Emitter to emit the signal on.
  * @param signal Signal name, optionally including a `::detail` suffix.
  * @param args Arguments to pass, including output and inout arguments.
- * @param returnDescriptor Descriptor for the signal's return value, omitted when it returns void.
+ * @param returns Descriptor for the signal's return value, omitted when it returns void.
  */
-function emitSignal(instance: object, signal: string, args: EmitArg[], returnDescriptor?: Descriptor): unknown {
+function emitSignal(instance: object, signal: string, args: EmitArg[], returns?: Descriptor): unknown {
     const signalId = getSignalId(instance, signal);
     const detail = getSignalDetailQuark(signal);
-    const values: ExternalObject<Handle>[] = [toValue(objectT("full"), instance)];
-    const reads: (() => unknown)[] = [];
-
-    for (const arg of args) {
-        const { value, read } = createEmitValue(arg);
-        values.push(value);
+    const { values, reads } = collectEmitValues(instance, args);
 
-        if (read) {
-            reads.push(read);
-        }
-    }
+    if (returns === undefined) {
+        gSignalEmitv(values, signalId, detail, undefined);
 
-    if (returnDescriptor !== undefined) {
-        const returnValue = newValueForDescriptor(returnDescriptor);
-        gSignalEmitv(values, signalId, detail, returnValue);
-
-        return packTupleResult(
-            reads.map((read) => read()),
-            fromValue(returnValue),
-            true,
-        );
+        return packTupleResult(readEmitOutputs(reads), undefined, false);
     }
 
-    gSignalEmitv(values, signalId, detail, undefined);
+    const returnValue = newValueForDescriptor(returns);
+    gSignalEmitv(values, signalId, detail, returnValue);
 
-    return packTupleResult(
-        reads.map((read) => read()),
-        undefined,
-        false,
-    );
+    return packTupleResult(readEmitOutputs(reads), fromValue(returnValue), true);
 }
 
 export {

package/src/t.ts

@@ -77,6 +77,8 @@ type T = {
     sizedArray: typeof helpers.sizedArrayT;
     /** Builds a descriptor for a C array of a fixed length. */
     fixedArray: typeof helpers.fixedArrayT;
+    /** Builds a descriptor for an out pointer into the buffer another argument supplied. */
+    cursorArray: typeof helpers.cursorArrayT;
     /** Builds a descriptor for a function pointer, marshalling a JavaScript function into a native closure. */
     callback: typeof helpers.callbackT;
     /**
@@ -127,6 +129,7 @@ const t: T = {
     byteArray: helpers.byteArrayT,
     sizedArray: helpers.sizedArrayT,
     fixedArray: helpers.fixedArrayT,
+    cursorArray: helpers.cursorArrayT,
     callback: helpers.callbackT,
     fn,
 };

package/src/tuple.ts

@@ -1,3 +1,10 @@
+import type { Descriptor } from "@gtkx/native";
+
+type SplitResult = { primary: unknown; outValues: unknown[] };
+
+const hasSurfacedPrimary = (returnDescriptor: Descriptor, isReturnSkipped: boolean | undefined): boolean =>
+    returnDescriptor.kind !== "void" && isReturnSkipped !== true;
+
 const packTupleResult = (outs: unknown[], primary: unknown, hasPrimary: boolean): unknown => {
     if (hasPrimary) {
         return outs.length === 0 ? primary : [primary, ...outs];
@@ -14,19 +21,15 @@ const packTupleResult = (outs: unknown[], primary: unknown, hasPrimary: boolean)
     return outs;
 };
 
-const splitTupleResult = (
-    result: unknown,
-    hasPrimary: boolean,
-    outCount: number,
-): { primary: unknown; outValues: unknown[] } => {
-    if (hasPrimary) {
-        if (Array.isArray(result)) {
-            return { primary: result[0], outValues: result.slice(1) };
-        }
-
-        return { primary: result, outValues: [] };
+const splitPrimaryResult = (result: unknown, outCount: number): SplitResult => {
+    if (outCount > 0 && Array.isArray(result)) {
+        return { primary: result[0], outValues: result.slice(1) };
     }
 
+    return { primary: result, outValues: [] };
+};
+
+const splitOutResult = (result: unknown, outCount: number): SplitResult => {
     if (outCount === 1) {
         return { primary: undefined, outValues: [result] };
     }
@@ -34,4 +37,7 @@ const splitTupleResult = (
     return { primary: undefined, outValues: Array.isArray(result) ? result : [] };
 };
 
-export { packTupleResult, splitTupleResult };
+const splitTupleResult = (result: unknown, hasPrimary: boolean, outCount: number): SplitResult =>
+    hasPrimary ? splitPrimaryResult(result, outCount) : splitOutResult(result, outCount);
+
+export { hasSurfacedPrimary, packTupleResult, splitTupleResult };