typegpu 0.6.0 → 0.7.1

package/std/index.d.cts

@@ -1,145 +1,297 @@
-import { c_ as TgpuDualFn, c$ as AnyNumericVecInstance, d0 as AnyMatInstance, d1 as vBaseForMat, d2 as mBaseForVec, d3 as AnyFloatVecInstance, bF as v3f, d4 as v3h, bB as v2f, d5 as v2h, bC as v2i, bG as v3i, bJ as v4f, d6 as v4h, bK as v4i, bv as m4x4f, bn as AnyVecInstance, d7 as AnyVec2Instance, bA as v2b, d8 as AnyVec3Instance, bE as v3b, bI as v4b, d9 as AnyBooleanVecInstance, da as atomicI32, db as atomicU32, ai as TgpuSampledTexture, dc as TgpuStorageTexture, bD as v2u, bH as v3u, dd as TexelData, bL as v4u, de as ChannelData, ar as TgpuSampler } from '../tgpuComputeFn-DOUjhQua.cjs';
-export { i as identity2, d as identity3, e as identity4, r as rotationX4, f as rotationY4, g as rotationZ4, s as scaling4, t as translation4 } from '../matrix-BN6ObiMv.cjs';
+import { c_ as DualFn, c$ as AnyNumericVecInstance, d0 as AnyFloatVecInstance, d1 as AnyIntegerVecInstance, bD as v3f, d2 as v3h, d3 as AnyMatInstance, I as Infer, aQ as WgslStruct, aM as F32, aN as I32, aL as F16, d4 as AbstractFloat, d5 as AbstractInt, aT as Vec2f, aV as Vec2i, aY as Vec3f, a_ as Vec3i, b1 as Vec4f, b3 as Vec4i, aU as Vec2h, aZ as Vec3h, b2 as Vec4h, bA as v2i, bE as v3i, bI as v4i, d6 as AnyFloat32VecInstance, d7 as AnySignedVecInstance, d8 as vBaseForMat, d9 as mBaseForVec, bt as m4x4f, bl as AnyVecInstance, da as AnyVec2Instance, by as v2b, db as AnyVec3Instance, bC as v3b, bG as v4b, dc as AnyBooleanVecInstance, dd as atomicI32, de as atomicU32, bH as v4f, bz as v2f, ag as TgpuSampledTexture, df as TgpuStorageTexture, bB as v2u, bF as v3u, dg as TexelData, bJ as v4u, dh as ChannelData, ao as TgpuSampler } from '../tgpuConstant-BSgcF4zi.cjs';
+export { i as identity2, d as identity3, e as identity4, r as rotationX4, f as rotationY4, g as rotationZ4, s as scaling4, t as translation4 } from '../matrix-4h_aOtIE.cjs';
 import 'tinyest';
 
-declare const discard: TgpuDualFn<() => never>;
+declare const discard: DualFn<() => never>;
 
-type NumVec = AnyNumericVecInstance;
-type Mat = AnyMatInstance;
-declare function cpuAdd(lhs: number, rhs: number): number;
-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: TgpuDualFn<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: TgpuDualFn<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;
-declare function cpuMul<V extends NumVec>(lhs: V, rhs: V): V;
-declare function cpuMul<M extends Mat, V extends vBaseForMat<M>>(lhs: V, rhs: M): V;
-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: TgpuDualFn<typeof cpuMul>;
-declare function cpuDiv(lhs: number, rhs: number): number;
-declare function cpuDiv<MV extends NumVec>(lhs: number, rhs: MV): MV;
-declare function cpuDiv<MV extends NumVec>(lhs: MV, rhs: number): MV;
-declare function cpuDiv<V extends NumVec>(lhs: V, rhs: V): V;
-declare function cpuDiv<Lhs extends number | NumVec, Rhs extends (Lhs extends number ? number | NumVec : Lhs extends NumVec ? number | Lhs : never)>(lhs: Lhs, rhs: Rhs): Lhs | Rhs;
-declare const div: TgpuDualFn<typeof cpuDiv>;
-declare const abs: TgpuDualFn<(<T extends NumVec | number>(value: T) => T)>;
-declare const atan2: TgpuDualFn<(<T extends AnyFloatVecInstance | number>(y: T, x: T) => T)>;
-declare const acos: TgpuDualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
+type NumVec$1 = AnyNumericVecInstance;
+declare const abs: DualFn<(<T extends NumVec$1 | number>(value: T) => T)>;
+declare const acos: DualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
 /**
  * @privateRemarks
  * https://www.w3.org/TR/WGSL/#acosh-builtin
  */
-declare const acosh: TgpuDualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
+declare const acosh: DualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
 /**
  * @privateRemarks
  * https://www.w3.org/TR/WGSL/#asin-builtin
  */
-declare const asin: TgpuDualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
+declare const asin: DualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#asinh-builtin
+ */
+declare const asinh: DualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#atan-builtin
+ */
+declare const atan: DualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#atanh-builtin
+ */
+declare const atanh: DualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
+declare const atan2: DualFn<(<T extends AnyFloatVecInstance | number>(y: T, x: T) => T)>;
 /**
  * @privateRemarks
  * https://www.w3.org/TR/WGSL/#ceil-builtin
  */
-declare const ceil: TgpuDualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
+declare const ceil: DualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
 /**
  * @privateRemarks
  * https://www.w3.org/TR/WGSL/#clamp
  */
-declare const clamp: TgpuDualFn<(<T extends NumVec | number>(value: T, low: T, high: T) => T)>;
+declare const clamp: DualFn<(<T extends NumVec$1 | number>(value: T, low: T, high: T) => T)>;
 /**
  * @privateRemarks
  * https://www.w3.org/TR/WGSL/#cos-builtin
  */
-declare const cos: TgpuDualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
+declare const cos: DualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
 /**
  * @privateRemarks
  * https://www.w3.org/TR/WGSL/#cosh-builtin
  */
-declare const cosh: TgpuDualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
+declare const cosh: DualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
+declare const countLeadingZeros: DualFn<(<T extends AnyIntegerVecInstance | number>(value: T) => T)>;
+declare const countOneBits: DualFn<(<T extends AnyIntegerVecInstance | number>(value: T) => T)>;
+declare const countTrailingZeros: DualFn<(<T extends AnyIntegerVecInstance | number>(value: T) => T)>;
 /**
  * @privateRemarks
  * https://www.w3.org/TR/WGSL/#cross-builtin
  */
-declare const cross: TgpuDualFn<(<T extends v3f | v3h>(a: T, b: T) => T)>;
+declare const cross: DualFn<(<T extends v3f | v3h>(a: T, b: T) => T)>;
+declare const degrees: DualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
+declare const determinant: DualFn<(value: AnyMatInstance) => number>;
+declare const distance: DualFn<(<T extends AnyFloatVecInstance | number>(a: T, b: T) => number)>;
 /**
  * @privateRemarks
  * https://www.w3.org/TR/WGSL/#dot-builtin
  */
-declare const dot: TgpuDualFn<(<T extends NumVec>(lhs: T, rhs: T) => number)>;
-declare const normalize: TgpuDualFn<(<T extends AnyFloatVecInstance>(v: T) => T)>;
+declare const dot: DualFn<(<T extends NumVec$1>(lhs: T, rhs: T) => number)>;
+declare const dot4U8Packed: DualFn<(e1: number, e2: number) => number>;
+declare const dot4I8Packed: DualFn<(e1: number, e2: number) => number>;
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#exp-builtin
+ */
+declare const exp: DualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#exp2-builtin
+ */
+declare const exp2: DualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
+declare const extractBits: DualFn<(<T extends AnyIntegerVecInstance | number>(e: T, offset: number, count: number) => T)>;
+declare const faceForward: DualFn<(<T extends AnyFloatVecInstance>(e1: T, e2: T, e3: T) => T)>;
+declare const firstLeadingBit: DualFn<(<T extends AnyIntegerVecInstance | number>(value: T) => T)>;
+declare const firstTrailingBit: DualFn<(<T extends AnyIntegerVecInstance | number>(value: T) => T)>;
 /**
  * @privateRemarks
  * https://www.w3.org/TR/WGSL/#floor-builtin
  */
-declare const floor: TgpuDualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
-declare const fract: TgpuDualFn<(<T extends AnyFloatVecInstance | number>(a: T) => T)>;
+declare const floor: DualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
+declare const fma: DualFn<(<T extends AnyFloatVecInstance | number>(e1: T, e2: T, e3: T) => T)>;
+declare const fract: DualFn<(<T extends AnyFloatVecInstance | number>(a: T) => T)>;
+declare const FrexpResults: {
+    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: FrexpOverload;
+declare const insertBits: DualFn<(<T extends AnyIntegerVecInstance | number>(e: T, newbits: T, offset: number, count: number) => T)>;
+declare const inverseSqrt: DualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
+type FloatVecInstanceToIntVecInstance<T extends AnyFloatVecInstance> = {
+    'vec2f': v2i;
+    'vec3f': v3i;
+    'vec4f': v4i;
+    'vec2h': v2i;
+    'vec3h': v3i;
+    'vec4h': v4i;
+}[T['kind']];
+type LdexpOverload = {
+    (e1: number, e2: number): number;
+    <T extends AnyFloatVecInstance>(e1: T, e2: FloatVecInstanceToIntVecInstance<T>): T;
+};
+declare const ldexp: LdexpOverload;
 /**
  * @privateRemarks
  * https://www.w3.org/TR/WGSL/#length-builtin
  */
-declare const length: TgpuDualFn<(<T extends AnyFloatVecInstance | number>(value: T) => number)>;
+declare const length: DualFn<(<T extends AnyFloatVecInstance | number>(value: T) => number)>;
 /**
  * @privateRemarks
  * https://www.w3.org/TR/WGSL/#log-builtin
  */
-declare const log: TgpuDualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
+declare const log: DualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
 /**
  * @privateRemarks
  * https://www.w3.org/TR/WGSL/#log2-builtin
  */
-declare const log2: TgpuDualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
+declare const log2: DualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
 /**
  * @privateRemarks
  * https://www.w3.org/TR/WGSL/#max-float-builtin
  */
-declare const max: TgpuDualFn<(<T extends NumVec | number>(a: T, b: T) => T)>;
+declare const max: DualFn<(<T extends NumVec$1 | number>(a: T, b: T) => T)>;
 /**
  * @privateRemarks
  * https://www.w3.org/TR/WGSL/#min-float-builtin
  */
-declare const min: TgpuDualFn<(<T extends NumVec | number>(a: T, b: T) => T)>;
-declare const sign: TgpuDualFn<(<T extends v2f | v2h | v2i | v3f | v3h | v3i | v4f | v4h | v4i | number>(e: T) => T)>;
+declare const min: DualFn<(<T extends NumVec$1 | number>(a: T, b: T) => T)>;
+type MixOverload = {
+    (e1: number, e2: number, e3: number): number;
+    <T extends AnyFloatVecInstance>(e1: T, e2: T, e3: number): T;
+    <T extends AnyFloatVecInstance>(e1: T, e2: T, e3: T): T;
+};
+declare const mix: MixOverload;
+declare const ModfResult: {
+    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<(<T extends AnyFloatVecInstance>(v: T) => T)>;
+type PowOverload = {
+    (base: number, exponent: number): number;
+    <T extends AnyFloatVecInstance>(base: T, exponent: T): T;
+};
+declare const pow: PowOverload;
+declare const quantizeToF16: DualFn<(<T extends AnyFloat32VecInstance | number>(value: T) => T)>;
+declare const radians: DualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
+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 const reverseBits: DualFn<(<T extends AnyIntegerVecInstance | number>(value: T) => T)>;
+declare const round: DualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
+declare const saturate: DualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
+declare const sign: DualFn<(<T extends AnySignedVecInstance | number>(e: T) => T)>;
 /**
  * @privateRemarks
  * https://www.w3.org/TR/WGSL/#sin-builtin
  */
-declare const sin: TgpuDualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
-/**
- * @privateRemarks
- * https://www.w3.org/TR/WGSL/#exp-builtin
- */
-declare const exp: TgpuDualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
+declare const sin: DualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
+declare const sinh: DualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
+declare const smoothstep: DualFn<(<T extends AnyFloatVecInstance | number>(edge0: T, edge1: T, x: T) => T)>;
+declare const sqrt: DualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
+declare const step: DualFn<(<T extends AnyFloatVecInstance | number>(edge: T, x: T) => T)>;
+declare const tan: DualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
+declare const tanh: DualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
+declare const transpose: DualFn<(e: AnyMatInstance) => never>;
+declare const trunc: DualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
+
+type NumVec = AnyNumericVecInstance;
+type Mat = AnyMatInstance;
+declare function cpuAdd(lhs: number, rhs: number): number;
+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<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<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;
+declare function cpuMul<V extends NumVec>(lhs: V, rhs: V): V;
+declare function cpuMul<M extends Mat, V extends vBaseForMat<M>>(lhs: V, rhs: M): V;
+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<typeof cpuMul>;
+declare function cpuDiv(lhs: number, rhs: number): number;
+declare function cpuDiv<T extends NumVec | number>(lhs: T, rhs: T): T;
+declare function cpuDiv<T extends NumVec | number>(lhs: number, rhs: T): T;
+declare function cpuDiv<T extends NumVec | number>(lhs: T, rhs: number): T;
+declare const div: DualFn<typeof cpuDiv>;
+type ModOverload = {
+    (a: number, b: number): number;
+    <T extends NumVec>(a: T, b: T): T;
+    <T extends NumVec>(a: number, b: T): T;
+    <T extends NumVec>(a: T, b: number): T;
+};
 /**
  * @privateRemarks
- * https://www.w3.org/TR/WGSL/#exp2-builtin
+ * Both JS and WGSL implementations use truncated definition of modulo
  */
-declare const exp2: TgpuDualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
-type PowOverload = {
-    (base: number, exponent: number): number;
-    <T extends AnyFloatVecInstance>(base: T, exponent: T): T;
-};
-declare const pow: PowOverload;
-type MixOverload = {
-    (e1: number, e2: number, e3: number): number;
-    <T extends AnyFloatVecInstance>(e1: T, e2: T, e3: number): T;
-    <T extends AnyFloatVecInstance>(e1: T, e2: T, e3: T): T;
-};
-declare const mix: MixOverload;
-declare const reflect: TgpuDualFn<(<T extends AnyFloatVecInstance>(e1: T, e2: T) => T)>;
-declare const distance: TgpuDualFn<(<T extends AnyFloatVecInstance | number>(a: T, b: T) => number)>;
-declare const neg: TgpuDualFn<(<T extends NumVec | number>(value: T) => T)>;
-declare const sqrt: TgpuDualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
-declare const tanh: TgpuDualFn<(<T extends AnyFloatVecInstance | number>(value: T) => T)>;
+declare const mod: ModOverload;
+declare const neg: DualFn<(<T extends NumVec | number>(value: T) => T)>;
 
 /**
  * Translates the given 4-by-4 matrix by the given vector.
@@ -147,35 +299,35 @@ declare const tanh: TgpuDualFn<(<T extends AnyFloatVecInstance | number>(value:
  * @param {v3f} vector - The vector by which to translate the matrix.
  * @returns {m4x4f} The translated matrix.
  */
-declare const translate4: TgpuDualFn<(matrix: m4x4f, vector: v3f) => m4x4f>;
+declare const translate4: DualFn<(matrix: m4x4f, vector: v3f) => m4x4f>;
 /**
  * Scales the given 4-by-4 matrix in each dimension by an amount given by the corresponding entry in the given vector.
  * @param {m4x4f} matrix - The matrix to be modified.
  * @param {v3f} vector - A vector of three entries specifying the factor by which to scale in each dimension.
  * @returns {m4x4f} The scaled matrix.
  */
-declare const scale4: TgpuDualFn<(matrix: m4x4f, vector: v3f) => m4x4f>;
+declare const scale4: DualFn<(matrix: m4x4f, vector: v3f) => m4x4f>;
 /**
  * Rotates the given 4-by-4 matrix around the x-axis by the given angle.
  * @param {m4x4f} matrix - The matrix to be modified.
  * @param {number} angle - The angle by which to rotate (in radians).
  * @returns {m4x4f} The rotated matrix.
  */
-declare const rotateX4: TgpuDualFn<(matrix: m4x4f, angle: number) => m4x4f>;
+declare const rotateX4: DualFn<(matrix: m4x4f, angle: number) => m4x4f>;
 /**
  * Rotates the given 4-by-4 matrix around the y-axis by the given angle.
  * @param {m4x4f} matrix - The matrix to be modified.
  * @param {number} angle - The angle by which to rotate (in radians).
  * @returns {m4x4f} The rotated matrix.
  */
-declare const rotateY4: TgpuDualFn<(matrix: m4x4f, angle: number) => m4x4f>;
+declare const rotateY4: DualFn<(matrix: m4x4f, angle: number) => m4x4f>;
 /**
  * Rotates the given 4-by-4 matrix around the z-axis by the given angle.
  * @param {m4x4f} matrix - The matrix to be modified.
  * @param {number} angle - The angle by which to rotate (in radians).
  * @returns {m4x4f} The rotated matrix.
  */
-declare const rotateZ4: TgpuDualFn<(matrix: m4x4f, angle: number) => m4x4f>;
+declare const rotateZ4: DualFn<(matrix: m4x4f, angle: number) => m4x4f>;
 
 /**
  * Checks whether `lhs == rhs` on all components.
@@ -184,7 +336,7 @@ declare const rotateZ4: TgpuDualFn<(matrix: m4x4f, angle: number) => m4x4f>;
  * allEq(vec2f(0.0, 1.0), vec2f(0.0, 2.0)) // returns false
  * allEq(vec3u(0, 1, 2), vec3u(0, 1, 2)) // returns true
  */
-declare const allEq: TgpuDualFn<(<T extends AnyVecInstance>(lhs: T, rhs: T) => boolean)>;
+declare const allEq: DualFn<(<T extends AnyVecInstance>(lhs: T, rhs: T) => boolean)>;
 /**
  * Checks **component-wise** whether `lhs == rhs`.
  * This function does **not** return `bool`, for that use-case, wrap the result in `all`, or use `allEq`.
@@ -194,7 +346,7 @@ declare const allEq: TgpuDualFn<(<T extends AnyVecInstance>(lhs: T, rhs: T) => b
  * all(eq(vec4i(4, 3, 2, 1), vec4i(4, 3, 2, 1))) // returns true
  * allEq(vec4i(4, 3, 2, 1), vec4i(4, 3, 2, 1)) // returns true
  */
-declare const eq: TgpuDualFn<(<T extends AnyVecInstance>(lhs: T, rhs: T) => T extends AnyVec2Instance ? v2b : T extends AnyVec3Instance ? v3b : v4b)>;
+declare const eq: DualFn<(<T extends AnyVecInstance>(lhs: T, rhs: T) => T extends AnyVec2Instance ? v2b : T extends AnyVec3Instance ? v3b : v4b)>;
 /**
  * Checks **component-wise** whether `lhs != rhs`.
  * This function does **not** return `bool`, for that use-case, wrap the result in `any`.
@@ -203,7 +355,7 @@ declare const eq: TgpuDualFn<(<T extends AnyVecInstance>(lhs: T, rhs: T) => T ex
  * ne(vec3u(0, 1, 2), vec3u(2, 1, 0)) // returns vec3b(true, false, true)
  * any(ne(vec4i(4, 3, 2, 1), vec4i(4, 2, 2, 1))) // returns true
  */
-declare const ne: TgpuDualFn<(<T extends AnyVecInstance>(lhs: T, rhs: T) => T extends AnyVec2Instance ? v2b : T extends AnyVec3Instance ? v3b : v4b)>;
+declare const ne: DualFn<(<T extends AnyVecInstance>(lhs: T, rhs: T) => T extends AnyVec2Instance ? v2b : T extends AnyVec3Instance ? v3b : v4b)>;
 /**
  * Checks **component-wise** whether `lhs < rhs`.
  * This function does **not** return `bool`, for that use-case, wrap the result in `all`.
@@ -212,7 +364,7 @@ declare const ne: TgpuDualFn<(<T extends AnyVecInstance>(lhs: T, rhs: T) => T ex
  * lt(vec3u(0, 1, 2), vec3u(2, 1, 0)) // returns vec3b(true, false, false)
  * all(lt(vec4i(1, 2, 3, 4), vec4i(2, 3, 4, 5))) // returns true
  */
-declare const lt: TgpuDualFn<(<T extends AnyNumericVecInstance>(lhs: T, rhs: T) => T extends AnyVec2Instance ? v2b : T extends AnyVec3Instance ? v3b : v4b)>;
+declare const lt: DualFn<(<T extends AnyNumericVecInstance>(lhs: T, rhs: T) => T extends AnyVec2Instance ? v2b : T extends AnyVec3Instance ? v3b : v4b)>;
 /**
  * Checks **component-wise** whether `lhs <= rhs`.
  * This function does **not** return `bool`, for that use-case, wrap the result in `all`.
@@ -221,7 +373,7 @@ declare const lt: TgpuDualFn<(<T extends AnyNumericVecInstance>(lhs: T, rhs: T)
  * le(vec3u(0, 1, 2), vec3u(2, 1, 0)) // returns vec3b(true, true, false)
  * all(le(vec4i(1, 2, 3, 4), vec4i(2, 3, 3, 5))) // returns true
  */
-declare const le: TgpuDualFn<(<T extends AnyNumericVecInstance>(lhs: T, rhs: T) => T extends AnyVec2Instance ? v2b : T extends AnyVec3Instance ? v3b : v4b)>;
+declare const le: DualFn<(<T extends AnyNumericVecInstance>(lhs: T, rhs: T) => T extends AnyVec2Instance ? v2b : T extends AnyVec3Instance ? v3b : v4b)>;
 /**
  * Checks **component-wise** whether `lhs > rhs`.
  * This function does **not** return `bool`, for that use-case, wrap the result in `all`.
@@ -230,7 +382,7 @@ declare const le: TgpuDualFn<(<T extends AnyNumericVecInstance>(lhs: T, rhs: T)
  * gt(vec3u(0, 1, 2), vec3u(2, 1, 0)) // returns vec3b(false, false, true)
  * all(gt(vec4i(2, 3, 4, 5), vec4i(1, 2, 3, 4))) // returns true
  */
-declare const gt: TgpuDualFn<(<T extends AnyNumericVecInstance>(lhs: T, rhs: T) => T extends AnyVec2Instance ? v2b : T extends AnyVec3Instance ? v3b : v4b)>;
+declare const gt: DualFn<(<T extends AnyNumericVecInstance>(lhs: T, rhs: T) => T extends AnyVec2Instance ? v2b : T extends AnyVec3Instance ? v3b : v4b)>;
 /**
  * Checks **component-wise** whether `lhs >= rhs`.
  * This function does **not** return `bool`, for that use-case, wrap the result in `all`.
@@ -239,42 +391,42 @@ declare const gt: TgpuDualFn<(<T extends AnyNumericVecInstance>(lhs: T, rhs: T)
  * ge(vec3u(0, 1, 2), vec3u(2, 1, 0)) // returns vec3b(false, true, true)
  * all(ge(vec4i(2, 2, 4, 5), vec4i(1, 2, 3, 4))) // returns true
  */
-declare const ge: TgpuDualFn<(<T extends AnyNumericVecInstance>(lhs: T, rhs: T) => T extends AnyVec2Instance ? v2b : T extends AnyVec3Instance ? v3b : v4b)>;
+declare const ge: DualFn<(<T extends AnyNumericVecInstance>(lhs: T, rhs: T) => T extends AnyVec2Instance ? v2b : T extends AnyVec3Instance ? v3b : v4b)>;
 /**
  * Returns **component-wise** `!value`.
  * @example
  * not(vec2b(false, true)) // returns vec2b(true, false)
  * not(vec3b(true, true, false)) // returns vec3b(false, false, true)
  */
-declare const not: TgpuDualFn<(<T extends AnyBooleanVecInstance>(value: T) => T)>;
+declare const not: DualFn<(<T extends AnyBooleanVecInstance>(value: T) => T)>;
 /**
  * Returns **component-wise** logical `or` result.
  * @example
  * or(vec2b(false, true), vec2b(false, false)) // returns vec2b(false, true)
  * or(vec3b(true, true, false), vec3b(false, true, false)) // returns vec3b(true, true, false)
  */
-declare const or: TgpuDualFn<(<T extends AnyBooleanVecInstance>(lhs: T, rhs: T) => T)>;
+declare const or: DualFn<(<T extends AnyBooleanVecInstance>(lhs: T, rhs: T) => T)>;
 /**
  * Returns **component-wise** logical `and` result.
  * @example
  * and(vec2b(false, true), vec2b(true, true)) // returns vec2b(false, true)
  * and(vec3b(true, true, false), vec3b(false, true, false)) // returns vec3b(false, true, false)
  */
-declare const and: TgpuDualFn<(<T extends AnyBooleanVecInstance>(lhs: T, rhs: T) => T)>;
+declare const and: DualFn<(<T extends AnyBooleanVecInstance>(lhs: T, rhs: T) => T)>;
 /**
  * Returns `true` if each component of `value` is true.
  * @example
  * all(vec2b(false, true)) // returns false
  * all(vec3b(true, true, true)) // returns true
  */
-declare const all: TgpuDualFn<(value: AnyBooleanVecInstance) => boolean>;
+declare const all: DualFn<(value: AnyBooleanVecInstance) => boolean>;
 /**
  * Returns `true` if any component of `value` is true.
  * @example
  * any(vec2b(false, true)) // returns true
  * any(vec3b(false, false, false)) // returns false
  */
-declare const any: TgpuDualFn<(value: AnyBooleanVecInstance) => boolean>;
+declare const any: DualFn<(value: AnyBooleanVecInstance) => boolean>;
 /**
  * Checks whether the given elements differ by at most the `precision` value.
  * Checks all elements of `lhs` and `rhs` if arguments are vectors.
@@ -284,7 +436,7 @@ declare const any: TgpuDualFn<(value: AnyBooleanVecInstance) => boolean>;
  *
  * @param {number} precision argument that specifies the maximum allowed difference, 0.01 by default.
  */
-declare const isCloseTo: TgpuDualFn<(<T extends AnyFloatVecInstance | number>(lhs: T, rhs: T, precision?: number) => boolean)>;
+declare const isCloseTo: DualFn<(<T extends AnyFloatVecInstance | number>(lhs: T, rhs: T, precision?: number) => boolean)>;
 type SelectOverload = {
     <T extends number | boolean | AnyVecInstance>(f: T, t: T, cond: boolean): T;
     <T extends AnyVecInstance>(f: T, t: T, cond: T extends AnyVec2Instance ? v2b : T extends AnyVec3Instance ? v3b : v4b): T;
@@ -301,41 +453,51 @@ type SelectOverload = {
 declare const select: SelectOverload;
 
 type AnyAtomic = atomicI32 | atomicU32;
-declare const workgroupBarrier: TgpuDualFn<() => void>;
-declare const storageBarrier: TgpuDualFn<() => void>;
-declare const textureBarrier: TgpuDualFn<() => void>;
-declare const atomicLoad: TgpuDualFn<(<T extends AnyAtomic>(a: T) => number)>;
-declare const atomicStore: TgpuDualFn<(<T extends AnyAtomic>(a: T, value: number) => void)>;
-declare const atomicAdd: TgpuDualFn<(<T extends AnyAtomic>(a: T, value: number) => number)>;
-declare const atomicSub: TgpuDualFn<(<T extends AnyAtomic>(a: T, value: number) => number)>;
-declare const atomicMax: TgpuDualFn<(<T extends AnyAtomic>(a: T, value: number) => number)>;
-declare const atomicMin: TgpuDualFn<(<T extends AnyAtomic>(a: T, value: number) => number)>;
-declare const atomicAnd: TgpuDualFn<(<T extends AnyAtomic>(a: T, value: number) => number)>;
-declare const atomicOr: TgpuDualFn<(<T extends AnyAtomic>(a: T, value: number) => number)>;
-declare const atomicXor: TgpuDualFn<(<T extends AnyAtomic>(a: T, value: number) => number)>;
+declare const workgroupBarrier: DualFn<() => void>;
+declare const storageBarrier: DualFn<() => void>;
+declare const textureBarrier: DualFn<() => void>;
+declare const atomicLoad: DualFn<(<T extends AnyAtomic>(a: T) => number)>;
+declare const atomicStore: DualFn<(<T extends AnyAtomic>(a: T, value: number) => void)>;
+declare const atomicAdd: DualFn<(<T extends AnyAtomic>(a: T, value: number) => number)>;
+declare const atomicSub: DualFn<(<T extends AnyAtomic>(a: T, value: number) => number)>;
+declare const atomicMax: DualFn<(<T extends AnyAtomic>(a: T, value: number) => number)>;
+declare const atomicMin: DualFn<(<T extends AnyAtomic>(a: T, value: number) => number)>;
+declare const atomicAnd: DualFn<(<T extends AnyAtomic>(a: T, value: number) => number)>;
+declare const atomicOr: DualFn<(<T extends AnyAtomic>(a: T, value: number) => number)>;
+declare const atomicXor: DualFn<(<T extends AnyAtomic>(a: T, value: number) => number)>;
+
+declare const dpdx: DualFn<(<T extends AnyFloat32VecInstance | number>(value: T) => T)>;
+declare const dpdxCoarse: DualFn<(<T extends AnyFloat32VecInstance | number>(value: T) => T)>;
+declare const dpdxFine: DualFn<(<T extends AnyFloat32VecInstance | number>(value: T) => T)>;
+declare const dpdy: DualFn<(<T extends AnyFloat32VecInstance | number>(value: T) => T)>;
+declare const dpdyCoarse: DualFn<(<T extends AnyFloat32VecInstance | number>(value: T) => T)>;
+declare const dpdyFine: DualFn<(<T extends AnyFloat32VecInstance | number>(value: T) => T)>;
+declare const fwidth: DualFn<(<T extends AnyFloat32VecInstance | number>(value: T) => T)>;
+declare const fwidthCoarse: DualFn<(<T extends AnyFloat32VecInstance | number>(value: T) => T)>;
+declare const fwidthFine: DualFn<(<T extends AnyFloat32VecInstance | number>(value: T) => T)>;
 
-declare const arrayLength: TgpuDualFn<(a: unknown[]) => number>;
+declare const arrayLength: DualFn<(a: unknown[]) => number>;
 
 /**
  * @privateRemarks
  * https://gpuweb.github.io/gpuweb/wgsl/#unpack2x16float-builtin
  */
-declare const unpack2x16float: TgpuDualFn<(e: number) => v2f>;
+declare const unpack2x16float: DualFn<(e: number) => v2f>;
 /**
  * @privateRemarks
  * https://gpuweb.github.io/gpuweb/wgsl/#pack2x16float-builtin
  */
-declare const pack2x16float: TgpuDualFn<(e: v2f) => number>;
+declare const pack2x16float: DualFn<(e: v2f) => number>;
 /**
  * @privateRemarks
  * https://gpuweb.github.io/gpuweb/wgsl/#unpack4x8unorm-builtin
  */
-declare const unpack4x8unorm: TgpuDualFn<(e: number) => v4f>;
+declare const unpack4x8unorm: DualFn<(e: number) => v4f>;
 /**
  * @privateRemarks
  * https://gpuweb.github.io/gpuweb/wgsl/#pack4x8unorm-builtin
  */
-declare const pack4x8unorm: TgpuDualFn<(e: v4f) => number>;
+declare const pack4x8unorm: DualFn<(e: v4f) => number>;
 
 type TextureSampleOverload = {
     <T extends TgpuSampledTexture<'1d'>>(texture: T, sampler: TgpuSampler, coords: number): v4f;
@@ -393,4 +555,4 @@ type TextureDimensionsOverload = {
 };
 declare const textureDimensions: TextureDimensionsOverload;
 
-export { abs, acos, acosh, add, all, allEq, and, any, arrayLength, asin, atan2, atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, ceil, clamp, cos, cosh, cross, discard, distance, div, dot, eq, exp, exp2, floor, fract, ge, gt, isCloseTo, le, length, log, log2, lt, max, min, mix, mul, ne, neg, normalize, not, or, pack2x16float, pack4x8unorm, pow, reflect, rotateX4, rotateY4, rotateZ4, scale4, select, sign, sin, sqrt, storageBarrier, sub, tanh, textureBarrier, textureDimensions, textureLoad, textureSample, textureSampleLevel, textureStore, translate4, unpack2x16float, unpack4x8unorm, workgroupBarrier };
+export { abs, acos, acosh, add, all, allEq, and, any, arrayLength, asin, asinh, atan, atan2, atanh, atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, ceil, clamp, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, discard, distance, div, dot, dot4I8Packed, dot4U8Packed, dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, eq, exp, exp2, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, fwidth, fwidthCoarse, fwidthFine, ge, gt, insertBits, inverseSqrt, isCloseTo, ldexp, le, length, log, log2, lt, max, min, mix, mod, modf, mul, ne, neg, normalize, not, or, pack2x16float, pack4x8unorm, pow, quantizeToF16, radians, reflect, refract, reverseBits, rotateX4, rotateY4, rotateZ4, round, saturate, scale4, select, sign, sin, sinh, smoothstep, sqrt, step, storageBarrier, sub, tan, tanh, textureBarrier, textureDimensions, textureLoad, textureSample, textureSampleLevel, textureStore, translate4, transpose, trunc, unpack2x16float, unpack4x8unorm, workgroupBarrier };