typegpu 0.11.1 → 0.11.3

package/std/numeric.d.ts

@@ -6,195 +6,249 @@ import { Infer } from "../shared/repr.js";
 type NumVec = AnyNumericVecInstance;
 declare function cpuAbs(value: number): number;
 declare function cpuAbs<T extends NumVec | number>(value: T): T;
-declare const abs: DualFn;
+declare const abs: DualFn<typeof cpuAbs>;
 declare function cpuAcos(value: number): number;
 declare function cpuAcos<T extends AnyFloatVecInstance>(value: T): T;
-declare const acos: DualFn;
+declare const acos: DualFn<typeof cpuAcos>;
 declare function cpuAcosh(value: number): number;
 declare function cpuAcosh<T extends AnyFloatVecInstance>(value: T): T;
-declare const acosh: DualFn;
+declare const acosh: DualFn<typeof cpuAcosh>;
 declare function cpuAsin(value: number): number;
 declare function cpuAsin<T extends AnyFloatVecInstance>(value: T): T;
-declare const asin: DualFn;
+declare const asin: DualFn<typeof cpuAsin>;
 declare function cpuAsinh(value: number): number;
 declare function cpuAsinh<T extends AnyFloatVecInstance>(value: T): T;
-declare const asinh: DualFn;
+declare const asinh: DualFn<typeof cpuAsinh>;
 declare function cpuAtan(value: number): number;
 declare function cpuAtan<T extends AnyFloatVecInstance>(value: T): T;
-declare const atan: DualFn;
+declare const atan: DualFn<typeof cpuAtan>;
 declare function cpuAtanh(value: number): number;
 declare function cpuAtanh<T extends AnyFloatVecInstance>(value: T): T;
-declare const atanh: DualFn;
+declare const atanh: DualFn<typeof cpuAtanh>;
 declare function cpuAtan2(y: number, x: number): number;
 declare function cpuAtan2<T extends AnyFloatVecInstance>(y: T, x: T): T;
-declare const atan2: DualFn;
+declare const atan2: DualFn<typeof cpuAtan2>;
 declare function cpuCeil(value: number): number;
 declare function cpuCeil<T extends AnyFloatVecInstance>(value: T): T;
-declare const ceil: DualFn;
+declare const ceil: DualFn<typeof cpuCeil>;
 declare function cpuClamp(value: number, low: number, high: number): number;
 declare function cpuClamp<T extends NumVec | number>(value: T, low: T, high: T): T;
-declare const clamp: DualFn;
+declare const clamp: DualFn<typeof cpuClamp>;
 declare function cpuCos(value: number): number;
 declare function cpuCos<T extends AnyFloatVecInstance>(value: T): T;
-declare const cos: DualFn;
+declare const cos: DualFn<typeof cpuCos>;
 declare function cpuCosh(value: number): number;
 declare function cpuCosh<T extends AnyFloatVecInstance>(value: T): T;
-declare const cosh: DualFn;
+declare const cosh: DualFn<typeof cpuCosh>;
 declare function cpuCountLeadingZeros(value: number): number;
 declare function cpuCountLeadingZeros<T extends AnyIntegerVecInstance>(value: T): T;
-declare const countLeadingZeros: DualFn;
+declare const countLeadingZeros: DualFn<typeof cpuCountLeadingZeros>;
 declare function cpuCountOneBits(value: number): number;
 declare function cpuCountOneBits<T extends AnyIntegerVecInstance>(value: T): T;
-declare const countOneBits: DualFn;
+declare const countOneBits: DualFn<typeof cpuCountOneBits>;
 declare function cpuCountTrailingZeros(value: number): number;
 declare function cpuCountTrailingZeros<T extends AnyIntegerVecInstance>(value: T): T;
-declare const countTrailingZeros: DualFn;
-declare const cross: DualFn;
+declare const countTrailingZeros: DualFn<typeof cpuCountTrailingZeros>;
+declare const cross: DualFn<(<T extends v3f | v3h>(a: T, b: T) => T)>;
 declare function cpuDegrees(value: number): number;
 declare function cpuDegrees<T extends AnyFloatVecInstance>(value: T): T;
-declare const degrees: DualFn;
-declare const determinant: DualFn;
+declare const degrees: DualFn<typeof cpuDegrees>;
+declare const determinant: DualFn<(value: AnyMatInstance) => number>;
 declare function cpuDistance(a: number, b: number): number;
 declare function cpuDistance<T extends AnyFloatVecInstance>(a: T, b: T): number;
-declare const distance: DualFn;
-declare const dot: DualFn;
-declare const dot4U8Packed: DualFn;
-declare const dot4I8Packed: DualFn;
+declare const distance: DualFn<typeof cpuDistance>;
+declare const dot: DualFn<(<T extends NumVec>(lhs: T, rhs: T) => number)>;
+declare const dot4U8Packed: DualFn<(e1: number, e2: number) => number>;
+declare const dot4I8Packed: DualFn<(e1: number, e2: number) => number>;
 declare function cpuExp(value: number): number;
 declare function cpuExp<T extends AnyFloatVecInstance>(value: T): T;
-declare const exp: DualFn;
+declare const exp: DualFn<typeof cpuExp>;
 declare function cpuExp2(value: number): number;
 declare function cpuExp2<T extends AnyFloatVecInstance>(value: T): T;
-declare const exp2: DualFn;
+declare const exp2: DualFn<typeof cpuExp2>;
 declare function cpuExtractBits(e: number, offset: number, count: number): number;
 declare function cpuExtractBits<T extends AnyIntegerVecInstance>(e: T, offset: number, count: number): T;
-declare const extractBits: DualFn;
-declare const faceForward: DualFn;
+declare const extractBits: DualFn<typeof cpuExtractBits>;
+declare const faceForward: DualFn<(<T extends AnyFloatVecInstance>(e1: T, e2: T, e3: T) => T)>;
 declare function cpuFirstLeadingBit(value: number): number;
 declare function cpuFirstLeadingBit<T extends AnyIntegerVecInstance>(value: T): T;
-declare const firstLeadingBit: DualFn;
+declare const firstLeadingBit: DualFn<typeof cpuFirstLeadingBit>;
 declare function cpuFirstTrailingBit(value: number): number;
 declare function cpuFirstTrailingBit<T extends AnyIntegerVecInstance>(value: T): T;
-declare const firstTrailingBit: DualFn;
+declare const firstTrailingBit: DualFn<typeof cpuFirstTrailingBit>;
 declare function cpuFloor(value: number): number;
 declare function cpuFloor<T extends AnyFloatVecInstance>(value: T): T;
-declare const floor: DualFn;
+declare const floor: DualFn<typeof cpuFloor>;
 declare function cpuFma(e1: number, e2: number, e3: number): number;
 declare function cpuFma<T extends AnyFloatVecInstance>(e1: T, e2: T, e3: T): T;
-declare const fma: DualFn;
+declare const fma: DualFn<typeof cpuFma>;
 declare function cpuFract(value: number): number;
 declare function cpuFract<T extends AnyFloatVecInstance>(value: T): T;
-declare const fract: DualFn;
+declare const fract: DualFn<typeof cpuFract>;
 declare const FrexpResults: {
-  readonly f32: WgslStruct;
-  readonly f16: WgslStruct;
-  readonly abstractFloat: WgslStruct;
-  readonly vec2f: WgslStruct;
-  readonly vec3f: WgslStruct;
-  readonly vec4f: WgslStruct;
-  readonly vec2h: WgslStruct;
-  readonly vec3h: WgslStruct;
-  readonly vec4h: WgslStruct;
+  readonly f32: WgslStruct<{
+    fract: F32;
+    exp: I32;
+  }>;
+  readonly f16: WgslStruct<{
+    fract: F16;
+    exp: I32;
+  }>;
+  readonly abstractFloat: WgslStruct<{
+    fract: AbstractFloat;
+    exp: AbstractInt;
+  }>;
+  readonly vec2f: WgslStruct<{
+    fract: Vec2f;
+    exp: Vec2i;
+  }>;
+  readonly vec3f: WgslStruct<{
+    fract: Vec3f;
+    exp: Vec3i;
+  }>;
+  readonly vec4f: WgslStruct<{
+    fract: Vec4f;
+    exp: Vec4i;
+  }>;
+  readonly vec2h: WgslStruct<{
+    fract: Vec2h;
+    exp: Vec2i;
+  }>;
+  readonly vec3h: WgslStruct<{
+    fract: Vec3h;
+    exp: Vec3i;
+  }>;
+  readonly vec4h: WgslStruct<{
+    fract: Vec4h;
+    exp: Vec4i;
+  }>;
 };
 type FrexpOverload = {
   (value: number): Infer<(typeof FrexpResults)['f32']>;
   <T extends AnyFloatVecInstance>(value: T): Infer<(typeof FrexpResults)[T['kind']]>;
 };
-declare const frexp: DualFn;
+declare const frexp: DualFn<FrexpOverload>;
 declare function cpuInsertBits(e: number, newbits: number, offset: number, count: number): number;
 declare function cpuInsertBits<T extends AnyIntegerVecInstance>(e: T, newbits: T, offset: number, count: number): T;
-declare const insertBits: DualFn;
+declare const insertBits: DualFn<typeof cpuInsertBits>;
 declare function cpuInverseSqrt(value: number): number;
 declare function cpuInverseSqrt<T extends AnyFloatVecInstance>(value: T): T;
-declare const inverseSqrt: DualFn;
+declare const inverseSqrt: DualFn<typeof cpuInverseSqrt>;
 declare function cpuLdexp(e1: number, e2: number): number;
 declare function cpuLdexp<T extends v2f | v2h>(e1: T, e2: v2i): T;
 declare function cpuLdexp<T extends v3f | v3h>(e1: T, e2: v3i): T;
 declare function cpuLdexp<T extends v4f | v4h>(e1: T, e2: v4i): T;
-declare const ldexp: DualFn;
+declare const ldexp: DualFn<typeof cpuLdexp>;
 declare function cpuLength(value: number): number;
 declare function cpuLength<T extends AnyFloatVecInstance>(value: T): number;
-declare const length: DualFn;
+declare const length: DualFn<typeof cpuLength>;
 declare function cpuLog(value: number): number;
 declare function cpuLog<T extends AnyFloatVecInstance>(value: T): T;
-declare const log: DualFn;
+declare const log: DualFn<typeof cpuLog>;
 declare function cpuLog2(value: number): number;
 declare function cpuLog2<T extends AnyFloatVecInstance>(value: T): T;
-declare const log2: DualFn;
+declare const log2: DualFn<typeof cpuLog2>;
 type VariadicOverload = {
   (fst: number, ...rest: number[]): number;
   <T extends NumVec>(fst: T, ...rest: T[]): T;
 };
-declare const max: DualFn;
-declare const min: DualFn;
+declare const max: DualFn<VariadicOverload>;
+declare const min: DualFn<VariadicOverload>;
 declare function cpuMix(e1: number, e2: number, e3: number): number;
 declare function cpuMix<T extends AnyFloatVecInstance>(e1: T, e2: T, e3: number): T;
 declare function cpuMix<T extends AnyFloatVecInstance>(e1: T, e2: T, e3: T): T;
-declare const mix: DualFn;
+declare const mix: DualFn<typeof cpuMix>;
 declare const ModfResult: {
-  readonly f32: WgslStruct;
-  readonly f16: WgslStruct;
-  readonly abstractFloat: WgslStruct;
-  readonly vec2f: WgslStruct;
-  readonly vec3f: WgslStruct;
-  readonly vec4f: WgslStruct;
-  readonly vec2h: WgslStruct;
-  readonly vec3h: WgslStruct;
-  readonly vec4h: WgslStruct;
+  readonly f32: WgslStruct<{
+    fract: F32;
+    whole: F32;
+  }>;
+  readonly f16: WgslStruct<{
+    fract: F16;
+    whole: F16;
+  }>;
+  readonly abstractFloat: WgslStruct<{
+    fract: AbstractFloat;
+    whole: AbstractFloat;
+  }>;
+  readonly vec2f: WgslStruct<{
+    fract: Vec2f;
+    whole: Vec2f;
+  }>;
+  readonly vec3f: WgslStruct<{
+    fract: Vec3f;
+    whole: Vec3f;
+  }>;
+  readonly vec4f: WgslStruct<{
+    fract: Vec4f;
+    whole: Vec4f;
+  }>;
+  readonly vec2h: WgslStruct<{
+    fract: Vec2h;
+    whole: Vec2h;
+  }>;
+  readonly vec3h: WgslStruct<{
+    fract: Vec3h;
+    whole: Vec3h;
+  }>;
+  readonly vec4h: WgslStruct<{
+    fract: Vec4h;
+    whole: Vec4h;
+  }>;
 };
 type ModfOverload = {
   (value: number): Infer<(typeof ModfResult)['f32']>;
   <T extends AnyFloatVecInstance>(value: T): Infer<(typeof ModfResult)[T['kind']]>;
 };
 declare const modf: ModfOverload;
-declare const normalize: DualFn;
+declare const normalize: DualFn<(<T extends AnyFloatVecInstance>(v: T) => T)>;
 declare function powCpu(base: number, exponent: number): number;
 declare function powCpu<T extends AnyFloatVecInstance>(base: T, exponent: T): T;
-declare const pow: DualFn;
+declare const pow: DualFn<typeof powCpu>;
 declare function cpuQuantizeToF16(value: number): number;
 declare function cpuQuantizeToF16<T extends AnyFloat32VecInstance>(value: T): T;
-declare const quantizeToF16: DualFn;
+declare const quantizeToF16: DualFn<typeof cpuQuantizeToF16>;
 declare function cpuRadians(value: number): number;
 declare function cpuRadians<T extends AnyFloatVecInstance | number>(value: T): T;
-declare const radians: DualFn;
-declare const reflect: DualFn;
-declare const refract: DualFn;
+declare const radians: DualFn<typeof cpuRadians>;
+declare const reflect: DualFn<(<T extends AnyFloatVecInstance>(e1: T, e2: T) => T)>;
+declare const refract: DualFn<(<T extends AnyFloatVecInstance>(e1: T, e2: T, e3: number) => T)>;
 declare function cpuReverseBits(value: number): number;
 declare function cpuReverseBits<T extends AnyIntegerVecInstance>(value: T): T;
-declare const reverseBits: DualFn;
+declare const reverseBits: DualFn<typeof cpuReverseBits>;
 declare function cpuRound(value: number): number;
 declare function cpuRound<T extends AnyFloatVecInstance>(value: T): T;
-declare const round: DualFn;
+declare const round: DualFn<typeof cpuRound>;
 declare function cpuSaturate(value: number): number;
 declare function cpuSaturate<T extends AnyFloatVecInstance>(value: T): T;
-declare const saturate: DualFn;
+declare const saturate: DualFn<typeof cpuSaturate>;
 declare function cpuSign(e: number): number;
 declare function cpuSign<T extends AnySignedVecInstance>(e: T): T;
-declare const sign: DualFn;
+declare const sign: DualFn<typeof cpuSign>;
 declare function cpuSin(value: number): number;
 declare function cpuSin<T extends AnyFloatVecInstance>(value: T): T;
-declare const sin: DualFn;
+declare const sin: DualFn<typeof cpuSin>;
 declare function cpuSinh(value: number): number;
 declare function cpuSinh<T extends AnyFloatVecInstance>(value: T): T;
-declare const sinh: DualFn;
+declare const sinh: DualFn<typeof cpuSinh>;
 declare function cpuSmoothstep(edge0: number, edge1: number, x: number): number;
 declare function cpuSmoothstep<T extends AnyFloatVecInstance>(edge0: T, edge1: T, x: T): T;
-declare const smoothstep: DualFn;
+declare const smoothstep: DualFn<typeof cpuSmoothstep>;
 declare function cpuSqrt(value: number): number;
 declare function cpuSqrt<T extends AnyFloatVecInstance>(value: T): T;
-declare const sqrt: DualFn;
+declare const sqrt: DualFn<typeof cpuSqrt>;
 declare function cpuStep(edge: number, x: number): number;
 declare function cpuStep<T extends AnyFloatVecInstance | number>(edge: T, x: T): T;
-declare const step: DualFn;
+declare const step: DualFn<typeof cpuStep>;
 declare function cpuTan(value: number): number;
 declare function cpuTan<T extends AnyFloatVecInstance>(value: T): T;
-declare const tan: DualFn;
+declare const tan: DualFn<typeof cpuTan>;
 declare function cpuTanh(value: number): number;
 declare function cpuTanh<T extends AnyFloatVecInstance>(value: T): T;
-declare const tanh: DualFn;
-declare const transpose: DualFn;
+declare const tanh: DualFn<typeof cpuTanh>;
+declare const transpose: DualFn<(<T extends AnyMatInstance>(e: T) => T)>;
 declare function cpuTrunc(value: number): number;
 declare function cpuTrunc<T extends AnyFloatVecInstance>(value: T): T;
-declare const trunc: DualFn;
+declare const trunc: DualFn<typeof cpuTrunc>;
 //#endregion
 export { abs, acos, acosh, asin, asinh, atan, atan2, atanh, ceil, clamp, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, distance, dot, dot4I8Packed, dot4U8Packed, exp, exp2, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, insertBits, inverseSqrt, ldexp, length, log, log2, max, min, mix, modf, normalize, pow, quantizeToF16, radians, reflect, refract, reverseBits, round, saturate, sign, sin, sinh, smoothstep, sqrt, step, tan, tanh, transpose, trunc };

package/std/numeric.js

@@ -10,6 +10,7 @@ import { mat2x2f, mat3x3f, mat4x4f } from "../data/matrix.js";
 import { smoothstepScalar } from "../data/numberOps.js";
 import { VectorOps } from "../data/vectorOps.js";
 import { mul, sub } from "./operators.js";
+
 //#region src/std/numeric.ts
 const unaryIdentitySignature = (arg) => {
 	return {
@@ -710,10 +711,10 @@ const reverseBits = dualImpl({
 });
 function cpuRound(value) {
 	if (typeof value === "number") {
-		const floor = Math.floor(value);
-		if (value === floor + .5) {
-			if (floor % 2 === 0) return floor;
-			return floor + 1;
+		const floor$1 = Math.floor(value);
+		if (value === floor$1 + .5) {
+			if (floor$1 % 2 === 0) return floor$1;
+			return floor$1 + 1;
 		}
 		return Math.round(value);
 	}
@@ -841,5 +842,6 @@ const trunc = dualImpl({
 	normalImpl: "CPU implementation for trunc not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
 	codegenImpl: (_ctx, [value]) => stitch`trunc(${value})`
 });
+
 //#endregion
-export { abs, acos, acosh, asin, asinh, atan, atan2, atanh, ceil, clamp, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, distance, dot, dot4I8Packed, dot4U8Packed, exp, exp2, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, insertBits, inverseSqrt, ldexp, length, log, log2, max, min, mix, modf, normalize, pow, quantizeToF16, radians, reflect, refract, reverseBits, round, saturate, sign, sin, sinh, smoothstep, sqrt, step, tan, tanh, transpose, trunc };
+export { abs, acos, acosh, asin, asinh, atan, atan2, atanh, ceil, clamp, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, distance, dot, dot4I8Packed, dot4U8Packed, exp, exp2, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, insertBits, inverseSqrt, ldexp, length, log, log2, max, min, mix, modf, normalize, pow, quantizeToF16, radians, reflect, refract, reverseBits, round, saturate, sign, sin, sinh, smoothstep, sqrt, step, tan, tanh, transpose, trunc };

package/std/operators.d.ts

@@ -9,13 +9,13 @@ declare function cpuAdd<T extends NumVec>(lhs: number, rhs: T): T;
 declare function cpuAdd<T extends NumVec>(lhs: T, rhs: number): T;
 declare function cpuAdd<T extends NumVec | Mat>(lhs: T, rhs: T): T;
 declare function cpuAdd<Lhs extends number | NumVec | Mat, Rhs extends (Lhs extends number ? number | NumVec : Lhs extends NumVec ? number | Lhs : Lhs extends Mat ? Lhs : never)>(lhs: Lhs, rhs: Rhs): Lhs | Rhs;
-declare const add: DualFn;
+declare const add: DualFn<typeof cpuAdd>;
 declare function cpuSub(lhs: number, rhs: number): number;
 declare function cpuSub<T extends NumVec>(lhs: number, rhs: T): T;
 declare function cpuSub<T extends NumVec>(lhs: T, rhs: number): T;
 declare function cpuSub<T extends NumVec | Mat>(lhs: T, rhs: T): T;
 declare function cpuSub<Lhs extends number | NumVec | Mat, Rhs extends (Lhs extends number ? number | NumVec : Lhs extends NumVec ? number | Lhs : Lhs extends Mat ? Lhs : never)>(lhs: Lhs, rhs: Rhs): Lhs | Rhs;
-declare const sub: DualFn;
+declare const sub: DualFn<typeof cpuSub>;
 declare function cpuMul(lhs: number, rhs: number): number;
 declare function cpuMul<MV extends NumVec | Mat>(lhs: number, rhs: MV): MV;
 declare function cpuMul<MV extends NumVec | Mat>(lhs: MV, rhs: number): MV;
@@ -24,12 +24,12 @@ declare function cpuMul<M extends Mat, V extends vBaseForMat<M>>(lhs: V, rhs: M)
 declare function cpuMul<M extends Mat, V extends vBaseForMat<M>>(lhs: M, rhs: V): V;
 declare function cpuMul<M extends Mat>(lhs: M, rhs: M): M;
 declare function cpuMul<Lhs extends number | NumVec | Mat, Rhs extends (Lhs extends number ? number | NumVec | Mat : Lhs extends NumVec ? number | Lhs | mBaseForVec<Lhs> : Lhs extends Mat ? number | vBaseForMat<Lhs> | Lhs : never)>(lhs: Lhs, rhs: Rhs): Lhs | Rhs;
-declare const mul: DualFn;
+declare const mul: DualFn<typeof cpuMul>;
 declare function cpuDiv(lhs: number, rhs: number): number;
 declare function cpuDiv<T extends NumVec>(lhs: T, rhs: T): T;
 declare function cpuDiv<T extends NumVec>(lhs: number, rhs: T): T;
 declare function cpuDiv<T extends NumVec>(lhs: T, rhs: number): T;
-declare const div: DualFn;
+declare const div: DualFn<typeof cpuDiv>;
 type ModOverload = {
   (a: number, b: number): number;
   <T extends NumVec>(a: T, b: T): T;
@@ -40,17 +40,17 @@ type ModOverload = {
  * @privateRemarks
  * Both JS and WGSL implementations use truncated definition of modulo
  */
-declare const mod: DualFn;
+declare const mod: DualFn<ModOverload>;
 declare function cpuNeg(value: number): number;
 declare function cpuNeg<T extends NumVec>(value: T): T;
-declare const neg: DualFn;
+declare const neg: DualFn<typeof cpuNeg>;
 declare function cpuBitShiftLeft(lhs: number, rhs: number): number;
 declare function cpuBitShiftLeft<T extends AnyIntegerVecInstance>(lhs: T, rhs: number): T;
 declare function cpuBitShiftLeft<T extends AnyIntegerVecInstance>(lhs: T, rhs: vecIToVecU<T>): T;
-declare const bitShiftLeft: DualFn;
+declare const bitShiftLeft: DualFn<typeof cpuBitShiftLeft>;
 declare function cpuBitShiftRight(lhs: number, rhs: number): number;
 declare function cpuBitShiftRight<T extends AnyIntegerVecInstance>(lhs: T, rhs: number): T;
 declare function cpuBitShiftRight<T extends AnyIntegerVecInstance>(lhs: T, rhs: vecIToVecU<T>): T;
-declare const bitShiftRight: DualFn;
+declare const bitShiftRight: DualFn<typeof cpuBitShiftRight>;
 //#endregion
 export { add, bitShiftLeft, bitShiftRight, div, mod, mul, neg, sub };

package/std/operators.js

@@ -6,6 +6,7 @@ import { abstractFloat, f16, f32, i32, u32 } from "../data/numeric.js";
 import { vec2i, vec2u, vec3i, vec3u, vec4i, vec4u, vecTypeToConstructor } from "../data/vector.js";
 import { dualImpl } from "../core/function/dualImpl.js";
 import { VectorOps } from "../data/vectorOps.js";
+
 //#region src/std/operators.ts
 const getPrimitive = (t) => "primitive" in t ? t.primitive : t;
 const makeBinarySignature = (opts) => (lhs, rhs) => {
@@ -18,11 +19,11 @@ const makeBinarySignature = (opts) => (lhs, rhs) => {
 	const lhsC = isVec(lhs) || isMat(lhs);
 	const rhsC = isVec(rhs) || isMat(rhs);
 	if (!lhsC && !rhsC) {
-		const unified = unify([lhs, rhs], restrict);
-		if (!unified) return fail("incompatible scalar types");
+		const unified$1 = unify([lhs, rhs], restrict);
+		if (!unified$1) return fail("incompatible scalar types");
 		return {
-			argTypes: unified,
-			returnType: unified[0]
+			argTypes: unified$1,
+			returnType: unified$1[0]
 		};
 	}
 	if (lhsC && rhsC) {
@@ -223,5 +224,6 @@ const bitShiftRight = dualImpl({
 		return stitch`(${lhs} >> ${rhs})`;
 	}
 });
+
 //#endregion
-export { add, bitShiftLeft, bitShiftRight, div, mod, mul, neg, sub };
+export { add, bitShiftLeft, bitShiftRight, div, mod, mul, neg, sub };

package/std/packing.d.ts

@@ -2,25 +2,26 @@ import { DualFn } from "../types.js";
 import { v2f, v4f } from "../data/wgslTypes.js";
 
 //#region src/std/packing.d.ts
+
 /**
  * @privateRemarks
  * https://gpuweb.github.io/gpuweb/wgsl/#unpack2x16float-builtin
  */
-declare const unpack2x16float: DualFn;
+declare const unpack2x16float: DualFn<(e: number) => v2f>;
 /**
  * @privateRemarks
  * https://gpuweb.github.io/gpuweb/wgsl/#pack2x16float-builtin
  */
-declare const pack2x16float: DualFn;
+declare const pack2x16float: DualFn<(e: v2f) => number>;
 /**
  * @privateRemarks
  * https://gpuweb.github.io/gpuweb/wgsl/#unpack4x8unorm-builtin
  */
-declare const unpack4x8unorm: DualFn;
+declare const unpack4x8unorm: DualFn<(e: number) => v4f>;
 /**
  * @privateRemarks
  * https://gpuweb.github.io/gpuweb/wgsl/#pack4x8unorm-builtin
  */
-declare const pack4x8unorm: DualFn;
+declare const pack4x8unorm: DualFn<(e: v4f) => number>;
 //#endregion
 export { pack2x16float, pack4x8unorm, unpack2x16float, unpack4x8unorm };

package/std/packing.js

@@ -3,6 +3,7 @@ import { u32 } from "../data/numeric.js";
 import { vec2f, vec4f } from "../data/vector.js";
 import { dualImpl } from "../core/function/dualImpl.js";
 import * as TB from "typed-binary";
+
 //#region src/std/packing.ts
 /**
 * @privateRemarks
@@ -80,5 +81,6 @@ const pack4x8unorm = dualImpl({
 	},
 	codegenImpl: (_ctx, [e]) => stitch`pack4x8unorm(${e})`
 });
+
 //#endregion
-export { pack2x16float, pack4x8unorm, unpack2x16float, unpack4x8unorm };
+export { pack2x16float, pack4x8unorm, unpack2x16float, unpack4x8unorm };

package/std/range.d.ts

@@ -1,4 +1,6 @@
 import { TgpuComptime } from "../core/function/comptime.js";
+import "../indexNamedExports.js";
+
 //#region src/std/range.d.ts
 interface TgpuRange extends Array<number> {
   start: number;
@@ -19,6 +21,6 @@ interface TgpuRange extends Array<number> {
  *
  * Can also be combined with `tgpu.unroll` to unroll a specific number of iterations.
  */
-declare const range: TgpuComptime;
+declare const range: TgpuComptime<((end: number) => TgpuRange) & ((start: number, end?: number, step?: number) => TgpuRange)>;
 //#endregion
 export { range };

package/std/range.js

@@ -1,4 +1,5 @@
 import { comptime } from "../core/function/comptime.js";
+
 //#region src/std/range.ts
 /**
 * Returns an array of values between `start` (inclusive) and `end` (exclusive) with the given `step`.
@@ -34,5 +35,6 @@ const range = comptime((start, end, step = 1) => {
 function isTgpuRange(value) {
 	return Array.isArray(value) && "start" in value && "end" in value && "step" in value;
 }
+
 //#endregion
-export { isTgpuRange, range };
+export { isTgpuRange, range };

package/std/subgroup.d.ts

@@ -22,26 +22,26 @@ interface IdentityNumOrVecWithMask {
   (e: number, mask: number): number;
   <T extends AnyNumericVecInstance>(e: T, mask: number): T;
 }
-declare const subgroupAdd: DualFn;
-declare const subgroupExclusiveAdd: DualFn;
-declare const subgroupInclusiveAdd: DualFn;
-declare const subgroupAll: DualFn;
-declare const subgroupAnd: DualFn;
-declare const subgroupAny: DualFn;
-declare const subgroupBallot: DualFn;
-declare const subgroupBroadcast: DualFn;
-declare const subgroupBroadcastFirst: DualFn;
-declare const subgroupElect: DualFn;
-declare const subgroupMax: DualFn;
-declare const subgroupMin: DualFn;
-declare const subgroupMul: DualFn;
-declare const subgroupExclusiveMul: DualFn;
-declare const subgroupInclusiveMul: DualFn;
-declare const subgroupOr: DualFn;
-declare const subgroupShuffle: DualFn;
-declare const subgroupShuffleDown: DualFn;
-declare const subgroupShuffleUp: DualFn;
-declare const subgroupShuffleXor: DualFn;
-declare const subgroupXor: DualFn;
+declare const subgroupAdd: DualFn<IdentityNumOrVec>;
+declare const subgroupExclusiveAdd: DualFn<IdentityNumOrVec>;
+declare const subgroupInclusiveAdd: DualFn<IdentityNumOrVec>;
+declare const subgroupAll: DualFn<(e: boolean) => boolean>;
+declare const subgroupAnd: DualFn<IdentityIntNumOrVec>;
+declare const subgroupAny: DualFn<(e: boolean) => boolean>;
+declare const subgroupBallot: DualFn<(e: boolean) => v4u>;
+declare const subgroupBroadcast: DualFn<IdentityNumOrVecWithIdx>;
+declare const subgroupBroadcastFirst: DualFn<IdentityNumOrVec>;
+declare const subgroupElect: DualFn<() => boolean>;
+declare const subgroupMax: DualFn<IdentityNumOrVec>;
+declare const subgroupMin: DualFn<IdentityNumOrVec>;
+declare const subgroupMul: DualFn<IdentityNumOrVec>;
+declare const subgroupExclusiveMul: DualFn<IdentityNumOrVec>;
+declare const subgroupInclusiveMul: DualFn<IdentityNumOrVec>;
+declare const subgroupOr: DualFn<IdentityIntNumOrVec>;
+declare const subgroupShuffle: DualFn<IdentityNumOrVecWithIdx>;
+declare const subgroupShuffleDown: DualFn<IdentityNumOrVecWithDelta>;
+declare const subgroupShuffleUp: DualFn<IdentityNumOrVecWithDelta>;
+declare const subgroupShuffleXor: DualFn<IdentityNumOrVecWithMask>;
+declare const subgroupXor: DualFn<IdentityIntNumOrVec>;
 //#endregion
 export { subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor };

package/std/subgroup.js

@@ -3,6 +3,7 @@ import { unify } from "../tgsl/conversion.js";
 import { bool, i32, u32 } from "../data/numeric.js";
 import { vec4u } from "../data/vector.js";
 import { dualImpl } from "../core/function/dualImpl.js";
+
 //#region src/std/subgroup.ts
 const errorMessage = "Subgroup operations can only be used in the GPU context.";
 const subgroupAdd = dualImpl({
@@ -214,5 +215,6 @@ const subgroupXor = dualImpl({
 	normalImpl: errorMessage,
 	codegenImpl: (_ctx, [e]) => stitch`subgroupXor(${e})`
 });
+
 //#endregion
-export { subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor };
+export { subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor };