typegpu 0.12.4 → 0.12.6

package/std/numeric.js

@@ -6,7 +6,7 @@ import { abstractFloat, abstractInt, f16, f32, i32, u32 } from "../data/numeric.
 import { abstruct } from "../data/struct.js";
 import { vec2f, vec2h, vec2i, vec2u, vec3f, vec3h, vec3i, vec3u, vec4f, vec4h, vec4i, vec4u, } from "../data/vector.js";
 import { VectorOps } from "../data/vectorOps.js";
-import { generalizeFn, upCast } from "../data/generalizeFn.js";
+import { floatKind, matrixKind, numericKind, signedKind, crossKind, assertEqualKinds, assertKind, upCast, generalizeFn, } from "../data/generalizeFn.js";
 import { isHalfPrecisionSchema, WORKAROUND_getSchema, } from "../data/wgslTypes.js";
 import { SignatureNotSupportedError } from "../errors.js";
 import { assertExhaustive } from "../shared/utilityTypes.js";
@@ -26,7 +26,7 @@ const variadicUnifySignature = (...args) => {
         returnType: uargs[0],
     };
 };
-const unifyRestrictedSignature = (restrict) => (...args) => {
+export const unifyRestrictedSignature = (restrict) => (...args) => {
     const uargs = unify(args, restrict);
     if (!uargs) {
         throw new SignatureNotSupportedError(args, restrict);
@@ -61,6 +61,7 @@ const anyConcreteIntegerPrimitive = [i32, u32];
 const anyConcreteIntegerVec = [vec2i, vec3i, vec4i, vec2u, vec3u, vec4u];
 const anyConcreteInteger = [...anyConcreteIntegerPrimitive, ...anyConcreteIntegerVec];
 function cpuAbs(value) {
+    assertKind(value, numericKind);
     return generalizeFn(Math.abs, [value]);
 }
 export const abs = dualImpl({
@@ -71,6 +72,7 @@ export const abs = dualImpl({
     sideEffects: false,
 });
 function cpuAcos(value) {
+    assertKind(value, floatKind);
     return generalizeFn(Math.acos, [value]);
 }
 export const acos = dualImpl({
@@ -81,6 +83,7 @@ export const acos = dualImpl({
     sideEffects: false,
 });
 function cpuAcosh(value) {
+    assertKind(value, floatKind);
     return generalizeFn(Math.acosh, [value]);
 }
 export const acosh = dualImpl({
@@ -91,6 +94,7 @@ export const acosh = dualImpl({
     sideEffects: false,
 });
 function cpuAsin(value) {
+    assertKind(value, floatKind);
     return generalizeFn(Math.asin, [value]);
 }
 export const asin = dualImpl({
@@ -101,6 +105,7 @@ export const asin = dualImpl({
     sideEffects: false,
 });
 function cpuAsinh(value) {
+    assertKind(value, floatKind);
     return generalizeFn(Math.asinh, [value]);
 }
 export const asinh = dualImpl({
@@ -111,6 +116,7 @@ export const asinh = dualImpl({
     sideEffects: false,
 });
 function cpuAtan(value) {
+    assertKind(value, floatKind);
     return generalizeFn(Math.atan, [value]);
 }
 export const atan = dualImpl({
@@ -121,6 +127,7 @@ export const atan = dualImpl({
     sideEffects: false,
 });
 function cpuAtanh(value) {
+    assertKind(value, floatKind);
     return generalizeFn(Math.atanh, [value]);
 }
 export const atanh = dualImpl({
@@ -131,6 +138,8 @@ export const atanh = dualImpl({
     sideEffects: false,
 });
 function cpuAtan2(y, x) {
+    assertKind([y, x], floatKind);
+    assertEqualKinds(y, x);
     return generalizeFn(Math.atan2, [y, x]);
 }
 export const atan2 = dualImpl({
@@ -141,6 +150,7 @@ export const atan2 = dualImpl({
     sideEffects: false,
 });
 function cpuCeil(value) {
+    assertKind(value, floatKind);
     return generalizeFn(Math.ceil, [value]);
 }
 export const ceil = dualImpl({
@@ -151,6 +161,8 @@ export const ceil = dualImpl({
     sideEffects: false,
 });
 function cpuClamp(value, low, high) {
+    assertKind([value, low, high], numericKind);
+    assertEqualKinds(value, low, high);
     return generalizeFn(clampScalar, [value, low, high]);
 }
 export const clamp = dualImpl({
@@ -161,6 +173,7 @@ export const clamp = dualImpl({
     sideEffects: false,
 });
 function cpuCos(value) {
+    assertKind(value, floatKind);
     return generalizeFn(Math.cos, [value]);
 }
 export const cos = dualImpl({
@@ -171,6 +184,7 @@ export const cos = dualImpl({
     sideEffects: false,
 });
 function cpuCosh(value) {
+    assertKind(value, floatKind);
     return generalizeFn(Math.cosh, [value]);
 }
 export const cosh = dualImpl({
@@ -213,11 +227,16 @@ export const countTrailingZeros = dualImpl({
 export const cross = dualImpl({
     name: 'cross',
     signature: unifyRestrictedSignature([vec3f, vec3h]),
-    normalImpl: (a, b) => VectorOps.cross[a.kind](a, b),
+    normalImpl: (a, b) => {
+        assertKind([a, b], crossKind);
+        assertEqualKinds(a, b);
+        return VectorOps.cross[a.kind](a, b);
+    },
     codegenImpl: (_ctx, [a, b]) => stitch `cross(${a}, ${b})`,
     sideEffects: false,
 });
 function cpuDegrees(value) {
+    assertKind(value, floatKind);
     if (typeof value === 'number') {
         return ((value * 180) / Math.PI);
     }
@@ -243,6 +262,8 @@ export const determinant = dualImpl({
     sideEffects: false,
 });
 function cpuDistance(a, b) {
+    assertKind([a, b], floatKind);
+    assertEqualKinds(a, b);
     if (typeof a === 'number' && typeof b === 'number') {
         return Math.abs(a - b);
     }
@@ -270,7 +291,11 @@ export const dot = dualImpl({
         argTypes: args,
         returnType: args[0].primitive,
     }),
-    normalImpl: (lhs, rhs) => VectorOps.dot[lhs.kind](lhs, rhs),
+    normalImpl: (lhs, rhs) => {
+        assertKind([lhs, rhs], numericKind, true);
+        assertEqualKinds(lhs, rhs);
+        return VectorOps.dot[lhs.kind](lhs, rhs);
+    },
     codegenImpl: (_ctx, [lhs, rhs]) => stitch `dot(${lhs}, ${rhs})`,
     sideEffects: false,
 });
@@ -289,6 +314,7 @@ export const dot4I8Packed = dualImpl({
     sideEffects: false,
 });
 function cpuExp(value) {
+    assertKind(value, floatKind);
     return generalizeFn(Math.exp, [value]);
 }
 export const exp = dualImpl({
@@ -299,6 +325,7 @@ export const exp = dualImpl({
     sideEffects: false,
 });
 function cpuExp2(value) {
+    assertKind(value, floatKind);
     return generalizeFn((val) => 2 ** val, [value]);
 }
 export const exp2 = dualImpl({
@@ -355,6 +382,7 @@ export const firstTrailingBit = dualImpl({
     sideEffects: false,
 });
 function cpuFloor(value) {
+    assertKind(value, floatKind);
     return generalizeFn(Math.floor, [value]);
 }
 export const floor = dualImpl({
@@ -365,6 +393,8 @@ export const floor = dualImpl({
     sideEffects: false,
 });
 function cpuFma(e1, e2, e3) {
+    assertKind([e1, e2, e3], floatKind);
+    assertEqualKinds(e1, e2, e3);
     if (typeof e1 === 'number') {
         return (e1 * e2 + e3);
     }
@@ -378,6 +408,7 @@ export const fma = dualImpl({
     sideEffects: false,
 });
 function cpuFract(value) {
+    assertKind(value, floatKind);
     return generalizeFn((value) => value - Math.floor(value), [value]);
 }
 export const fract = dualImpl({
@@ -431,6 +462,7 @@ export const insertBits = dualImpl({
     sideEffects: false,
 });
 function cpuInverseSqrt(value) {
+    assertKind(value, floatKind);
     if (typeof value === 'number') {
         return (1 / Math.sqrt(value));
     }
@@ -440,7 +472,7 @@ export const inverseSqrt = dualImpl({
     name: 'inverseSqrt',
     signature: unifyRestrictedSignature(anyFloat),
     normalImpl: cpuInverseSqrt,
-    codegenImpl: (_ctx, [value]) => stitch `inverseSqrt(${value})`,
+    codegenImpl: (ctx, [value]) => ctx.gen.emitCall('inverseSqrt', [], [value]),
     sideEffects: false,
 });
 function cpuLdexp(_e1, _e2) {
@@ -473,6 +505,7 @@ export const ldexp = dualImpl({
     sideEffects: false,
 });
 function cpuLength(value) {
+    assertKind(value, floatKind);
     if (typeof value === 'number') {
         return Math.abs(value);
     }
@@ -495,6 +528,7 @@ export const length = dualImpl({
     sideEffects: false,
 });
 function cpuLog(value) {
+    assertKind(value, floatKind);
     return generalizeFn(Math.log, [value]);
 }
 export const log = dualImpl({
@@ -505,6 +539,7 @@ export const log = dualImpl({
     sideEffects: false,
 });
 function cpuLog2(value) {
+    assertKind(value, floatKind);
     return generalizeFn(Math.log2, [value]);
 }
 export const log2 = dualImpl({
@@ -515,6 +550,8 @@ export const log2 = dualImpl({
     sideEffects: false,
 });
 function cpuMax(a, b) {
+    assertKind([a, b], numericKind);
+    assertEqualKinds(a, b);
     return generalizeFn(Math.max, [a, b]);
 }
 export const max = dualImpl({
@@ -525,6 +562,8 @@ export const max = dualImpl({
     sideEffects: false,
 });
 function cpuMin(a, b) {
+    assertKind([a, b], numericKind);
+    assertEqualKinds(a, b);
     return generalizeFn(Math.min, [a, b]);
 }
 export const min = dualImpl({
@@ -535,6 +574,13 @@ export const min = dualImpl({
     sideEffects: false,
 });
 function cpuMix(e1, e2, e3) {
+    assertKind([e1, e2, e3], floatKind);
+    if (typeof e3 === 'number') {
+        assertEqualKinds(e1, e2);
+    }
+    else {
+        assertEqualKinds(e1, e2, e3);
+    }
     return generalizeFn((e1, e2, e3) => e1 * (1 - e3) + e2 * e3, [e1, ...upCast([e2, e3])]);
 }
 export const mix = dualImpl({
@@ -588,6 +634,7 @@ export const normalize = dualImpl({
     name: 'normalize',
     signature: unifyRestrictedSignature(anyFloatVec),
     normalImpl: (v) => {
+        assertKind(v, floatKind);
         const len = length(v);
         return generalizeFn((e) => e / len, [v]);
     },
@@ -595,6 +642,8 @@ export const normalize = dualImpl({
     sideEffects: false,
 });
 function powCpu(base, exponent) {
+    assertKind([base, exponent], floatKind);
+    assertEqualKinds(base, exponent);
     return generalizeFn((a, b) => a ** b, [base, exponent]);
 }
 export const pow = dualImpl({
@@ -622,6 +671,7 @@ export const quantizeToF16 = dualImpl({
     sideEffects: false,
 });
 function cpuRadians(value) {
+    assertKind(value, floatKind);
     if (typeof value === 'number') {
         return ((value * Math.PI) / 180);
     }
@@ -646,7 +696,11 @@ export const reflect = dualImpl({
             returnType: uargs[0],
         };
     },
-    normalImpl: (e1, e2) => sub(e1, mul(2 * dot(e2, e1), e2)),
+    normalImpl: (e1, e2) => {
+        assertKind([e1, e2], floatKind, true);
+        assertEqualKinds(e1, e2);
+        return sub(e1, mul(2 * dot(e2, e1), e2));
+    },
     codegenImpl: (_ctx, [e1, e2]) => stitch `reflect(${e1}, ${e2})`,
     sideEffects: false,
 });
@@ -671,6 +725,7 @@ export const reverseBits = dualImpl({
     sideEffects: false,
 });
 function cpuRound(value) {
+    assertKind(value, floatKind);
     if (typeof value === 'number') {
         const floor = Math.floor(value);
         if (value === floor + 0.5) {
@@ -691,6 +746,7 @@ export const round = dualImpl({
     sideEffects: false,
 });
 function cpuSaturate(value) {
+    assertKind(value, floatKind);
     if (typeof value === 'number') {
         return Math.max(0, Math.min(1, value));
     }
@@ -704,6 +760,7 @@ export const saturate = dualImpl({
     sideEffects: false,
 });
 function cpuSign(e) {
+    assertKind(e, signedKind);
     return generalizeFn(Math.sign, [e]);
 }
 export const sign = dualImpl({
@@ -721,6 +778,7 @@ export const sign = dualImpl({
     sideEffects: false,
 });
 function cpuSin(value) {
+    assertKind(value, floatKind);
     return generalizeFn(Math.sin, [value]);
 }
 export const sin = dualImpl({
@@ -731,6 +789,7 @@ export const sin = dualImpl({
     sideEffects: false,
 });
 function cpuSinh(value) {
+    assertKind(value, floatKind);
     return generalizeFn(Math.sinh, [value]);
 }
 export const sinh = dualImpl({
@@ -741,6 +800,8 @@ export const sinh = dualImpl({
     sideEffects: false,
 });
 function cpuSmoothstep(edge0, edge1, x) {
+    assertKind([edge0, edge1, x], floatKind);
+    assertEqualKinds(edge0, edge1, x);
     return generalizeFn(smoothstepScalar, [edge0, edge1, x]);
 }
 export const smoothstep = dualImpl({
@@ -751,6 +812,7 @@ export const smoothstep = dualImpl({
     sideEffects: false,
 });
 function cpuSqrt(value) {
+    assertKind(value, floatKind);
     return generalizeFn(Math.sqrt, [value]);
 }
 export const sqrt = dualImpl({
@@ -761,6 +823,8 @@ export const sqrt = dualImpl({
     sideEffects: false,
 });
 function cpuStep(edge, x) {
+    assertKind([edge, x], floatKind);
+    assertEqualKinds(edge, x);
     if (typeof edge === 'number') {
         return (edge <= x ? 1.0 : 0.0);
     }
@@ -774,6 +838,7 @@ export const step = dualImpl({
     sideEffects: false,
 });
 function cpuTan(value) {
+    assertKind(value, floatKind);
     if (typeof value === 'number') {
         return Math.tan(value);
     }
@@ -787,6 +852,7 @@ export const tan = dualImpl({
     sideEffects: false,
 });
 function cpuTanh(value) {
+    assertKind(value, floatKind);
     return generalizeFn(Math.tanh, [value]);
 }
 export const tanh = dualImpl({
@@ -797,6 +863,7 @@ export const tanh = dualImpl({
     sideEffects: false,
 });
 function cpuTranspose(value) {
+    assertKind(value, matrixKind);
     const schema = WORKAROUND_getSchema(value);
     // NOTE: This assumes all matrices are square
     const transposed = schema();
@@ -879,9 +946,9 @@ function cpuIntdiv(lhs, rhs) {
 export const intdiv = dualImpl({
     name: 'intdiv',
     signature: (lhs, rhs) => {
-        const unified = unify([lhs, rhs], [u32, i32]);
+        const unified = unify([lhs, rhs], [i32, u32]);
         if (!unified) {
-            throw new SignatureNotSupportedError([lhs, rhs], [u32, i32, abstractInt]);
+            throw new SignatureNotSupportedError([lhs, rhs], [i32, u32, abstractInt]);
         }
         return { argTypes: unified, returnType: unified[0] };
     },

package/std/operators.d.ts

@@ -1,4 +1,4 @@
-import { type AnyIntegerVecInstance, type AnyMatInstance, type AnyNumericVecInstance, type mBaseForVec, type vBaseForMat, type vecIToVecU } from '../data/wgslTypes.ts';
+import { type AnyIntegerVecInstance, type AnyMatInstance, type AnyNumericVecInstance, type AnySignedVecInstance, type mBaseForVec, type vBaseForMat, type vecIToVecU } from '../data/wgslTypes.ts';
 type NumVec = AnyNumericVecInstance;
 type Mat = AnyMatInstance;
 declare function cpuAdd(lhs: number, rhs: number): number;
@@ -39,7 +39,7 @@ type ModOverload = {
  */
 export declare const mod: import("../types.ts").DualFn<ModOverload>;
 declare function cpuNeg(value: number): number;
-declare function cpuNeg<T extends NumVec>(value: T): T;
+declare function cpuNeg<T extends AnySignedVecInstance>(value: T): T;
 export declare const neg: import("../types.ts").DualFn<typeof cpuNeg>;
 declare function cpuBitShiftLeft<T extends AnyIntegerVecInstance>(lhs: T, rhs: number | vecIToVecU<T>): T;
 export declare const bitShiftLeft: import("../types.ts").DualFn<typeof cpuBitShiftLeft>;

package/std/operators.js

@@ -3,9 +3,9 @@ import { stitch } from "../core/resolve/stitch.js";
 import { abstractFloat, f16, f32, u32 } from "../data/numeric.js";
 import { vec2i, vec2u, vec3i, vec3u, vec4i, vec4u } from "../data/vector.js";
 import { VectorOps } from "../data/vectorOps.js";
-import { generalizeFn, upCast } from "../data/generalizeFn.js";
-import { isFloat32VecInstance, isInteger32VecInstance, isMat, isMatInstance, isUint32VecInstance, isVec, isVecInstance, } from "../data/wgslTypes.js";
-import { SignatureNotSupportedError } from "../errors.js";
+import { generalizeFn, kindOf, numericKind, numericOrMatrixKind, signedKind, upCast, assertEqualKinds, assertKind, } from "../data/generalizeFn.js";
+import { isFloat32VecInstance, isMat, isMatInstance, isVec, isVecInstance, isInteger32VecInstance, isUint32VecInstance, } from "../data/wgslTypes.js";
+import { SignatureNotSupportedError, WgslTypeError } from "../errors.js";
 import { unify } from "../tgsl/conversion.js";
 const getPrimitive = (t) => ('primitive' in t ? t.primitive : t);
 const makeBinarySignature = (opts) => (lhs, rhs) => {
@@ -56,19 +56,15 @@ const binaryDivSignature = makeBinarySignature({
     restrict: [f32, f16, abstractFloat],
 });
 function cpuAdd(lhs, rhs) {
-    if (typeof lhs === 'number' && typeof rhs === 'number') {
-        return lhs + rhs; // default addition
-    }
-    if (typeof lhs === 'number' && isVecInstance(rhs)) {
-        return generalizeFn((e) => lhs + e, [rhs]); // mixed addition
-    }
-    if (isVecInstance(lhs) && typeof rhs === 'number') {
-        return generalizeFn((e) => e + rhs, [lhs]); // mixed addition
+    assertKind([lhs, rhs], numericOrMatrixKind);
+    if (isMatInstance(lhs) !== isMatInstance(rhs)) {
+        throw new WgslTypeError('There is no matrix/non-matrix addition or subtraction in WGSL.');
     }
-    if ((isVecInstance(lhs) && isVecInstance(rhs)) || (isMatInstance(lhs) && isMatInstance(rhs))) {
-        return generalizeFn((a, b) => a + b, [lhs, rhs]); // component-wise addition
+    if ((typeof lhs === 'number') === (typeof rhs === 'number')) {
+        // If exactly one is a number, then it's fine, since we already know the other one is not a matrix.
+        assertEqualKinds(lhs, rhs);
     }
-    throw new Error('Add/Sub called with invalid arguments.');
+    return generalizeFn((a, b) => a + b, upCast([lhs, rhs]));
 }
 export const add = dualImpl({
     name: 'add',
@@ -89,6 +85,7 @@ export const sub = dualImpl({
     sideEffects: false,
 });
 function cpuMul(lhs, rhs) {
+    assertKind([lhs, rhs], numericOrMatrixKind);
     if (typeof lhs === 'number' && typeof rhs === 'number') {
         return lhs * rhs; // default multiplication
     }
@@ -99,18 +96,26 @@ function cpuMul(lhs, rhs) {
         return generalizeFn((e) => e * rhs, [lhs]); // scale
     }
     if (isVecInstance(lhs) && isVecInstance(rhs)) {
+        assertEqualKinds(lhs, rhs);
         return generalizeFn((a, b) => a * b, [lhs, rhs]); // component-wise
     }
     if (isFloat32VecInstance(lhs) && isMatInstance(rhs)) {
+        if (lhs.length !== rhs.columns.length) {
+            throw new WgslTypeError(`Unsupported signature. Kind '${kindOf(lhs)}' cannot be multiplied by '${kindOf(rhs)}'.`);
+        }
         return VectorOps.mulVxM[rhs.kind](lhs, rhs); // row-vector-matrix
     }
     if (isMatInstance(lhs) && isFloat32VecInstance(rhs)) {
+        if (lhs.columns.length !== rhs.length) {
+            throw new WgslTypeError(`Unsupported signature. Kind '${kindOf(lhs)}' cannot be multiplied by '${kindOf(rhs)}'.`);
+        }
         return VectorOps.mulMxV[lhs.kind](lhs, rhs); // matrix-column-vector
     }
     if (isMatInstance(lhs) && isMatInstance(rhs)) {
+        assertEqualKinds(lhs, rhs);
         return VectorOps.mulMxM[lhs.kind](lhs, rhs); // matrix multiplication
     }
-    throw new Error('Mul called with invalid arguments.');
+    throw new WgslTypeError(`Unsupported signature. Kind '${kindOf(lhs)}' cannot be multiplied by '${kindOf(rhs)}'.`);
 }
 export const mul = dualImpl({
     name: 'mul',
@@ -120,7 +125,10 @@ export const mul = dualImpl({
     sideEffects: false,
 });
 function cpuDiv(lhs, rhs) {
-    return generalizeFn((a, b) => a / b, upCast([lhs, rhs]));
+    assertKind([lhs, rhs], numericKind);
+    const cast = upCast([lhs, rhs]);
+    assertEqualKinds(...cast);
+    return generalizeFn((a, b) => a / b, cast);
 }
 export const div = dualImpl({
     name: 'div',
@@ -138,12 +146,16 @@ export const mod = dualImpl({
     name: 'mod',
     signature: binaryDivSignature,
     normalImpl: ((a, b) => {
-        return generalizeFn((a, b) => a % b, upCast([a, b]));
+        assertKind([a, b], numericKind);
+        const cast = upCast([a, b]);
+        assertEqualKinds(...cast);
+        return generalizeFn((a, b) => a % b, cast);
     }),
     codegenImpl: (ctx, [lhs, rhs]) => ctx.gen.emitBinaryOp(lhs, '%', rhs),
     sideEffects: false,
 });
 function cpuNeg(value) {
+    assertKind(value, signedKind);
     return generalizeFn((value) => -value, [value]);
 }
 export const neg = dualImpl({

package/std/packing.d.ts

@@ -1,4 +1,4 @@
-import type { v2f, v4f } from '../data/wgslTypes.ts';
+import type { v2f, v4f, v4i, v4u } from '../data/wgslTypes.ts';
 /**
  * @privateRemarks
  * https://gpuweb.github.io/gpuweb/wgsl/#unpack2x16float-builtin
@@ -9,13 +9,73 @@ export declare const unpack2x16float: import("../types.ts").DualFn<(e: number) =
  * https://gpuweb.github.io/gpuweb/wgsl/#pack2x16float-builtin
  */
 export declare const pack2x16float: import("../types.ts").DualFn<(e: v2f) => number>;
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#pack2x16snorm-builtin
+ */
+export declare const pack2x16snorm: import("../types.ts").DualFn<(e: v2f) => number>;
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#pack2x16unorm-builtin
+ */
+export declare const pack2x16unorm: import("../types.ts").DualFn<(e: v2f) => number>;
 /**
  * @privateRemarks
  * https://gpuweb.github.io/gpuweb/wgsl/#unpack4x8unorm-builtin
  */
 export declare const unpack4x8unorm: import("../types.ts").DualFn<(e: number) => v4f>;
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#unpack4x8snorm-builtin
+ */
+export declare const unpack4x8snorm: import("../types.ts").DualFn<(e: number) => v4f>;
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#unpack4xi8-builtin
+ */
+export declare const unpack4xI8: import("../types.ts").DualFn<(e: number) => v4i>;
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#unpack4xu8-builtin
+ */
+export declare const unpack4xU8: import("../types.ts").DualFn<(e: number) => v4u>;
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#unpack2x16snorm-builtin
+ */
+export declare const unpack2x16snorm: import("../types.ts").DualFn<(e: number) => v2f>;
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#unpack2x16unorm-builtin
+ */
+export declare const unpack2x16unorm: import("../types.ts").DualFn<(e: number) => v2f>;
 /**
  * @privateRemarks
  * https://gpuweb.github.io/gpuweb/wgsl/#pack4x8unorm-builtin
  */
 export declare const pack4x8unorm: import("../types.ts").DualFn<(e: v4f) => number>;
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#pack4x8snorm-builtin
+ */
+export declare const pack4x8snorm: import("../types.ts").DualFn<(e: v4f) => number>;
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#pack4xi8-builtin
+ */
+export declare const pack4xI8: import("../types.ts").DualFn<(e: v4i) => number>;
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#pack4xu8-builtin
+ */
+export declare const pack4xU8: import("../types.ts").DualFn<(e: v4u) => number>;
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#pack4xi8clamp-builtin
+ */
+export declare const pack4xI8Clamp: import("../types.ts").DualFn<(e: v4i) => number>;
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#pack4xu8clamp-builtin
+ */
+export declare const pack4xU8Clamp: import("../types.ts").DualFn<(e: v4u) => number>;