typegpu 0.9.0 → 0.10.0

package/extensions-0SFbU9FH.js

@@ -0,0 +1,2032 @@
+import { At as stitch, B as vec2h, C as translation4, E as dualImpl, G as vec3h, Gn as isVecInstance, H as vec2u, J as vec4b, K as vec3i, Mt as getResolutionCtx, N as abstruct, Pn as isHalfPrecisionSchema, Q as vec4u, R as vec2b, S as scaling4, T as MissingCpuImplError, U as vec3b, Un as isVec, V as vec2i, Vn as isPtr, W as vec3f, X as vec4h, Y as vec4f, Z as vec4i, _ as mat4x4f, at as i32, b as rotationY4, c as bitcastU32toF32Impl, et as abstractFloat, ft as unify, g as mat3x3f, h as mat2x2f, ht as safeStringify, i as mul, it as f32, jn as isAtomic, kn as Void, l as bitcastU32toI32Impl, mn as snip, nt as bool, o as sub, or as $gpuCallable, pn as isSnippetNumeric, q as vec3u, qn as isWgslArray, rt as f16, s as VectorOps, sn as SignatureNotSupportedError, st as u32, tt as abstractInt, u as smoothstepScalar, w as comptime, wt as ptrFn, x as rotationZ4, xt as isRef, y as rotationX4, z as vec2f } from "./operators-HTxa_0k9.js";
+import { r as isWgslTexture } from "./texture-Dg5ybJro.js";
+import * as TB from "typed-binary";
+
+//#region src/core/texture/textureFormats.ts
+const DEPTH_ASPECT_NON_COPYABLE = {
+	channelType: f32,
+	vectorType: vec4f,
+	sampleTypes: ["depth", "unfilterable-float"],
+	texelSize: "non-copyable"
+};
+const DEPTH_ASPECT_16 = {
+	channelType: f32,
+	vectorType: vec4f,
+	sampleTypes: ["depth", "unfilterable-float"],
+	texelSize: 2
+};
+const DEPTH_ASPECT_32 = {
+	channelType: f32,
+	vectorType: vec4f,
+	sampleTypes: ["depth", "unfilterable-float"],
+	texelSize: 4
+};
+const STENCIL_ASPECT = {
+	channelType: u32,
+	vectorType: vec4u,
+	sampleTypes: ["uint"],
+	texelSize: 1
+};
+const formatInfoCache = /* @__PURE__ */ new Map();
+function getTextureFormatInfo(format) {
+	let info = formatInfoCache.get(format);
+	if (info === void 0) {
+		info = createFormatInfo(format);
+		formatInfoCache.set(format, info);
+	}
+	return info;
+}
+function createFormatInfo(format) {
+	const channelType = parseChannelType(format);
+	const depthAspect = getDepthAspect(format);
+	const hasStencil = format.includes("stencil");
+	return {
+		channelType,
+		vectorType: channelType === u32 ? vec4u : channelType === i32 ? vec4i : vec4f,
+		texelSize: parseTexelSize(format),
+		sampleTypes: parseSampleTypes(format),
+		canRenderAttachment: canRenderAttachment(format),
+		...depthAspect && { depthAspect },
+		...hasStencil && { stencilAspect: STENCIL_ASPECT }
+	};
+}
+function getDepthAspect(format) {
+	if (format === "depth16unorm") return DEPTH_ASPECT_16;
+	if (format === "depth32float" || format === "depth32float-stencil8") return DEPTH_ASPECT_32;
+	if (format === "depth24plus" || format === "depth24plus-stencil8") return DEPTH_ASPECT_NON_COPYABLE;
+}
+function canRenderAttachment(format) {
+	if (format.startsWith("bc") || format.startsWith("etc2") || format.startsWith("eac") || format.startsWith("astc")) return false;
+	if (format === "rgb9e5ufloat") return false;
+	return true;
+}
+function parseChannelType(format) {
+	if (format === "stencil8") return u32;
+	if (format.includes("uint")) return u32;
+	if (format.includes("sint")) return i32;
+	return f32;
+}
+function parseTexelSize(format) {
+	const [, channels, bits] = format.match(/^(rgba|bgra|rg|r)(8|16|32)/) ?? [];
+	if (channels && bits) return channels.length * Number(bits) / 8;
+	if (format === "stencil8") return 1;
+	if (format === "depth16unorm") return 2;
+	if (format === "depth32float") return 4;
+	if (format === "depth32float-stencil8") return 5;
+	if (format === "depth24plus" || format === "depth24plus-stencil8") return "non-copyable";
+	if (/^(bc[14]-|etc2-rgb8|eac-r11)/.test(format)) return 8;
+	if (/^(bc|astc-|etc2-rgba|eac-rg)/.test(format)) return 16;
+	return 4;
+}
+function parseSampleTypes(format) {
+	if (format === "stencil8") return ["uint"];
+	if (format.includes("uint")) return ["uint"];
+	if (format.includes("sint")) return ["sint"];
+	if (format.includes("depth")) return ["depth", "unfilterable-float"];
+	if (/^(r|rg|rgba)16(u|s)norm$/.test(format)) return ["unfilterable-float"];
+	return ["float", "unfilterable-float"];
+}
+const FLOAT32_FORMATS = new Set([
+	"r32float",
+	"rg32float",
+	"rgba32float"
+]);
+function getEffectiveSampleTypes(device, format) {
+	if (FLOAT32_FORMATS.has(format) && !device.features.has("float32-filterable")) return ["unfilterable-float"];
+	return getTextureFormatInfo(format).sampleTypes;
+}
+
+//#endregion
+//#region src/std/numeric.ts
+const unaryIdentitySignature = (arg) => {
+	return {
+		argTypes: [arg],
+		returnType: arg
+	};
+};
+const variadicUnifySignature = (...args) => {
+	const uargs = unify(args) ?? args;
+	return {
+		argTypes: uargs,
+		returnType: uargs[0]
+	};
+};
+const unifyRestrictedSignature = (restrict) => (...args) => {
+	const uargs = unify(args, restrict);
+	if (!uargs) throw new SignatureNotSupportedError(args, restrict);
+	return {
+		argTypes: uargs,
+		returnType: uargs[0]
+	};
+};
+function variadicReduce(fn) {
+	return (fst, ...rest) => {
+		let acc = fst;
+		for (const r of rest) acc = fn(acc, r);
+		return acc;
+	};
+}
+function variadicStitch(wrapper) {
+	return (_ctx, [fst, ...rest]) => {
+		let acc = stitch`${fst}`;
+		for (const r of rest) acc = stitch`${wrapper}(${acc}, ${r})`;
+		return acc;
+	};
+}
+const anyFloatPrimitive = [
+	f32,
+	f16,
+	abstractFloat
+];
+const anyFloatVec = [
+	vec2f,
+	vec3f,
+	vec4f,
+	vec2h,
+	vec3h,
+	vec4h
+];
+const anyFloat = [...anyFloatPrimitive, ...anyFloatVec];
+const anyConcreteIntegerPrimitive = [i32, u32];
+const anyConcreteIntegerVec = [
+	vec2i,
+	vec3i,
+	vec4i,
+	vec2u,
+	vec3u,
+	vec4u
+];
+const anyConcreteInteger = [...anyConcreteIntegerPrimitive, ...anyConcreteIntegerVec];
+function cpuAbs(value) {
+	if (typeof value === "number") return Math.abs(value);
+	return VectorOps.abs[value.kind](value);
+}
+const abs = dualImpl({
+	name: "abs",
+	signature: unaryIdentitySignature,
+	normalImpl: cpuAbs,
+	codegenImpl: (_ctx, [value]) => stitch`abs(${value})`
+});
+function cpuAcos(value) {
+	if (typeof value === "number") return Math.acos(value);
+	return VectorOps.acos[value.kind](value);
+}
+const acos = dualImpl({
+	name: "acos",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuAcos,
+	codegenImpl: (_ctx, [value]) => stitch`acos(${value})`
+});
+function cpuAcosh(value) {
+	if (typeof value === "number") return Math.acosh(value);
+	return VectorOps.acosh[value.kind](value);
+}
+const acosh = dualImpl({
+	name: "acosh",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuAcosh,
+	codegenImpl: (_ctx, [value]) => stitch`acosh(${value})`
+});
+function cpuAsin(value) {
+	if (typeof value === "number") return Math.asin(value);
+	return VectorOps.asin[value.kind](value);
+}
+const asin = dualImpl({
+	name: "asin",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuAsin,
+	codegenImpl: (_ctx, [value]) => stitch`asin(${value})`
+});
+function cpuAsinh(value) {
+	if (typeof value === "number") return Math.asinh(value);
+	return VectorOps.asinh[value.kind](value);
+}
+const asinh = dualImpl({
+	name: "asinh",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuAsinh,
+	codegenImpl: (_ctx, [value]) => stitch`asinh(${value})`
+});
+function cpuAtan(value) {
+	if (typeof value === "number") return Math.atan(value);
+	return VectorOps.atan[value.kind](value);
+}
+const atan = dualImpl({
+	name: "atan",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuAtan,
+	codegenImpl: (_ctx, [value]) => stitch`atan(${value})`
+});
+function cpuAtanh(value) {
+	if (typeof value === "number") return Math.atanh(value);
+	return VectorOps.atanh[value.kind](value);
+}
+const atanh = dualImpl({
+	name: "atanh",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuAtanh,
+	codegenImpl: (_ctx, [value]) => stitch`atanh(${value})`
+});
+function cpuAtan2(y, x) {
+	if (typeof y === "number" && typeof x === "number") return Math.atan2(y, x);
+	return VectorOps.atan2[y.kind](y, x);
+}
+const atan2 = dualImpl({
+	name: "atan2",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuAtan2,
+	codegenImpl: (_ctx, [y, x]) => stitch`atan2(${y}, ${x})`
+});
+function cpuCeil(value) {
+	if (typeof value === "number") return Math.ceil(value);
+	return VectorOps.ceil[value.kind](value);
+}
+const ceil = dualImpl({
+	name: "ceil",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuCeil,
+	codegenImpl: (_ctx, [value]) => stitch`ceil(${value})`
+});
+function cpuClamp(value, low, high) {
+	if (typeof value === "number") return Math.min(Math.max(low, value), high);
+	return VectorOps.clamp[value.kind](value, low, high);
+}
+const clamp = dualImpl({
+	name: "clamp",
+	signature: variadicUnifySignature,
+	normalImpl: cpuClamp,
+	codegenImpl: (_ctx, [value, low, high]) => stitch`clamp(${value}, ${low}, ${high})`
+});
+function cpuCos(value) {
+	if (typeof value === "number") return Math.cos(value);
+	return VectorOps.cos[value.kind](value);
+}
+const cos = dualImpl({
+	name: "cos",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuCos,
+	codegenImpl: (_ctx, [value]) => stitch`cos(${value})`
+});
+function cpuCosh(value) {
+	if (typeof value === "number") return Math.cosh(value);
+	return VectorOps.cosh[value.kind](value);
+}
+const cosh = dualImpl({
+	name: "cosh",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuCosh,
+	codegenImpl: (_ctx, [value]) => stitch`cosh(${value})`
+});
+const countLeadingZeros = dualImpl({
+	name: "countLeadingZeros",
+	signature: unifyRestrictedSignature(anyConcreteInteger),
+	normalImpl: "CPU implementation for countLeadingZeros not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	codegenImpl: (_ctx, [value]) => stitch`countLeadingZeros(${value})`
+});
+const countOneBits = dualImpl({
+	name: "countOneBits",
+	signature: unifyRestrictedSignature(anyConcreteInteger),
+	normalImpl: "CPU implementation for countOneBits not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	codegenImpl: (_ctx, [value]) => stitch`countOneBits(${value})`
+});
+const countTrailingZeros = dualImpl({
+	name: "countTrailingZeros",
+	signature: unifyRestrictedSignature(anyConcreteInteger),
+	normalImpl: "CPU implementation for countTrailingZeros not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	codegenImpl: (_ctx, [value]) => stitch`countTrailingZeros(${value})`
+});
+const cross = dualImpl({
+	name: "cross",
+	signature: unifyRestrictedSignature([vec3f, vec3h]),
+	normalImpl: (a, b) => VectorOps.cross[a.kind](a, b),
+	codegenImpl: (_ctx, [a, b]) => stitch`cross(${a}, ${b})`
+});
+function cpuDegrees(value) {
+	if (typeof value === "number") return value * 180 / Math.PI;
+	throw new MissingCpuImplError("CPU implementation for degrees on vectors not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}
+const degrees = dualImpl({
+	name: "degrees",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuDegrees,
+	codegenImpl: (_ctx, [value]) => stitch`degrees(${value})`
+});
+const determinant = dualImpl({
+	name: "determinant",
+	signature: (arg) => {
+		if (!(arg.type === "mat2x2f" || arg.type === "mat3x3f" || arg.type === "mat4x4f")) throw new SignatureNotSupportedError([arg], [
+			mat2x2f,
+			mat3x3f,
+			mat4x4f
+		]);
+		return {
+			argTypes: [arg],
+			returnType: f32
+		};
+	},
+	normalImpl: "CPU implementation for determinant not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	codegenImpl: (_ctx, [value]) => stitch`determinant(${value})`
+});
+function cpuDistance(a, b) {
+	if (typeof a === "number" && typeof b === "number") return Math.abs(a - b);
+	return length(sub(a, b));
+}
+const distance = dualImpl({
+	name: "distance",
+	signature: (...args) => {
+		const uargs = unify(args, anyFloat);
+		if (!uargs) throw new SignatureNotSupportedError(args, anyFloat);
+		return {
+			argTypes: uargs,
+			returnType: isHalfPrecisionSchema(uargs[0]) ? f16 : f32
+		};
+	},
+	normalImpl: cpuDistance,
+	codegenImpl: (_ctx, [a, b]) => stitch`distance(${a}, ${b})`
+});
+const dot = dualImpl({
+	name: "dot",
+	signature: (...args) => ({
+		argTypes: args,
+		returnType: args[0].primitive
+	}),
+	normalImpl: (lhs, rhs) => VectorOps.dot[lhs.kind](lhs, rhs),
+	codegenImpl: (_ctx, [lhs, rhs]) => stitch`dot(${lhs}, ${rhs})`
+});
+const dot4U8Packed = dualImpl({
+	name: "dot4U8Packed",
+	signature: {
+		argTypes: [u32, u32],
+		returnType: u32
+	},
+	normalImpl: "CPU implementation for dot4U8Packed not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	codegenImpl: (_ctx, [e1, e2]) => stitch`dot4U8Packed(${e1}, ${e2})`
+});
+const dot4I8Packed = dualImpl({
+	name: "dot4I8Packed",
+	signature: {
+		argTypes: [u32, u32],
+		returnType: i32
+	},
+	normalImpl: "CPU implementation for dot4I8Packed not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	codegenImpl: (_ctx, [e1, e2]) => stitch`dot4I8Packed(${e1}, ${e2})`
+});
+function cpuExp(value) {
+	if (typeof value === "number") return Math.exp(value);
+	return VectorOps.exp[value.kind](value);
+}
+const exp = dualImpl({
+	name: "exp",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuExp,
+	codegenImpl: (_ctx, [value]) => stitch`exp(${value})`
+});
+function cpuExp2(value) {
+	if (typeof value === "number") return 2 ** value;
+	return VectorOps.exp2[value.kind](value);
+}
+const exp2 = dualImpl({
+	name: "exp2",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuExp2,
+	codegenImpl: (_ctx, [value]) => stitch`exp2(${value})`
+});
+const extractBits = dualImpl({
+	name: "extractBits",
+	signature: (arg, _offset, _count) => {
+		const argRestricted = unify([arg], anyConcreteInteger)?.[0];
+		if (!argRestricted) throw new SignatureNotSupportedError([arg], anyConcreteInteger);
+		return {
+			argTypes: [
+				argRestricted,
+				u32,
+				u32
+			],
+			returnType: argRestricted
+		};
+	},
+	normalImpl: "CPU implementation for extractBits not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	codegenImpl: (_ctx, [e, offset, count]) => stitch`extractBits(${e}, ${offset}, ${count})`
+});
+const faceForward = dualImpl({
+	name: "faceForward",
+	signature: unifyRestrictedSignature(anyFloatVec),
+	normalImpl: "CPU implementation for faceForward not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	codegenImpl: (_ctx, [e1, e2, e3]) => stitch`faceForward(${e1}, ${e2}, ${e3})`
+});
+const firstLeadingBit = dualImpl({
+	name: "firstLeadingBit",
+	signature: unaryIdentitySignature,
+	normalImpl: "CPU implementation for firstLeadingBit not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	codegenImpl: (_ctx, [value]) => stitch`firstLeadingBit(${value})`
+});
+const firstTrailingBit = dualImpl({
+	name: "firstTrailingBit",
+	signature: unifyRestrictedSignature(anyConcreteInteger),
+	normalImpl: "CPU implementation for firstTrailingBit not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	codegenImpl: (_ctx, [value]) => stitch`firstTrailingBit(${value})`
+});
+function cpuFloor(value) {
+	if (typeof value === "number") return Math.floor(value);
+	return VectorOps.floor[value.kind](value);
+}
+const floor = dualImpl({
+	name: "floor",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuFloor,
+	codegenImpl: (_ctx, [arg]) => stitch`floor(${arg})`
+});
+function cpuFma(e1, e2, e3) {
+	if (typeof e1 === "number") return e1 * e2 + e3;
+	throw new MissingCpuImplError("CPU implementation for fma on vectors not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}
+const fma = dualImpl({
+	name: "fma",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuFma,
+	codegenImpl: (_ctx, [e1, e2, e3]) => stitch`fma(${e1}, ${e2}, ${e3})`
+});
+function cpuFract(value) {
+	if (typeof value === "number") return value - Math.floor(value);
+	return VectorOps.fract[value.kind](value);
+}
+const fract = dualImpl({
+	name: "fract",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuFract,
+	codegenImpl: (_ctx, [a]) => stitch`fract(${a})`
+});
+const FrexpResults = {
+	f32: abstruct({
+		fract: f32,
+		exp: i32
+	}),
+	f16: abstruct({
+		fract: f16,
+		exp: i32
+	}),
+	abstractFloat: abstruct({
+		fract: abstractFloat,
+		exp: abstractInt
+	}),
+	vec2f: abstruct({
+		fract: vec2f,
+		exp: vec2i
+	}),
+	vec3f: abstruct({
+		fract: vec3f,
+		exp: vec3i
+	}),
+	vec4f: abstruct({
+		fract: vec4f,
+		exp: vec4i
+	}),
+	vec2h: abstruct({
+		fract: vec2h,
+		exp: vec2i
+	}),
+	vec3h: abstruct({
+		fract: vec3h,
+		exp: vec3i
+	}),
+	vec4h: abstruct({
+		fract: vec4h,
+		exp: vec4i
+	})
+};
+const frexp = dualImpl({
+	name: "frexp",
+	normalImpl: "CPU implementation for frexp not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	signature: (value) => {
+		const returnType = FrexpResults[value.type];
+		if (!returnType) throw new SignatureNotSupportedError([value], anyFloat);
+		return {
+			argTypes: [value],
+			returnType
+		};
+	},
+	codegenImpl: (_ctx, [value]) => stitch`frexp(${value})`
+});
+const insertBits = dualImpl({
+	name: "insertBits",
+	signature: (e, newbits, _offset, _count) => {
+		const uargs = unify([e, newbits], anyConcreteInteger);
+		if (!uargs) throw new SignatureNotSupportedError([e, newbits], anyConcreteInteger);
+		return {
+			argTypes: [
+				...uargs,
+				u32,
+				u32
+			],
+			returnType: uargs[0]
+		};
+	},
+	normalImpl: "CPU implementation for insertBits not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	codegenImpl: (_ctx, [e, newbits, offset, count]) => stitch`insertBits(${e}, ${newbits}, ${offset}, ${count})`
+});
+function cpuInverseSqrt(value) {
+	if (typeof value === "number") return 1 / Math.sqrt(value);
+	throw new MissingCpuImplError("CPU implementation for inverseSqrt on vectors not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}
+const inverseSqrt = dualImpl({
+	name: "inverseSqrt",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuInverseSqrt,
+	codegenImpl: (_ctx, [value]) => stitch`inverseSqrt(${value})`
+});
+const ldexp = dualImpl({
+	name: "ldexp",
+	signature: (e1, _e2) => {
+		switch (e1.type) {
+			case "abstractFloat": return {
+				argTypes: [e1, abstractInt],
+				returnType: e1
+			};
+			case "f32":
+			case "f16": return {
+				argTypes: [e1, i32],
+				returnType: e1
+			};
+			case "vec2f":
+			case "vec2h": return {
+				argTypes: [e1, vec2i],
+				returnType: e1
+			};
+			case "vec3f":
+			case "vec3h": return {
+				argTypes: [e1, vec3i],
+				returnType: e1
+			};
+			case "vec4f":
+			case "vec4h": return {
+				argTypes: [e1, vec4i],
+				returnType: e1
+			};
+			default: throw new Error(`Unsupported data type for ldexp: ${e1.type}. Supported types are abstractFloat, f32, f16, vec2f, vec2h, vec3f, vec3h, vec4f, vec4h.`);
+		}
+	},
+	normalImpl: "CPU implementation for ldexp not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	codegenImpl: (_ctx, [e1, e2]) => stitch`ldexp(${e1}, ${e2})`
+});
+function cpuLength(value) {
+	if (typeof value === "number") return Math.abs(value);
+	return VectorOps.length[value.kind](value);
+}
+const length = dualImpl({
+	name: "length",
+	signature: (arg) => {
+		const uarg = unify([arg], anyFloat);
+		if (!uarg) throw new SignatureNotSupportedError([arg], anyFloat);
+		return {
+			argTypes: uarg,
+			returnType: isHalfPrecisionSchema(uarg[0]) ? f16 : f32
+		};
+	},
+	normalImpl: cpuLength,
+	codegenImpl: (_ctx, [arg]) => stitch`length(${arg})`
+});
+function cpuLog(value) {
+	if (typeof value === "number") return Math.log(value);
+	return VectorOps.log[value.kind](value);
+}
+const log = dualImpl({
+	name: "log",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuLog,
+	codegenImpl: (_ctx, [value]) => stitch`log(${value})`
+});
+function cpuLog2(value) {
+	if (typeof value === "number") return Math.log2(value);
+	return VectorOps.log2[value.kind](value);
+}
+const log2 = dualImpl({
+	name: "log2",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuLog2,
+	codegenImpl: (_ctx, [value]) => stitch`log2(${value})`
+});
+function cpuMax(a, b) {
+	if (typeof a === "number") return Math.max(a, b);
+	return VectorOps.max[a.kind](a, b);
+}
+const max = dualImpl({
+	name: "max",
+	signature: variadicUnifySignature,
+	normalImpl: variadicReduce(cpuMax),
+	codegenImpl: variadicStitch("max")
+});
+function cpuMin(a, b) {
+	if (typeof a === "number") return Math.min(a, b);
+	return VectorOps.min[a.kind](a, b);
+}
+const min = dualImpl({
+	name: "min",
+	signature: variadicUnifySignature,
+	normalImpl: variadicReduce(cpuMin),
+	codegenImpl: variadicStitch("min")
+});
+function cpuMix(e1, e2, e3) {
+	if (typeof e1 === "number") {
+		if (typeof e3 !== "number" || typeof e2 !== "number") throw new Error("When e1 and e2 are numbers, the blend factor must be a number.");
+		return e1 * (1 - e3) + e2 * e3;
+	}
+	if (typeof e1 === "number" || typeof e2 === "number") throw new Error("e1 and e2 need to both be vectors of the same kind.");
+	return VectorOps.mix[e1.kind](e1, e2, e3);
+}
+const mix = dualImpl({
+	name: "mix",
+	signature: (e1, e2, e3) => {
+		if (e1.type.startsWith("vec") && !e3.type.startsWith("vec")) {
+			const uarg = unify([e3], [e1.primitive]);
+			if (!uarg) throw new SignatureNotSupportedError([e3], [e1.primitive]);
+			return {
+				argTypes: [
+					e1,
+					e2,
+					uarg[0]
+				],
+				returnType: e1
+			};
+		}
+		const uargs = unify([
+			e1,
+			e2,
+			e3
+		], anyFloat);
+		if (!uargs) throw new SignatureNotSupportedError([
+			e1,
+			e2,
+			e3
+		], anyFloat);
+		return {
+			argTypes: uargs,
+			returnType: uargs[0]
+		};
+	},
+	normalImpl: cpuMix,
+	codegenImpl: (_ctx, [e1, e2, e3]) => stitch`mix(${e1}, ${e2}, ${e3})`
+});
+const ModfResult = {
+	f32: abstruct({
+		fract: f32,
+		whole: f32
+	}),
+	f16: abstruct({
+		fract: f16,
+		whole: f16
+	}),
+	abstractFloat: abstruct({
+		fract: abstractFloat,
+		whole: abstractFloat
+	}),
+	vec2f: abstruct({
+		fract: vec2f,
+		whole: vec2f
+	}),
+	vec3f: abstruct({
+		fract: vec3f,
+		whole: vec3f
+	}),
+	vec4f: abstruct({
+		fract: vec4f,
+		whole: vec4f
+	}),
+	vec2h: abstruct({
+		fract: vec2h,
+		whole: vec2h
+	}),
+	vec3h: abstruct({
+		fract: vec3h,
+		whole: vec3h
+	}),
+	vec4h: abstruct({
+		fract: vec4h,
+		whole: vec4h
+	})
+};
+const modf = dualImpl({
+	name: "modf",
+	signature: (e) => {
+		const returnType = ModfResult[e.type];
+		if (!returnType) throw new Error(`Unsupported data type for modf: ${e.type}. Supported types are f32, f16, abstractFloat, vec2f, vec3f, vec4f, vec2h, vec3h, vec4h.`);
+		return {
+			argTypes: [e],
+			returnType
+		};
+	},
+	normalImpl: "CPU implementation for modf not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	codegenImpl: (_ctx, [value]) => stitch`modf(${value})`
+});
+const normalize = dualImpl({
+	name: "normalize",
+	signature: unifyRestrictedSignature(anyFloatVec),
+	normalImpl: (v) => VectorOps.normalize[v.kind](v),
+	codegenImpl: (_ctx, [value]) => stitch`normalize(${value})`
+});
+function powCpu(base, exponent) {
+	if (typeof base === "number" && typeof exponent === "number") return base ** exponent;
+	if (isVecInstance(base) && isVecInstance(exponent)) return VectorOps.pow[base.kind](base, exponent);
+	throw new Error(`Invalid arguments to pow(): '${base}' '${exponent}'`);
+}
+const pow = dualImpl({
+	name: "pow",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: powCpu,
+	codegenImpl: (_ctx, [lhs, rhs]) => stitch`pow(${lhs}, ${rhs})`
+});
+const quantizeToF16 = dualImpl({
+	name: "quantizeToF16",
+	signature: (arg) => {
+		const candidates = [
+			vec2f,
+			vec3f,
+			vec4f,
+			f32
+		];
+		const uarg = unify([arg], candidates)?.[0];
+		if (!uarg) throw new SignatureNotSupportedError([arg], candidates);
+		return {
+			argTypes: [uarg],
+			returnType: uarg
+		};
+	},
+	normalImpl: "CPU implementation for quantizeToF16 not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	codegenImpl: (_ctx, [value]) => stitch`quantizeToF16(${value})`
+});
+function cpuRadians(value) {
+	if (typeof value === "number") return value * Math.PI / 180;
+	throw new MissingCpuImplError("CPU implementation for radians on vectors not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}
+const radians = dualImpl({
+	name: "radians",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuRadians,
+	codegenImpl: (_ctx, [value]) => stitch`radians(${value})`
+});
+const reflect = dualImpl({
+	name: "reflect",
+	signature: (...args) => {
+		const uargs = unify(args, anyFloatVec);
+		if (!uargs) throw new SignatureNotSupportedError(args, anyFloatVec);
+		return {
+			argTypes: uargs,
+			returnType: uargs[0]
+		};
+	},
+	normalImpl: (e1, e2) => sub(e1, mul(2 * dot(e2, e1), e2)),
+	codegenImpl: (_ctx, [e1, e2]) => stitch`reflect(${e1}, ${e2})`
+});
+const refract = dualImpl({
+	name: "refract",
+	normalImpl: "CPU implementation for refract not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	codegenImpl: (_ctx, [e1, e2, e3]) => stitch`refract(${e1}, ${e2}, ${e3})`,
+	signature: (e1, e2, _e3) => ({
+		argTypes: [
+			e1,
+			e2,
+			isHalfPrecisionSchema(e1) ? f16 : f32
+		],
+		returnType: e1
+	})
+});
+const reverseBits = dualImpl({
+	name: "reverseBits",
+	signature: unifyRestrictedSignature(anyConcreteInteger),
+	normalImpl: "CPU implementation for reverseBits not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	codegenImpl: (_ctx, [value]) => stitch`reverseBits(${value})`
+});
+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;
+		}
+		return Math.round(value);
+	}
+	throw new MissingCpuImplError("CPU implementation for round on vectors not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}
+const round = dualImpl({
+	name: "round",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuRound,
+	codegenImpl: (_ctx, [value]) => stitch`round(${value})`
+});
+function cpuSaturate(value) {
+	if (typeof value === "number") return Math.max(0, Math.min(1, value));
+	throw new MissingCpuImplError("CPU implementation for saturate on vectors not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}
+const saturate = dualImpl({
+	name: "saturate",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuSaturate,
+	codegenImpl: (_ctx, [value]) => stitch`saturate(${value})`
+});
+function cpuSign(e) {
+	if (typeof e === "number") return Math.sign(e);
+	return VectorOps.sign[e.kind](e);
+}
+const sign = dualImpl({
+	name: "sign",
+	signature: (arg) => {
+		const candidates = [
+			...anyFloat,
+			i32,
+			vec2i,
+			vec3i,
+			vec4i
+		];
+		const uarg = unify([arg], candidates)?.[0];
+		if (!uarg) throw new SignatureNotSupportedError([arg], candidates);
+		return {
+			argTypes: [uarg],
+			returnType: uarg
+		};
+	},
+	normalImpl: cpuSign,
+	codegenImpl: (_ctx, [e]) => stitch`sign(${e})`
+});
+function cpuSin(value) {
+	if (typeof value === "number") return Math.sin(value);
+	return VectorOps.sin[value.kind](value);
+}
+const sin = dualImpl({
+	name: "sin",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuSin,
+	codegenImpl: (_ctx, [value]) => stitch`sin(${value})`
+});
+function cpuSinh(value) {
+	if (typeof value === "number") return Math.sinh(value);
+	throw new MissingCpuImplError("CPU implementation for sinh on vectors not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}
+const sinh = dualImpl({
+	name: "sinh",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuSinh,
+	codegenImpl: (_ctx, [value]) => stitch`sinh(${value})`
+});
+function cpuSmoothstep(edge0, edge1, x) {
+	if (typeof x === "number") return smoothstepScalar(edge0, edge1, x);
+	return VectorOps.smoothstep[x.kind](edge0, edge1, x);
+}
+const smoothstep = dualImpl({
+	name: "smoothstep",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuSmoothstep,
+	codegenImpl: (_ctx, [edge0, edge1, x]) => stitch`smoothstep(${edge0}, ${edge1}, ${x})`
+});
+function cpuSqrt(value) {
+	if (typeof value === "number") return Math.sqrt(value);
+	return VectorOps.sqrt[value.kind](value);
+}
+const sqrt = dualImpl({
+	name: "sqrt",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuSqrt,
+	codegenImpl: (_ctx, [value]) => stitch`sqrt(${value})`
+});
+function cpuStep(edge, x) {
+	if (typeof edge === "number") return edge <= x ? 1 : 0;
+	throw new MissingCpuImplError("CPU implementation for step on vectors not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}
+const step = dualImpl({
+	name: "step",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuStep,
+	codegenImpl: (_ctx, [edge, x]) => stitch`step(${edge}, ${x})`
+});
+function cpuTan(value) {
+	if (typeof value === "number") return Math.tan(value);
+	throw new MissingCpuImplError("CPU implementation for tan on vectors not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}
+const tan = dualImpl({
+	name: "tan",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuTan,
+	codegenImpl: (_ctx, [value]) => stitch`tan(${value})`
+});
+function cpuTanh(value) {
+	if (typeof value === "number") return Math.tanh(value);
+	return VectorOps.tanh[value.kind](value);
+}
+const tanh = dualImpl({
+	name: "tanh",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuTanh,
+	codegenImpl: (_ctx, [value]) => stitch`tanh(${value})`
+});
+const transpose = dualImpl({
+	name: "transpose",
+	signature: unaryIdentitySignature,
+	normalImpl: "CPU implementation for transpose not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	codegenImpl: (_ctx, [e]) => stitch`transpose(${e})`
+});
+const trunc = dualImpl({
+	name: "trunc",
+	signature: unifyRestrictedSignature(anyFloat),
+	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
+//#region src/std/array.ts
+const sizeOfPointedToArray = (dataType) => isPtr(dataType) && isWgslArray(dataType.inner) ? dataType.inner.elementCount : 0;
+const arrayLength = dualImpl({
+	name: "arrayLength",
+	signature: (arg) => {
+		const ptrArg = isPtr(arg) ? arg : ptrFn(arg);
+		return {
+			argTypes: [ptrArg],
+			returnType: sizeOfPointedToArray(ptrArg) > 0 ? abstractInt : u32
+		};
+	},
+	normalImpl: (a) => isRef(a) ? a.$.length : a.length,
+	codegenImpl(_ctx, [a]) {
+		const length = sizeOfPointedToArray(a.dataType);
+		return length > 0 ? `${length}` : stitch`arrayLength(${a})`;
+	}
+});
+
+//#endregion
+//#region src/std/bitcast.ts
+const bitcastU32toF32 = dualImpl({
+	name: "bitcastU32toF32",
+	normalImpl: ((value) => {
+		if (typeof value === "number") return bitcastU32toF32Impl(value);
+		return VectorOps.bitcastU32toF32[value.kind](value);
+	}),
+	codegenImpl: (_ctx, [n]) => stitch`bitcast<f32>(${n})`,
+	signature: (...arg) => {
+		const uargs = unify(arg, [u32]) ?? arg;
+		return {
+			argTypes: uargs,
+			returnType: isVec(uargs[0]) ? uargs[0].type === "vec2u" ? vec2f : uargs[0].type === "vec3u" ? vec3f : vec4f : f32
+		};
+	}
+});
+const bitcastU32toI32 = dualImpl({
+	name: "bitcastU32toI32",
+	normalImpl: ((value) => {
+		if (typeof value === "number") return bitcastU32toI32Impl(value);
+		return VectorOps.bitcastU32toI32[value.kind](value);
+	}),
+	codegenImpl: (_ctx, [n]) => stitch`bitcast<i32>(${n})`,
+	signature: (...arg) => {
+		const uargs = unify(arg, [u32]) ?? arg;
+		return {
+			argTypes: uargs,
+			returnType: isVec(uargs[0]) ? uargs[0].type === "vec2u" ? vec2i : uargs[0].type === "vec3u" ? vec3i : vec4i : i32
+		};
+	}
+});
+
+//#endregion
+//#region src/std/packing.ts
+/**
+* @privateRemarks
+* https://gpuweb.github.io/gpuweb/wgsl/#unpack2x16float-builtin
+*/
+const unpack2x16float = dualImpl({
+	name: "unpack2x16float",
+	normalImpl: (e) => {
+		const buffer = /* @__PURE__ */ new ArrayBuffer(4);
+		new TB.BufferWriter(buffer).writeUint32(e);
+		const reader = new TB.BufferReader(buffer);
+		return vec2f(reader.readFloat16(), reader.readFloat16());
+	},
+	signature: {
+		argTypes: [u32],
+		returnType: vec2f
+	},
+	codegenImpl: (_ctx, [e]) => stitch`unpack2x16float(${e})`
+});
+/**
+* @privateRemarks
+* https://gpuweb.github.io/gpuweb/wgsl/#pack2x16float-builtin
+*/
+const pack2x16float = dualImpl({
+	name: "pack2x16float",
+	normalImpl: (e) => {
+		const buffer = /* @__PURE__ */ new ArrayBuffer(4);
+		const writer = new TB.BufferWriter(buffer);
+		writer.writeFloat16(e.x);
+		writer.writeFloat16(e.y);
+		return u32(new TB.BufferReader(buffer).readUint32());
+	},
+	signature: {
+		argTypes: [vec2f],
+		returnType: u32
+	},
+	codegenImpl: (_ctx, [e]) => stitch`pack2x16float(${e})`
+});
+/**
+* @privateRemarks
+* https://gpuweb.github.io/gpuweb/wgsl/#unpack4x8unorm-builtin
+*/
+const unpack4x8unorm = dualImpl({
+	name: "unpack4x8unorm",
+	normalImpl: (e) => {
+		const buffer = /* @__PURE__ */ new ArrayBuffer(4);
+		new TB.BufferWriter(buffer).writeUint32(e);
+		const reader = new TB.BufferReader(buffer);
+		return vec4f(reader.readUint8() / 255, reader.readUint8() / 255, reader.readUint8() / 255, reader.readUint8() / 255);
+	},
+	signature: {
+		argTypes: [u32],
+		returnType: vec4f
+	},
+	codegenImpl: (_ctx, [e]) => stitch`unpack4x8unorm(${e})`
+});
+/**
+* @privateRemarks
+* https://gpuweb.github.io/gpuweb/wgsl/#pack4x8unorm-builtin
+*/
+const pack4x8unorm = dualImpl({
+	name: "pack4x8unorm",
+	normalImpl: (e) => {
+		const buffer = /* @__PURE__ */ new ArrayBuffer(4);
+		const writer = new TB.BufferWriter(buffer);
+		writer.writeUint8(e.x * 255);
+		writer.writeUint8(e.y * 255);
+		writer.writeUint8(e.z * 255);
+		writer.writeUint8(e.w * 255);
+		return u32(new TB.BufferReader(buffer).readUint32());
+	},
+	signature: {
+		argTypes: [vec4f],
+		returnType: u32
+	},
+	codegenImpl: (_ctx, [e]) => stitch`pack4x8unorm(${e})`
+});
+
+//#endregion
+//#region src/wgslExtensions.ts
+const wgslExtensions = [
+	"f16",
+	"clip_distances",
+	"dual_source_blending",
+	"subgroups",
+	"primitive_index"
+];
+const wgslExtensionToFeatureName = {
+	f16: "shader-f16",
+	clip_distances: "clip-distances",
+	dual_source_blending: "dual-source-blending",
+	subgroups: "subgroups",
+	primitive_index: "primitive-index"
+};
+
+//#endregion
+//#region src/std/boolean.ts
+function correspondingBooleanVectorSchema(dataType) {
+	if (dataType.type.includes("2")) return vec2b;
+	if (dataType.type.includes("3")) return vec3b;
+	return vec4b;
+}
+/**
+* Checks whether `lhs == rhs` on all components.
+* Equivalent to `all(eq(lhs, rhs))`.
+* @example
+* allEq(vec2f(0.0, 1.0), vec2f(0.0, 2.0)) // returns false
+* allEq(vec3u(0, 1, 2), vec3u(0, 1, 2)) // returns true
+*/
+const allEq = dualImpl({
+	name: "allEq",
+	signature: (...argTypes) => ({
+		argTypes,
+		returnType: bool
+	}),
+	normalImpl: (lhs, rhs) => cpuAll(cpuEq(lhs, rhs)),
+	codegenImpl: (_ctx, [lhs, rhs]) => stitch`all(${lhs} == ${rhs})`
+});
+const cpuEq = (lhs, rhs) => VectorOps.eq[lhs.kind](lhs, rhs);
+/**
+* Checks **component-wise** whether `lhs == rhs`.
+* This function does **not** return `bool`, for that use-case, wrap the result in `all`, or use `allEq`.
+* @example
+* eq(vec2f(0.0, 1.0), vec2f(0.0, 2.0)) // returns vec2b(true, false)
+* eq(vec3u(0, 1, 2), vec3u(2, 1, 0)) // returns vec3b(false, true, false)
+* 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
+*/
+const eq = dualImpl({
+	name: "eq",
+	signature: (...argTypes) => ({
+		argTypes,
+		returnType: correspondingBooleanVectorSchema(argTypes[0])
+	}),
+	normalImpl: cpuEq,
+	codegenImpl: (_ctx, [lhs, rhs]) => stitch`(${lhs} == ${rhs})`
+});
+/**
+* Checks **component-wise** whether `lhs != rhs`.
+* This function does **not** return `bool`, for that use-case, wrap the result in `any`.
+* @example
+* ne(vec2f(0.0, 1.0), vec2f(0.0, 2.0)) // returns vec2b(false, true)
+* 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
+*/
+const ne = dualImpl({
+	name: "ne",
+	signature: (...argTypes) => ({
+		argTypes,
+		returnType: correspondingBooleanVectorSchema(argTypes[0])
+	}),
+	normalImpl: (lhs, rhs) => cpuNot(cpuEq(lhs, rhs)),
+	codegenImpl: (_ctx, [lhs, rhs]) => stitch`(${lhs} != ${rhs})`
+});
+const cpuLt = (lhs, rhs) => VectorOps.lt[lhs.kind](lhs, rhs);
+/**
+* Checks **component-wise** whether `lhs < rhs`.
+* This function does **not** return `bool`, for that use-case, wrap the result in `all`.
+* @example
+* lt(vec2f(0.0, 0.0), vec2f(0.0, 1.0)) // returns vec2b(false, true)
+* 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
+*/
+const lt = dualImpl({
+	name: "lt",
+	signature: (...argTypes) => ({
+		argTypes,
+		returnType: correspondingBooleanVectorSchema(argTypes[0])
+	}),
+	normalImpl: cpuLt,
+	codegenImpl: (_ctx, [lhs, rhs]) => stitch`(${lhs} < ${rhs})`
+});
+/**
+* Checks **component-wise** whether `lhs <= rhs`.
+* This function does **not** return `bool`, for that use-case, wrap the result in `all`.
+* @example
+* le(vec2f(0.0, 0.0), vec2f(0.0, 1.0)) // returns vec2b(true, true)
+* 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
+*/
+const le = dualImpl({
+	name: "le",
+	signature: (...argTypes) => ({
+		argTypes,
+		returnType: correspondingBooleanVectorSchema(argTypes[0])
+	}),
+	normalImpl: (lhs, rhs) => cpuOr(cpuLt(lhs, rhs), cpuEq(lhs, rhs)),
+	codegenImpl: (_ctx, [lhs, rhs]) => stitch`(${lhs} <= ${rhs})`
+});
+/**
+* Checks **component-wise** whether `lhs > rhs`.
+* This function does **not** return `bool`, for that use-case, wrap the result in `all`.
+* @example
+* gt(vec2f(0.0, 0.0), vec2f(0.0, 1.0)) // returns vec2b(false, false)
+* 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
+*/
+const gt = dualImpl({
+	name: "gt",
+	signature: (...argTypes) => ({
+		argTypes,
+		returnType: correspondingBooleanVectorSchema(argTypes[0])
+	}),
+	normalImpl: (lhs, rhs) => cpuAnd(cpuNot(cpuLt(lhs, rhs)), cpuNot(cpuEq(lhs, rhs))),
+	codegenImpl: (_ctx, [lhs, rhs]) => stitch`(${lhs} > ${rhs})`
+});
+/**
+* Checks **component-wise** whether `lhs >= rhs`.
+* This function does **not** return `bool`, for that use-case, wrap the result in `all`.
+* @example
+* ge(vec2f(0.0, 0.0), vec2f(0.0, 1.0)) // returns vec2b(true, false)
+* 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
+*/
+const ge = dualImpl({
+	name: "ge",
+	signature: (...argTypes) => ({
+		argTypes,
+		returnType: correspondingBooleanVectorSchema(argTypes[0])
+	}),
+	normalImpl: (lhs, rhs) => cpuNot(cpuLt(lhs, rhs)),
+	codegenImpl: (_ctx, [lhs, rhs]) => stitch`(${lhs} >= ${rhs})`
+});
+const cpuNot = (value) => VectorOps.neg[value.kind](value);
+/**
+* Returns **component-wise** `!value`.
+* @example
+* not(vec2b(false, true)) // returns vec2b(true, false)
+* not(vec3b(true, true, false)) // returns vec3b(false, false, true)
+*/
+const not = dualImpl({
+	name: "not",
+	signature: (...argTypes) => ({
+		argTypes,
+		returnType: argTypes[0]
+	}),
+	normalImpl: cpuNot,
+	codegenImpl: (_ctx, [arg]) => stitch`!(${arg})`
+});
+const cpuOr = (lhs, rhs) => VectorOps.or[lhs.kind](lhs, rhs);
+/**
+* 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)
+*/
+const or = dualImpl({
+	name: "or",
+	signature: (...argTypes) => ({
+		argTypes,
+		returnType: argTypes[0]
+	}),
+	normalImpl: cpuOr,
+	codegenImpl: (_ctx, [lhs, rhs]) => stitch`(${lhs} | ${rhs})`
+});
+const cpuAnd = (lhs, rhs) => cpuNot(cpuOr(cpuNot(lhs), cpuNot(rhs)));
+/**
+* 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)
+*/
+const and = dualImpl({
+	name: "and",
+	signature: (...argTypes) => ({
+		argTypes,
+		returnType: argTypes[0]
+	}),
+	normalImpl: cpuAnd,
+	codegenImpl: (_ctx, [lhs, rhs]) => stitch`(${lhs} & ${rhs})`
+});
+const cpuAll = (value) => VectorOps.all[value.kind](value);
+/**
+* Returns `true` if each component of `value` is true.
+* @example
+* all(vec2b(false, true)) // returns false
+* all(vec3b(true, true, true)) // returns true
+*/
+const all = dualImpl({
+	name: "all",
+	signature: (...argTypes) => ({
+		argTypes,
+		returnType: bool
+	}),
+	normalImpl: cpuAll,
+	codegenImpl: (_ctx, [value]) => stitch`all(${value})`
+});
+/**
+* Returns `true` if any component of `value` is true.
+* @example
+* any(vec2b(false, true)) // returns true
+* any(vec3b(false, false, false)) // returns false
+*/
+const any = dualImpl({
+	name: "any",
+	signature: (...argTypes) => ({
+		argTypes,
+		returnType: bool
+	}),
+	normalImpl: (value) => !cpuAll(cpuNot(value)),
+	codegenImpl: (_ctx, [arg]) => stitch`any(${arg})`
+});
+/**
+* Checks whether the given elements differ by at most the `precision` value.
+* Checks all elements of `lhs` and `rhs` if arguments are vectors.
+* @example
+* isCloseTo(0, 0.1) // returns false
+* isCloseTo(vec3f(0, 0, 0), vec3f(0.002, -0.009, 0)) // returns true
+*
+* @param {number} precision argument that specifies the maximum allowed difference, 0.01 by default.
+*/
+const isCloseTo = dualImpl({
+	name: "isCloseTo",
+	signature: (...args) => ({
+		argTypes: args,
+		returnType: bool
+	}),
+	normalImpl: (lhs, rhs, precision = .01) => {
+		if (typeof lhs === "number" && typeof rhs === "number") return Math.abs(lhs - rhs) < precision;
+		if (isVecInstance(lhs) && isVecInstance(rhs)) return VectorOps.isCloseToZero[lhs.kind](sub(lhs, rhs), precision);
+		return false;
+	},
+	codegenImpl: (_ctx, [lhs, rhs, precision = snip(.01, f32, "constant")]) => {
+		if (isSnippetNumeric(lhs) && isSnippetNumeric(rhs)) return stitch`(abs(f32(${lhs}) - f32(${rhs})) <= ${precision})`;
+		if (!isSnippetNumeric(lhs) && !isSnippetNumeric(rhs)) return stitch`all(abs(${lhs} - ${rhs}) <= (${lhs} - ${lhs}) + ${precision})`;
+		return "false";
+	}
+});
+function cpuSelect(f, t, cond) {
+	if (typeof cond === "boolean") return cond ? t : f;
+	return VectorOps.select[f.kind](f, t, cond);
+}
+/**
+* Returns `t` if `cond` is `true`, and `f` otherwise.
+* Component-wise if `cond` is a vector.
+* @example
+* select(1, 2, false) // returns 1
+* select(1, 2, true) // returns 2
+* select(vec2i(1, 2), vec2i(3, 4), true) // returns vec2i(3, 4)
+* select(vec2i(1, 2), vec2i(3, 4), vec2b(false, true)) // returns vec2i(1, 4)
+*/
+const select = dualImpl({
+	name: "select",
+	signature: (f, t, cond) => {
+		const [uf, ut] = unify([f, t]) ?? [f, t];
+		return {
+			argTypes: [
+				uf,
+				ut,
+				cond
+			],
+			returnType: uf
+		};
+	},
+	normalImpl: cpuSelect,
+	codegenImpl: (_ctx, [f, t, cond]) => stitch`select(${f}, ${t}, ${cond})`
+});
+
+//#endregion
+//#region src/std/discard.ts
+const discard = dualImpl({
+	name: "discard",
+	normalImpl: "`discard` relies on GPU resources and cannot be executed outside of a draw call",
+	signature: {
+		argTypes: [],
+		returnType: Void
+	},
+	codegenImpl: () => "discard;"
+});
+
+//#endregion
+//#region src/std/matrix.ts
+const gpuTranslation4 = translation4[$gpuCallable].call.bind(translation4);
+const gpuScaling4 = scaling4[$gpuCallable].call.bind(scaling4);
+const gpuRotationX4 = rotationX4[$gpuCallable].call.bind(rotationX4);
+const gpuRotationY4 = rotationY4[$gpuCallable].call.bind(rotationY4);
+const gpuRotationZ4 = rotationZ4[$gpuCallable].call.bind(rotationZ4);
+/**
+* Translates the given 4-by-4 matrix by the given vector.
+* @param {m4x4f} matrix - The matrix to be modified.
+* @param {v3f} vector - The vector by which to translate the matrix.
+* @returns {m4x4f} The translated matrix.
+*/
+const translate4 = dualImpl({
+	name: "translate4",
+	normalImpl: (matrix, vector) => mul(translation4(vector), matrix),
+	signature: {
+		argTypes: [mat4x4f, vec3f],
+		returnType: mat4x4f
+	},
+	codegenImpl: (ctx, [matrix, vector]) => stitch`(${gpuTranslation4(ctx, [vector])} * ${matrix})`
+});
+/**
+* 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.
+*/
+const scale4 = dualImpl({
+	name: "scale4",
+	normalImpl: (matrix, vector) => mul(scaling4(vector), matrix),
+	signature: {
+		argTypes: [mat4x4f, vec3f],
+		returnType: mat4x4f
+	},
+	codegenImpl: (ctx, [matrix, vector]) => stitch`(${gpuScaling4(ctx, [vector])} * ${matrix})`
+});
+const rotateSignature = {
+	argTypes: [mat4x4f, f32],
+	returnType: mat4x4f
+};
+/**
+* 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.
+*/
+const rotateX4 = dualImpl({
+	name: "rotateX4",
+	normalImpl: (matrix, angle) => mul(rotationX4(angle), matrix),
+	signature: rotateSignature,
+	codegenImpl: (ctx, [matrix, angle]) => stitch`(${gpuRotationX4(ctx, [angle])} * ${matrix})`
+});
+/**
+* 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.
+*/
+const rotateY4 = dualImpl({
+	name: "rotateY4",
+	normalImpl: (matrix, angle) => mul(rotationY4(angle), matrix),
+	signature: rotateSignature,
+	codegenImpl: (ctx, [matrix, angle]) => stitch`(${gpuRotationY4(ctx, [angle])} * ${matrix})`
+});
+/**
+* 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.
+*/
+const rotateZ4 = dualImpl({
+	name: "rotateZ4",
+	normalImpl: (matrix, angle) => mul(rotationZ4(angle), matrix),
+	signature: rotateSignature,
+	codegenImpl: (ctx, [matrix, angle]) => stitch`(${gpuRotationZ4(ctx, [angle])} * ${matrix})`
+});
+
+//#endregion
+//#region src/std/atomic.ts
+const workgroupBarrier = dualImpl({
+	name: "workgroupBarrier",
+	normalImpl: "workgroupBarrier is a no-op outside of CODEGEN mode.",
+	signature: {
+		argTypes: [],
+		returnType: Void
+	},
+	codegenImpl: () => "workgroupBarrier()"
+});
+const storageBarrier = dualImpl({
+	name: "storageBarrier",
+	normalImpl: "storageBarrier is a no-op outside of CODEGEN mode.",
+	signature: {
+		argTypes: [],
+		returnType: Void
+	},
+	codegenImpl: () => "storageBarrier()"
+});
+const textureBarrier = dualImpl({
+	name: "textureBarrier",
+	normalImpl: "textureBarrier is a no-op outside of CODEGEN mode.",
+	signature: {
+		argTypes: [],
+		returnType: Void
+	},
+	codegenImpl: () => "textureBarrier()"
+});
+const atomicNormalError = "Atomic operations are not supported outside of CODEGEN mode.";
+const atomicLoad = dualImpl({
+	name: "atomicLoad",
+	normalImpl: atomicNormalError,
+	signature: (a) => {
+		if (!isAtomic(a)) throw new Error(`Invalid atomic type: ${safeStringify(a)}`);
+		return {
+			argTypes: [a],
+			returnType: a.inner
+		};
+	},
+	codegenImpl: (_ctx, [a]) => stitch`atomicLoad(&${a})`
+});
+const atomicActionSignature = (a) => {
+	if (!isAtomic(a)) throw new Error(`Invalid atomic type: ${safeStringify(a)}`);
+	return {
+		argTypes: [a, a.inner.type === "u32" ? u32 : i32],
+		returnType: Void
+	};
+};
+const atomicOpSignature = (a) => {
+	if (!isAtomic(a)) throw new Error(`Invalid atomic type: ${safeStringify(a)}`);
+	const paramType = a.inner.type === "u32" ? u32 : i32;
+	return {
+		argTypes: [a, paramType],
+		returnType: paramType
+	};
+};
+const atomicStore = dualImpl({
+	name: "atomicStore",
+	normalImpl: atomicNormalError,
+	signature: atomicActionSignature,
+	codegenImpl: (_ctx, [a, value]) => stitch`atomicStore(&${a}, ${value})`
+});
+const atomicAdd = dualImpl({
+	name: "atomicAdd",
+	normalImpl: atomicNormalError,
+	signature: atomicOpSignature,
+	codegenImpl: (_ctx, [a, value]) => stitch`atomicAdd(&${a}, ${value})`
+});
+const atomicSub = dualImpl({
+	name: "atomicSub",
+	normalImpl: atomicNormalError,
+	signature: atomicOpSignature,
+	codegenImpl: (_ctx, [a, value]) => stitch`atomicSub(&${a}, ${value})`
+});
+const atomicMax = dualImpl({
+	name: "atomicMax",
+	normalImpl: atomicNormalError,
+	signature: atomicOpSignature,
+	codegenImpl: (_ctx, [a, value]) => stitch`atomicMax(&${a}, ${value})`
+});
+const atomicMin = dualImpl({
+	name: "atomicMin",
+	normalImpl: atomicNormalError,
+	signature: atomicOpSignature,
+	codegenImpl: (_ctx, [a, value]) => stitch`atomicMin(&${a}, ${value})`
+});
+const atomicAnd = dualImpl({
+	name: "atomicAnd",
+	normalImpl: atomicNormalError,
+	signature: atomicOpSignature,
+	codegenImpl: (_ctx, [a, value]) => stitch`atomicAnd(&${a}, ${value})`
+});
+const atomicOr = dualImpl({
+	name: "atomicOr",
+	normalImpl: atomicNormalError,
+	signature: atomicOpSignature,
+	codegenImpl: (_ctx, [a, value]) => stitch`atomicOr(&${a}, ${value})`
+});
+const atomicXor = dualImpl({
+	name: "atomicXor",
+	normalImpl: atomicNormalError,
+	signature: atomicOpSignature,
+	codegenImpl: (_ctx, [a, value]) => stitch`atomicXor(&${a}, ${value})`
+});
+
+//#endregion
+//#region src/std/derivative.ts
+const derivativeNormalError = "Derivative builtins are not allowed on the CPU";
+const dpdx = dualImpl({
+	name: "dpdx",
+	normalImpl: derivativeNormalError,
+	signature: (value) => ({
+		argTypes: [value],
+		returnType: value
+	}),
+	codegenImpl: (_ctx, [value]) => stitch`dpdx(${value})`
+});
+const dpdxCoarse = dualImpl({
+	name: "dpdxCoarse",
+	normalImpl: derivativeNormalError,
+	signature: (value) => ({
+		argTypes: [value],
+		returnType: value
+	}),
+	codegenImpl: (_ctx, [value]) => stitch`dpdxCoarse(${value})`
+});
+const dpdxFine = dualImpl({
+	name: "dpdxFine",
+	normalImpl: derivativeNormalError,
+	signature: (value) => ({
+		argTypes: [value],
+		returnType: value
+	}),
+	codegenImpl: (_ctx, [value]) => stitch`dpdxFine(${value})`
+});
+const dpdy = dualImpl({
+	name: "dpdy",
+	normalImpl: derivativeNormalError,
+	signature: (value) => ({
+		argTypes: [value],
+		returnType: value
+	}),
+	codegenImpl: (_ctx, [value]) => stitch`dpdy(${value})`
+});
+const dpdyCoarse = dualImpl({
+	name: "dpdyCoarse",
+	normalImpl: derivativeNormalError,
+	signature: (value) => ({
+		argTypes: [value],
+		returnType: value
+	}),
+	codegenImpl: (_ctx, [value]) => stitch`dpdyCoarse(${value})`
+});
+const dpdyFine = dualImpl({
+	name: "dpdyFine",
+	normalImpl: derivativeNormalError,
+	signature: (value) => ({
+		argTypes: [value],
+		returnType: value
+	}),
+	codegenImpl: (_ctx, [value]) => stitch`dpdyFine(${value})`
+});
+const fwidth = dualImpl({
+	name: "fwidth",
+	normalImpl: derivativeNormalError,
+	signature: (value) => ({
+		argTypes: [value],
+		returnType: value
+	}),
+	codegenImpl: (_ctx, [value]) => stitch`fwidth(${value})`
+});
+const fwidthCoarse = dualImpl({
+	name: "fwidthCoarse",
+	normalImpl: derivativeNormalError,
+	signature: (value) => ({
+		argTypes: [value],
+		returnType: value
+	}),
+	codegenImpl: (_ctx, [value]) => stitch`fwidthCoarse(${value})`
+});
+const fwidthFine = dualImpl({
+	name: "fwidthFine",
+	normalImpl: derivativeNormalError,
+	signature: (value) => ({
+		argTypes: [value],
+		returnType: value
+	}),
+	codegenImpl: (_ctx, [value]) => stitch`fwidthFine(${value})`
+});
+
+//#endregion
+//#region src/std/texture.ts
+function sampleCpu(_texture, _sampler, _coords, _offsetOrArrayIndex, _maybeOffset) {
+	throw new MissingCpuImplError("Texture sampling relies on GPU resources and cannot be executed outside of a draw call");
+}
+const textureSample = dualImpl({
+	name: "textureSample",
+	normalImpl: sampleCpu,
+	codegenImpl: (_ctx, args) => stitch`textureSample(${args})`,
+	signature: (...args) => {
+		return {
+			argTypes: args,
+			returnType: args[0].type.startsWith("texture_depth") ? f32 : vec4f
+		};
+	}
+});
+function sampleBiasCpu(_texture, _sampler, _coords, _biasOrArrayIndex, _biasOrOffset, _maybeOffset) {
+	throw new MissingCpuImplError("Texture sampling with bias relies on GPU resources and cannot be executed outside of a draw call");
+}
+const textureSampleBias = dualImpl({
+	name: "textureSampleBias",
+	normalImpl: sampleBiasCpu,
+	codegenImpl: (_ctx, args) => stitch`textureSampleBias(${args})`,
+	signature: (...args) => ({
+		argTypes: args,
+		returnType: vec4f
+	})
+});
+function sampleLevelCpu(_texture, _sampler, _coords, _level, _offsetOrArrayIndex, _maybeOffset) {
+	throw new MissingCpuImplError("Texture sampling relies on GPU resources and cannot be executed outside of a draw call");
+}
+const textureSampleLevel = dualImpl({
+	name: "textureSampleLevel",
+	normalImpl: sampleLevelCpu,
+	codegenImpl: (_ctx, args) => stitch`textureSampleLevel(${args})`,
+	signature: (...args) => {
+		return {
+			argTypes: args,
+			returnType: args[0].type.startsWith("texture_depth") ? f32 : vec4f
+		};
+	}
+});
+function textureLoadCpu(_texture, _coords, _levelOrArrayIndex) {
+	throw new MissingCpuImplError("`textureLoad` relies on GPU resources and cannot be executed outside of a draw call");
+}
+const textureLoad = dualImpl({
+	name: "textureLoad",
+	normalImpl: textureLoadCpu,
+	codegenImpl: (_ctx, args) => stitch`textureLoad(${args})`,
+	signature: (...args) => {
+		const texture = args[0];
+		if (isWgslTexture(texture)) {
+			const isDepth = texture.type.startsWith("texture_depth");
+			const sampleType = texture.sampleType;
+			return {
+				argTypes: args,
+				returnType: isDepth ? f32 : sampleType.type === "f32" ? vec4f : sampleType.type === "u32" ? vec4u : vec4i
+			};
+		}
+		const format = texture.format;
+		return {
+			argTypes: args,
+			returnType: getTextureFormatInfo(format).vectorType
+		};
+	}
+});
+function textureStoreCpu(_texture, _coords, _arrayIndexOrValue, _maybeValue) {
+	throw new MissingCpuImplError("`textureStore` relies on GPU resources and cannot be executed outside of a draw call");
+}
+const textureStore = dualImpl({
+	name: "textureStore",
+	normalImpl: textureStoreCpu,
+	codegenImpl: (_ctx, args) => stitch`textureStore(${args})`,
+	signature: (...args) => ({
+		argTypes: args,
+		returnType: Void
+	})
+});
+function textureDimensionsCpu(_texture, _level) {
+	throw new MissingCpuImplError("`textureDimensions` relies on GPU resources and cannot be executed outside of a draw call");
+}
+const textureDimensions = dualImpl({
+	name: "textureDimensions",
+	normalImpl: textureDimensionsCpu,
+	codegenImpl: (_ctx, args) => stitch`textureDimensions(${args})`,
+	signature: (...args) => {
+		const dim = args[0].dimension;
+		if (dim === "1d") return {
+			argTypes: args,
+			returnType: u32
+		};
+		if (dim === "3d") return {
+			argTypes: args,
+			returnType: vec3u
+		};
+		return {
+			argTypes: args,
+			returnType: vec2u
+		};
+	}
+});
+const textureGatherCpu = (..._args) => {
+	throw new Error("Texture gather relies on GPU resources and cannot be executed outside of a draw call");
+};
+const sampleTypeToVecType = {
+	f32: vec4f,
+	i32: vec4i,
+	u32: vec4u
+};
+const textureGather = dualImpl({
+	name: "textureGather",
+	normalImpl: textureGatherCpu,
+	codegenImpl: (_ctx, args) => stitch`textureGather(${args})`,
+	signature: (...args) => {
+		if (args[0].type.startsWith("texture")) {
+			const [texture, sampler, coords, _, ...rest] = args;
+			return {
+				argTypes: texture.type === "texture_depth_2d_array" || texture.type === "texture_depth_cube_array" ? [
+					texture,
+					sampler,
+					coords,
+					[u32, i32],
+					...rest
+				] : args,
+				returnType: vec4f
+			};
+		}
+		const [_, texture, sampler, coords, ...rest] = args;
+		return {
+			argTypes: texture.type === "texture_2d_array" || texture.type === "texture_cube_array" ? [
+				[u32, i32],
+				texture,
+				sampler,
+				coords,
+				[u32, i32],
+				...rest
+			] : [
+				[u32, i32],
+				texture,
+				sampler,
+				coords,
+				...rest
+			],
+			returnType: sampleTypeToVecType[texture.sampleType.type]
+		};
+	}
+});
+function textureSampleCompareCpu(_texture, _sampler, _coords, _depthRefOrArrayIndex, _depthRefOrOffset, _maybeOffset) {
+	throw new MissingCpuImplError("Texture comparison sampling relies on GPU resources and cannot be executed outside of a draw call");
+}
+const textureSampleCompare = dualImpl({
+	name: "textureSampleCompare",
+	normalImpl: textureSampleCompareCpu,
+	codegenImpl: (_ctx, args) => stitch`textureSampleCompare(${args})`,
+	signature: (...args) => ({
+		argTypes: args,
+		returnType: f32
+	})
+});
+function textureSampleCompareLevelCpu(_texture, _sampler, _coords, _depthRefOrArrayIndex, _depthRefOrOffset, _maybeOffset) {
+	throw new MissingCpuImplError("Texture comparison sampling with level relies on GPU resources and cannot be executed outside of a draw call");
+}
+const textureSampleCompareLevel = dualImpl({
+	name: "textureSampleCompareLevel",
+	normalImpl: textureSampleCompareLevelCpu,
+	codegenImpl: (ctx, args) => stitch`textureSampleCompareLevel(${args})`,
+	signature: (...args) => ({
+		argTypes: args,
+		returnType: f32
+	})
+});
+function textureSampleBaseClampToEdgeCpu(_texture, _sampler, _coords) {
+	throw new MissingCpuImplError("Texture sampling with base clamp to edge is not supported outside of GPU mode.");
+}
+const textureSampleBaseClampToEdge = dualImpl({
+	name: "textureSampleBaseClampToEdge",
+	normalImpl: textureSampleBaseClampToEdgeCpu,
+	codegenImpl: (_ctx, args) => stitch`textureSampleBaseClampToEdge(${args})`,
+	signature: (...args) => ({
+		argTypes: args,
+		returnType: vec4f
+	})
+});
+
+//#endregion
+//#region src/std/subgroup.ts
+const errorMessage = "Subgroup operations can only be used in the GPU context.";
+const subgroupAdd = dualImpl({
+	name: "subgroupAdd",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [arg]) => stitch`subgroupAdd(${arg})`
+});
+const subgroupExclusiveAdd = dualImpl({
+	name: "subgroupExclusiveAdd",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [arg]) => stitch`subgroupExclusiveAdd(${arg})`
+});
+const subgroupInclusiveAdd = dualImpl({
+	name: "subgroupInclusiveAdd",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [arg]) => stitch`subgroupInclusiveAdd(${arg})`
+});
+const subgroupAll = dualImpl({
+	name: "subgroupAll",
+	signature: {
+		argTypes: [bool],
+		returnType: bool
+	},
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [e]) => stitch`subgroupAll(${e})`
+});
+const subgroupAnd = dualImpl({
+	name: "subgroupAnd",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [e]) => stitch`subgroupAnd(${e})`
+});
+const subgroupAny = dualImpl({
+	name: "subgroupAny",
+	signature: {
+		argTypes: [bool],
+		returnType: bool
+	},
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [e]) => stitch`subgroupAny(${e})`
+});
+const subgroupBallot = dualImpl({
+	name: "subgroupBallot",
+	signature: {
+		argTypes: [bool],
+		returnType: vec4u
+	},
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [e]) => stitch`subgroupBallot(${e})`
+});
+const subgroupBroadcast = dualImpl({
+	name: "subgroupBroadcast",
+	signature: (...args) => {
+		const id = unify([args[1]], [i32, u32]);
+		if (!id) throw new Error(`subgroupBroadcast's second argument has to be compatible with i32 or u32. Got: ${args[1].type}`);
+		return {
+			argTypes: [args[0], id[0]],
+			returnType: args[0]
+		};
+	},
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [e, index]) => stitch`subgroupBroadcast(${e}, ${index})`
+});
+const subgroupBroadcastFirst = dualImpl({
+	name: "subgroupBroadcastFirst",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [e]) => stitch`subgroupBroadcastFirst(${e})`
+});
+const subgroupElect = dualImpl({
+	name: "subgroupElect",
+	signature: {
+		argTypes: [],
+		returnType: bool
+	},
+	normalImpl: errorMessage,
+	codegenImpl: () => stitch`subgroupElect()`
+});
+const subgroupMax = dualImpl({
+	name: "subgroupMax",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [arg]) => stitch`subgroupMax(${arg})`
+});
+const subgroupMin = dualImpl({
+	name: "subgroupMin",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [arg]) => stitch`subgroupMin(${arg})`
+});
+const subgroupMul = dualImpl({
+	name: "subgroupMul",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [arg]) => stitch`subgroupMul(${arg})`
+});
+const subgroupExclusiveMul = dualImpl({
+	name: "subgroupExclusiveMul",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [arg]) => stitch`subgroupExclusiveMul(${arg})`
+});
+const subgroupInclusiveMul = dualImpl({
+	name: "subgroupInclusiveMul",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [arg]) => stitch`subgroupInclusiveMul(${arg})`
+});
+const subgroupOr = dualImpl({
+	name: "subgroupOr",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [e]) => stitch`subgroupOr(${e})`
+});
+const subgroupShuffle = dualImpl({
+	name: "subgroupShuffle",
+	signature: (...args) => {
+		const id = unify([args[1]], [i32, u32]);
+		if (!id) throw new Error(`subgroupShuffle's second argument has to be compatible with i32 or u32. Got: ${args[1].type}`);
+		return {
+			argTypes: [args[0], id[0]],
+			returnType: args[0]
+		};
+	},
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [e, index]) => stitch`subgroupShuffle(${e}, ${index})`
+});
+const subgroupShuffleDown = dualImpl({
+	name: "subgroupShuffleDown",
+	signature: (...args) => {
+		const delta = unify([args[1]], [u32]);
+		if (!delta) throw new Error(`subgroupShuffleDown's second argument has to be compatible with u32. Got: ${args[1].type}`);
+		return {
+			argTypes: [args[0], delta[0]],
+			returnType: args[0]
+		};
+	},
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [e, delta]) => stitch`subgroupShuffleDown(${e}, ${delta})`
+});
+const subgroupShuffleUp = dualImpl({
+	name: "subgroupShuffleUp",
+	signature: (...args) => {
+		const delta = unify([args[1]], [u32]);
+		if (!delta) throw new Error(`subgroupShuffleUp's second argument has to be compatible with u32. Got: ${args[1].type}`);
+		return {
+			argTypes: [args[0], delta[0]],
+			returnType: args[0]
+		};
+	},
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [e, delta]) => stitch`subgroupShuffleUp(${e}, ${delta})`
+});
+const subgroupShuffleXor = dualImpl({
+	name: "subgroupShuffleXor",
+	signature: (...args) => {
+		const mask = unify([args[1]], [u32]);
+		if (!mask) throw new Error(`subgroupShuffleXor's second argument has to be compatible with u32. Got: ${args[1].type}`);
+		return {
+			argTypes: [args[0], mask[0]],
+			returnType: args[0]
+		};
+	},
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [e, mask]) => stitch`subgroupShuffleXor(${e}, ${mask})`
+});
+const subgroupXor = dualImpl({
+	name: "subgroupXor",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [e]) => stitch`subgroupXor(${e})`
+});
+
+//#endregion
+//#region src/std/extensions.ts
+const extensionEnabled = comptime((extensionName) => {
+	const resolutionCtx = getResolutionCtx();
+	if (!resolutionCtx) throw new Error("Functions using `extensionEnabled` cannot be called directly. Either generate WGSL from them, or use tgpu['~unstable'].simulate(...)");
+	if (typeof extensionName !== "string" || !wgslExtensions.includes(extensionName)) throw new Error(`extensionEnabled has to be called with a string literal representing a valid WGSL extension name. Got: '${extensionName}'`);
+	return (resolutionCtx.enableExtensions ?? []).includes(extensionName);
+});
+
+//#endregion
+export { workgroupBarrier as $, extractBits as $t, textureSampleCompareLevel as A, sqrt as An, acos as At, fwidthCoarse as B, cosh as Bt, textureDimensions as C, reverseBits as Cn, pack4x8unorm as Ct, textureSampleBaseClampToEdge as D, sin as Dn, bitcastU32toI32 as Dt, textureSample as E, sign as En, bitcastU32toF32 as Et, dpdxFine as F, trunc as Fn, atan2 as Ft, atomicMax as G, degrees as Gt, atomicAdd as H, countOneBits as Ht, dpdy as I, getEffectiveSampleTypes as In, atanh as It, atomicStore as J, dot as Jt, atomicMin as K, determinant as Kt, dpdyCoarse as L, getTextureFormatInfo as Ln, ceil as Lt, textureStore as M, tan as Mn, asin as Mt, dpdx as N, tanh as Nn, asinh as Nt, textureSampleBias as O, sinh as On, arrayLength as Ot, dpdxCoarse as P, transpose as Pn, atan as Pt, textureBarrier as Q, exp2 as Qt, dpdyFine as R, clamp as Rt, subgroupXor as S, refract as Sn, pack2x16float as St, textureLoad as T, saturate as Tn, unpack4x8unorm as Tt, atomicAnd as U, countTrailingZeros as Ut, fwidthFine as V, countLeadingZeros as Vt, atomicLoad as W, cross as Wt, atomicXor as X, dot4U8Packed as Xt, atomicSub as Y, dot4I8Packed as Yt, storageBarrier as Z, exp as Zt, subgroupOr as _, normalize as _n, not as _t, subgroupAny as a, fract as an, discard as at, subgroupShuffleUp as b, radians as bn, wgslExtensionToFeatureName as bt, subgroupBroadcastFirst as c, inverseSqrt as cn, and as ct, subgroupExclusiveMul as d, log as dn, ge as dt, faceForward as en, rotateX4 as et, subgroupInclusiveAdd as f, log2 as fn, gt as ft, subgroupMul as g, modf as gn, ne as gt, subgroupMin as h, mix as hn, lt as ht, subgroupAnd as i, fma as in, translate4 as it, textureSampleLevel as j, step as jn, acosh as jt, textureSampleCompare as k, smoothstep as kn, abs as kt, subgroupElect as l, ldexp as ln, any as lt, subgroupMax as m, min as mn, le as mt, subgroupAdd as n, firstTrailingBit as nn, rotateZ4 as nt, subgroupBallot as o, frexp as on, all as ot, subgroupInclusiveMul as p, max as pn, isCloseTo as pt, atomicOr as q, distance as qt, subgroupAll as r, floor as rn, scale4 as rt, subgroupBroadcast as s, insertBits as sn, allEq as st, extensionEnabled as t, firstLeadingBit as tn, rotateY4 as tt, subgroupExclusiveAdd as u, length as un, eq as ut, subgroupShuffle as v, pow as vn, or as vt, textureGather as w, round as wn, unpack2x16float as wt, subgroupShuffleXor as x, reflect as xn, wgslExtensions as xt, subgroupShuffleDown as y, quantizeToF16 as yn, select as yt, fwidth as z, cos as zt };
+//# sourceMappingURL=extensions-0SFbU9FH.js.map