typegpu 0.12.0 → 0.12.1

package/bin.mjs

@@ -21,8 +21,11 @@ if (major === undefined || minor === undefined) {
  */
 const semver = `^${major}.${minor}.0`;
 
+/**
+ * @returns {Promise<number | undefined>}
+ */
 function asyncSpawn(...args) {
-  return new Promise((resolve, _reject) => {
+  return new Promise((resolve, reject) => {
     const child = spawn(...args);
 
     child.on('exit', (code, signal) => {
@@ -34,22 +37,41 @@ function asyncSpawn(...args) {
 
       resolve(code);
     });
+
+    child.on('error', (err) => {
+      reject(err);
+    });
   });
 }
 
+/**
+ * @param {string} label
+ */
+function failedToRunErrHandler(label) {
+  return (err) => {
+    console.error(`Failed to run '${label}':`, err);
+    process.exit(1);
+  };
+}
+
 (async () => {
-  const code = await asyncSpawn('npx', [`@typegpu/cli@${semver}`, ...process.argv.slice(2)], {
-    stdio: ['inherit', 'inherit', 'ignore'],
-  });
+  const windows = process.platform === 'win32';
+  const npxCommand = windows ? 'npx.cmd' : 'npx';
+
+  const code = await asyncSpawn(npxCommand, [`@typegpu/cli@${semver}`, ...process.argv.slice(2)], {
+    stdio: 'inherit',
+    shell: windows, // needs to be ran through the shell on Windows
+  }).catch(failedToRunErrHandler(`npx @typegpu/cli@${semver}`));
 
   if (code !== 0) {
     console.warn(
       `Couldn't find @typegpu/cli version matching ${semver}, falling back to latest...`,
     );
     // Fallback to latest
-    const code = await asyncSpawn('npx', [`@typegpu/cli@latest`, ...process.argv.slice(2)], {
+    const code = await asyncSpawn(npxCommand, [`@typegpu/cli@latest`, ...process.argv.slice(2)], {
       stdio: 'inherit',
-    });
+      shell: windows, // needs to be ran through the shell on Windows
+    }).catch(failedToRunErrHandler('npx @typegpu/cli@latest'));
     process.exit(code ?? 0);
   }
 

package/core/buffer/buffer.js

@@ -8,6 +8,7 @@ import { isGPUBuffer } from "../../types.js";
 import { calculateOffsets, readFromArrayBuffer, writeToArrayBuffer } from "../../data/dataIO.js";
 import { patchArrayBuffer } from "../../data/partialIO.js";
 import { mutable, readonly, uniform, } from "./bufferBinding.js";
+import { warnIfNotUniformAligned } from "../pipeline/webgpuLimitations.js";
 const usageToUsageConstructor = { uniform, mutable, readonly };
 export function INTERNAL_createBuffer(group, typeSchema, initialOrBuffer) {
     if (!isWgslData(typeSchema)) {
@@ -145,6 +146,9 @@ class TgpuBufferImpl {
             if (this.#disallowedUsages?.includes(usage)) {
                 throw new Error(`Buffer of type ${this.dataType.type} cannot be used as ${usage}`);
             }
+            if (usage === 'uniform') {
+                warnIfNotUniformAligned(this.dataType);
+            }
             this.flags |= usage === 'uniform' ? GPUBufferUsage.UNIFORM : 0;
             this.flags |= usage === 'storage' ? GPUBufferUsage.STORAGE : 0;
             this.flags |= usage === 'vertex' ? GPUBufferUsage.VERTEX : 0;

package/core/pipeline/computePipeline.js

@@ -11,7 +11,7 @@ import { isGPUCommandEncoder, isGPUComputePassEncoder, isTgpuCommandEncoder, isT
 import { isGPUBuffer } from "../../types.js";
 import { wgslEnableExtensions, wgslEnableExtensionToFeatureName } from "../../wgslExtensions.js";
 import { namespace } from "../resolve/namespace.js";
-import { warnIfOverflow } from "./limitsOverflow.js";
+import { warnIfOverflow } from "./webgpuLimitations.js";
 import { collectBindGroupPairs, DISPATCH_INDIRECT_SIZE, resolveIndirectOffset, restoreTimestampPriors, } from "./pipelineUtils.js";
 import { invariant } from "../../errors.js";
 import { createWithPerformanceCallback, createWithTimestampWrites, } from "./timeable.js";

package/core/pipeline/renderPipeline.js

@@ -24,7 +24,7 @@ import { isGPUCommandEncoder, isGPURenderBundleEncoder, isGPURenderPassEncoder,
 import { createWithPerformanceCallback, createWithTimestampWrites, } from "./timeable.js";
 import { nonTransferablePriorsOf } from "./priors.js";
 import {} from "../../data/offsetUtils.js";
-import { warnIfOverflow } from "./limitsOverflow.js";
+import { warnIfOverflow } from "./webgpuLimitations.js";
 import { collectBindGroupPairs, collectVertexBufferPairs, DRAW_INDEXED_INDIRECT_SIZE, DRAW_INDIRECT_SIZE, resolveIndirectOffset, restoreTimestampPriors, } from "./pipelineUtils.js";
 import { NullPerformanceTracker, PerformanceTrackerImpl, } from "./performanceTracker.js";
 import { logger } from "../../tgpuLogger.js";

package/core/pipeline/webgpuLimitations.d.ts

@@ -0,0 +1,10 @@
+import { type BaseData } from '../../data/wgslTypes.ts';
+import type { TgpuBindGroupLayout } from '../../tgpuBindGroupLayout.ts';
+/**
+ * Warns if layout exceeds supported buffer count limits.
+ */
+export declare function warnIfOverflow(layouts: TgpuBindGroupLayout[], limits: GPUSupportedLimits): void;
+/**
+ * See https://www.w3.org/TR/WGSL/#address-space-layout-constraints
+ */
+export declare function warnIfNotUniformAligned(schema: BaseData): void;

package/core/pipeline/webgpuLimitations.js

@@ -0,0 +1,81 @@
+import { alignmentOf } from "../../data/alignmentOf.js";
+import { memoryLayoutOf } from "../../data/offsetUtils.js";
+import { sizeOf } from "../../data/sizeOf.js";
+import { isWgslArray, isWgslStruct } from "../../data/wgslTypes.js";
+import { invariant } from "../../errors.js";
+import { roundUp } from "../../mathUtils.js";
+import { getName } from "../../shared/meta.js";
+import { logger } from "../../tgpuLogger.js";
+/**
+ * Warns if layout exceeds supported buffer count limits.
+ */
+export function warnIfOverflow(layouts, limits) {
+    const entries = Object.values(layouts)
+        .flatMap((layout) => Object.values(layout.entries))
+        .filter((entry) => entry !== null);
+    const uniform = entries.filter((entry) => 'uniform' in entry).length;
+    const storage = entries.filter((entry) => 'storage' in entry).length;
+    if (uniform > limits.maxUniformBuffersPerShaderStage) {
+        logger.warn('webgpu-limits-exceeded', `Total number of uniform buffers (${uniform}) exceeds maxUniformBuffersPerShaderStage (${limits.maxUniformBuffersPerShaderStage}). Consider:
+1. Grouping some of the uniforms into one using 'd.struct',
+2. Increasing the limit when requesting a device or creating a root.`);
+    }
+    if (storage > limits.maxStorageBuffersPerShaderStage) {
+        logger.warn('webgpu-limits-exceeded', `Total number of storage buffers (${storage}) exceeds maxStorageBuffersPerShaderStage (${limits.maxStorageBuffersPerShaderStage}).`);
+    }
+}
+function requiredAlignOf(schema) {
+    if (isWgslStruct(schema) || isWgslArray(schema)) {
+        return roundUp(alignmentOf(schema), 16);
+    }
+    return alignmentOf(schema);
+}
+/**
+ * See https://www.w3.org/TR/WGSL/#address-space-layout-constraints
+ */
+export function warnIfNotUniformAligned(schema) {
+    if (isWgslArray(schema)) {
+        warnIfNotUniformAligned(schema.elementType);
+        const stride = roundUp(sizeOf(schema.elementType), alignmentOf(schema.elementType));
+        if (stride % 16 !== 0) {
+            logger.warn('uniform-schema-misaligned', `\
+Schema '${getName(schema.elementType) ?? '<unnamed>'}' is used in an array in a uniform buffer, and its stride (${stride}) is not a multiple of 16.
+This is not portable (see https://www.w3.org/TR/WGSL/#address-space-layout-constraints), and will break on some devices.
+To address this, put the element schema in a struct and wrap the prop in 'd.align(16, ...)', or use a different schema like 'vec4f'.`);
+        }
+    }
+    if (isWgslStruct(schema)) {
+        Object.values(schema.propTypes).forEach(warnIfNotUniformAligned);
+        Object.entries(schema.propTypes).forEach(([key, value]) => {
+            const offset = memoryLayoutOf(schema, (schema) => schema[key]).offset;
+            const requiredAlignment = requiredAlignOf(value);
+            if (offset % requiredAlignment) {
+                logger.warn('uniform-schema-misaligned', `\
+Schema '${getName(schema) ?? '<unnamed>'}' is used in a uniform buffer, and its property '${key}' does not meet required alignment (offset is ${offset}, required alignment is ${requiredAlignment}).
+This is not portable (see https://www.w3.org/TR/WGSL/#address-space-layout-constraints), and will break on some devices.
+To address this, wrap the property '${key}' in 'd.align(${requiredAlignment}, ...)'.`);
+            }
+        });
+        const keys = Object.keys(schema.propTypes);
+        for (let i = 0; i < keys.length - 1; i++) {
+            const thisKey = keys[i];
+            const nextKey = keys[i + 1];
+            invariant(thisKey && nextKey);
+            const thisValue = schema.propTypes[thisKey];
+            invariant(thisValue);
+            if (!isWgslStruct(thisValue)) {
+                continue;
+            }
+            const minimumDifference = roundUp(sizeOf(thisValue), 16);
+            const thisKeyOffset = memoryLayoutOf(schema, (schema) => schema[thisKey]).offset;
+            const nextKeyOffset = memoryLayoutOf(schema, (schema) => schema[nextKey]).offset;
+            const difference = nextKeyOffset - thisKeyOffset;
+            if (minimumDifference > difference) {
+                logger.warn('uniform-schema-misaligned', `\
+Schema '${getName(schema) ?? '<unnamed>'}' is used in a uniform buffer, and the difference between memory offsets of '${thisKey}' and '${nextKey}' props (${difference}) is less than recommended (${minimumDifference}).
+This is not portable (see https://www.w3.org/TR/WGSL/#address-space-layout-constraints), and will break on some devices.
+To address this, wrap the '${thisKey}' prop in 'd.size(${minimumDifference}, ...)'.`);
+            }
+        }
+    }
+}

package/data/array.d.ts

@@ -1,6 +1,12 @@
 import { type TgpuComptime } from '../core/function/comptime.ts';
-import type { AnyWgslData, WgslArray } from './wgslTypes.ts';
+import type { AnyWgslData, Decorated, Location, WgslArray } from './wgslTypes.ts';
+type ForbiddenDecoratedArrayElement<T> = T extends Decorated<infer _, infer Attribs> ? Attribs[number] extends Location ? never : T : never;
 interface WgslArrayConstructor {
+    /**
+     * @deprecated Error: Arrays cannot hold decorated types other than @location.
+     * Wrap align/size in a struct instead, e.g. d.arrayOf(d.struct({ value: d.align(16, d.u32) }), n).
+     */
+    <TElement extends AnyWgslData>(elementType: ForbiddenDecoratedArrayElement<TElement>, elementCount?: number): 'Error: Arrays cannot hold decorated types other than @location. Wrap it in a struct instead, e.g. d.arrayOf(d.struct({ value: d.align(16, d.u32) }), n).';
     <TElement extends AnyWgslData>(elementType: TElement): (elementCount: number) => WgslArray<TElement>;
     <TElement extends AnyWgslData>(elementType: TElement, elementCount: number): WgslArray<TElement>;
 }
@@ -8,6 +14,10 @@ interface WgslArrayConstructor {
  * Creates an array schema that can be used to construct gpu buffers.
  * Describes arrays with fixed-size length, storing elements of the same type.
  *
+ * The only decoration allowed on element types is `d.location`. Decorators like
+ * `d.align` and `d.size` cannot be applied directly — wrap them in a struct instead,
+ * e.g. `d.arrayOf(d.struct({ value: d.align(16, d.u32) }), n)`.
+ *
  * @example
  * const LENGTH = 3;
  * const array = d.arrayOf(d.u32, LENGTH);
@@ -19,6 +29,7 @@ interface WgslArrayConstructor {
  *
  * @param elementType The type of elements in the array.
  * @param elementCount The number of elements in the array.
+ * @throws If `elementType` is decorated with anything other than `d.location`.
  */
 export declare const arrayOf: TgpuComptime<WgslArrayConstructor>;
 export {};

package/data/array.js

@@ -2,10 +2,15 @@ import { comptime } from "../core/function/comptime.js";
 import { $internal } from "../shared/symbols.js";
 import { schemaCallWrapper } from "./schemaCallWrapper.js";
 import { sizeOf } from "./sizeOf.js";
+import { isDecorated, isLocationAttrib } from "./wgslTypes.js";
 /**
  * Creates an array schema that can be used to construct gpu buffers.
  * Describes arrays with fixed-size length, storing elements of the same type.
  *
+ * The only decoration allowed on element types is `d.location`. Decorators like
+ * `d.align` and `d.size` cannot be applied directly — wrap them in a struct instead,
+ * e.g. `d.arrayOf(d.struct({ value: d.align(16, d.u32) }), n)`.
+ *
  * @example
  * const LENGTH = 3;
  * const array = d.arrayOf(d.u32, LENGTH);
@@ -17,8 +22,12 @@ import { sizeOf } from "./sizeOf.js";
  *
  * @param elementType The type of elements in the array.
  * @param elementCount The number of elements in the array.
+ * @throws If `elementType` is decorated with anything other than `d.location`.
  */
 export const arrayOf = comptime(((elementType, elementCount) => {
+    if (isDecorated(elementType) && !elementType.attribs.every(isLocationAttrib)) {
+        throw new Error('Arrays cannot hold decorated types other than @location. Wrap it in a struct instead, e.g. d.arrayOf(d.struct({ value: d.align(16, d.u32) }), n).');
+    }
     if (elementCount === undefined) {
         return comptime((count) => cpu_arrayOf(elementType, count));
     }

package/data/generalizeFn.d.ts

@@ -0,0 +1,25 @@
+import { type AnyBooleanVecInstance, type AnyMatInstance, type AnyVec2Instance, type AnyVec3Instance, type AnyVec4Instance, type AnyVecInstance, type v2b, type v3b, type v4b } from './wgslTypes.ts';
+type Vec = AnyVecInstance;
+type Mat = AnyMatInstance;
+type Algebraic = number | boolean | Vec | Mat;
+export type ToBool<T extends Algebraic> = T extends number | boolean ? boolean : T extends AnyVec2Instance ? v2b : T extends AnyVec3Instance ? v3b : T extends AnyVec4Instance ? v4b : never;
+/**
+ * Generalizes function of 1 to 3 arguments to work component-wise on vectors and matrices.
+ * Assumes the types are already correct (in particular, that they have the same length),
+ * and performs no additional checks.
+ * The return type is the same as the first argument's type.
+ */
+export declare function generalizeFn<T extends Algebraic>(fn: (a: number) => number, args: [T]): T;
+export declare function generalizeFn<T extends Algebraic>(fn: (a: number, b: number) => number, args: [T, T]): T;
+export declare function generalizeFn<T extends Algebraic>(fn: (a: number, b: number, c: number) => number, args: [T, T, T]): T;
+/**
+ * Analogous to `generalizeFn`, but the return type is a boolean vector instead.
+ */
+export declare function generalizeBoolFn<T extends Algebraic>(fn: (a: number, b: number) => boolean, args: [T, T]): ToBool<T>;
+export declare function generalizeBoolFn<T extends boolean | AnyBooleanVecInstance>(fn: (a: boolean, b: boolean) => boolean, args: [T, T]): ToBool<T>;
+/**
+ * If one of the arguments is a vector and other is a number,
+ * the number is up-cased to a vector.
+ */
+export declare function upCast<T extends number | Vec>(args: [T, T]): [Exclude<T, number>, Exclude<T, number>];
+export {};

package/data/generalizeFn.js

@@ -0,0 +1,89 @@
+import { vec2b, vec3b, vec4b, vecTypeToConstructor } from "./vector.js";
+import { mat2x2f, mat3x3f, mat4x4f } from "./matrix.js";
+import { isVecInstance, } from "./wgslTypes.js";
+import { invariant } from "../errors.js";
+const booleanFor = {
+    vec2f: vec2b,
+    vec2h: vec2b,
+    vec2i: vec2b,
+    vec2u: vec2b,
+    'vec2<bool>': vec2b,
+    vec3f: vec3b,
+    vec3h: vec3b,
+    vec3i: vec3b,
+    vec3u: vec3b,
+    'vec3<bool>': vec3b,
+    vec4f: vec4b,
+    vec4h: vec4b,
+    vec4i: vec4b,
+    vec4u: vec4b,
+    'vec4<bool>': vec4b,
+};
+const constructorFor = {
+    ...vecTypeToConstructor,
+    mat2x2f,
+    mat3x3f,
+    mat4x4f,
+};
+function getConstructorFor(mode, kind) {
+    const map = mode === 'boolean' ? booleanFor : constructorFor;
+    if (kind in map) {
+        return map[kind];
+    }
+    throw new Error(`No corresponding vector/matrix type for '${kind}' kind in '${mode}' mode.`);
+}
+function makeIterable(item) {
+    if (item.kind.startsWith('vec')) {
+        return item;
+    }
+    return item.columns.flat();
+}
+function applyArgs(fn, args, mode) {
+    // I'm sorry, TypeScript, I swear I won't lie to you no more ;-;
+    const kinds = args.map(kindOf);
+    if (kinds.every((type) => type === 'boolean' || type === 'number')) {
+        return fn(...args);
+    }
+    const kind = kinds[0];
+    invariant(kind, `Expected kind of the first argument to be present.`);
+    const constructor = getConstructorFor(mode, kind);
+    const iterableArgs = args.map(makeIterable);
+    const length = iterableArgs[0]?.length;
+    invariant(length !== undefined, `Expected constructor to have at least one argument.`);
+    const constructorArgs = Array.from({ length }, (_, i) => {
+        const args = iterableArgs.map((arg) => arg[i]);
+        return fn(...args);
+    });
+    return constructor(...constructorArgs);
+}
+export function generalizeFn(fn, args) {
+    return applyArgs(fn, args, 'first');
+}
+export function generalizeBoolFn(fn, args) {
+    return applyArgs(fn, args, 'boolean');
+}
+function kindOf(v) {
+    if (typeof v === 'number') {
+        return 'number';
+    }
+    if (typeof v === 'boolean') {
+        return 'boolean';
+    }
+    return v.kind;
+}
+/**
+ * If one of the arguments is a vector and other is a number,
+ * the number is up-cased to a vector.
+ */
+export function upCast(args) {
+    const [lhs, rhs] = args;
+    if (typeof lhs === 'number' && isVecInstance(rhs)) {
+        const schema = constructorFor[rhs.kind];
+        return [schema(lhs), rhs];
+    }
+    else if (isVecInstance(lhs) && typeof rhs === 'number') {
+        const schema = constructorFor[lhs.kind];
+        return [lhs, schema(rhs)];
+    }
+    return [lhs, rhs];
+}

package/data/numberOps.d.ts

@@ -1,6 +1,5 @@
 export declare const smoothstepScalar: (edge0: number, edge1: number, x: number) => number;
-export declare const clamp: (value: number, low: number, high: number) => number;
-export declare const divInteger: (lhs: number, rhs: number) => number;
+export declare const clampScalar: (value: number, low: number, high: number) => number;
 export declare function bitcastU32toF32Impl(n: number): number;
 export declare function bitcastU32toI32Impl(n: number): number;
 export declare function bitcastF32toU32Impl(n: number): number;

package/data/numberOps.js

@@ -2,16 +2,10 @@ export const smoothstepScalar = (edge0, edge1, x) => {
     if (edge0 === edge1) {
         return 0; // WGSL spec says this is an indeterminate value
     }
-    const t = clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0);
+    const t = clampScalar((x - edge0) / (edge1 - edge0), 0.0, 1.0);
     return t * t * (3 - 2 * t);
 };
-export const clamp = (value, low, high) => Math.min(Math.max(low, value), high);
-export const divInteger = (lhs, rhs) => {
-    if (rhs === 0) {
-        return lhs;
-    }
-    return Math.trunc(lhs / rhs);
-};
+export const clampScalar = (value, low, high) => Math.min(Math.max(low, value), high);
 const buf32 = new ArrayBuffer(4);
 const f32arr = new Float32Array(buf32);
 const u32arr = new Uint32Array(buf32);

package/data/vectorOps.d.ts

@@ -3,57 +3,19 @@ import type { VecKind } from './wgslTypes.ts';
 type vBase = {
     kind: VecKind;
 };
-type mBase = {
-    kind: MatKind;
-};
 type MatKind = 'mat2x2f' | 'mat3x3f' | 'mat4x4f';
+/**
+ * Functions that cannot be simply generalized via `generalizeFn`
+ * have their overloads listed explicitly here.
+ */
 export declare const VectorOps: {
-    eq: Record<VecKind, <T extends wgsl.AnyVecInstance>(e1: T, e2: T) => T extends wgsl.AnyVec2Instance ? wgsl.v2b : T extends wgsl.AnyVec3Instance ? wgsl.v3b : wgsl.v4b>;
-    lt: Record<VecKind, <T extends wgsl.AnyNumericVecInstance>(e1: T, e2: T) => T extends wgsl.AnyVec2Instance ? wgsl.v2b : T extends wgsl.AnyVec3Instance ? wgsl.v3b : wgsl.v4b>;
-    or: Record<VecKind, <T extends wgsl.AnyBooleanVecInstance>(e1: T, e2: T) => T>;
     all: Record<VecKind, (v: wgsl.AnyBooleanVecInstance) => boolean>;
-    abs: Record<VecKind, <T extends vBase>(v: T) => T>;
-    atan2: Record<VecKind, <T extends vBase>(a: T, b: T) => T>;
-    acos: Record<VecKind, <T extends vBase>(v: T) => T>;
-    acosh: Record<VecKind, <T extends vBase>(v: T) => T>;
-    asin: Record<VecKind, <T extends vBase>(v: T) => T>;
-    asinh: Record<VecKind, <T extends vBase>(v: T) => T>;
-    atan: Record<VecKind, <T extends vBase>(v: T) => T>;
-    atanh: Record<VecKind, <T extends vBase>(v: T) => T>;
-    ceil: Record<VecKind, <T extends vBase>(v: T) => T>;
-    clamp: Record<VecKind, <T extends vBase>(v: T, low: T, high: T) => T>;
     length: Record<VecKind, (v: vBase) => number>;
-    add: Record<VecKind | MatKind, <T extends vBase | mBase>(lhs: T, rhs: T) => T>;
-    smoothstep: Record<VecKind, <T extends vBase>(edge0: T, edge1: T, x: T) => T extends wgsl.AnyVec2Instance ? wgsl.v2f : T extends wgsl.AnyVec3Instance ? wgsl.v3f : T extends wgsl.AnyVec4Instance ? wgsl.v4f : wgsl.AnyVecInstance>;
-    addMixed: Record<VecKind | MatKind, <T extends vBase | mBase>(lhs: T, rhs: number) => T>;
-    mulSxV: Record<VecKind | MatKind, <T extends vBase | wgsl.AnyMatInstance>(s: number, v: T) => T>;
-    mulVxV: Record<VecKind | MatKind, <T extends vBase | wgsl.AnyMatInstance>(lhs: T, rhs: T) => T>;
+    mulMxM: Record<VecKind | MatKind, <T extends vBase | wgsl.AnyMatInstance>(lhs: T, rhs: T) => T>;
     mulMxV: Record<MatKind, <T extends wgsl.AnyMatInstance>(m: T, v: wgsl.vBaseForMat<T>) => wgsl.vBaseForMat<T>>;
     mulVxM: Record<MatKind, <T extends wgsl.AnyMatInstance>(v: wgsl.vBaseForMat<T>, m: T) => wgsl.vBaseForMat<T>>;
-    div: Record<VecKind, <T extends vBase>(a: T, b: T) => T>;
     dot: Record<VecKind, <T extends vBase>(lhs: T, rhs: T) => number>;
-    normalize: Record<VecKind, <T extends vBase>(v: T) => T>;
     cross: Record<"vec3f" | "vec3h", <T extends wgsl.v3f | wgsl.v3h>(a: T, b: T) => T>;
-    mod: Record<VecKind, <T extends vBase>(a: T, b: T) => T>;
-    floor: Record<VecKind, <T extends vBase>(v: T) => T>;
-    max: Record<VecKind, <T extends vBase>(a: T, b: T) => T>;
-    min: Record<VecKind, <T extends vBase>(a: T, b: T) => T>;
-    pow: Record<"vec2f" | "vec3f" | "vec4f" | "vec2h" | "vec3h" | "vec4h" | "number", <T extends wgsl.AnyFloatVecInstance | number>(a: T, b: T) => T>;
-    sign: Record<VecKind, <T extends vBase>(e: T) => T>;
-    sqrt: Record<VecKind, <T extends vBase>(v: T) => T>;
-    mix: Record<"vec2f" | "vec3f" | "vec4f" | "vec2h" | "vec3h" | "vec4h", <T extends wgsl.v2f | wgsl.v3f | wgsl.v4f | wgsl.v2h | wgsl.v3h | wgsl.v4h>(a: T, b: T, c: T | number) => T>;
-    sin: Record<VecKind, <T extends vBase>(v: T) => T>;
-    cos: Record<VecKind, <T extends vBase>(v: T) => T>;
-    cosh: Record<VecKind, <T extends vBase>(v: T) => T>;
-    exp: Record<VecKind, <T extends vBase>(v: T) => T>;
-    exp2: Record<VecKind, <T extends vBase>(v: T) => T>;
-    log: Record<VecKind, <T extends vBase>(v: T) => T>;
-    log2: Record<VecKind, <T extends vBase>(v: T) => T>;
-    fract: Record<VecKind, <T extends vBase>(v: T) => T>;
-    isCloseToZero: Record<VecKind, <T extends vBase>(v: T, n: number) => boolean>;
-    neg: Record<VecKind, <T extends vBase>(v: T) => T>;
-    select: Record<VecKind, <T extends wgsl.AnyVecInstance>(f: T, t: T, c: T extends wgsl.AnyVec2Instance ? wgsl.v2b : T extends wgsl.AnyVec3Instance ? wgsl.v3b : wgsl.v4b) => T>;
-    tanh: Record<VecKind, <T extends vBase>(v: T) => T>;
     bitShiftLeft: Record<VecKind, <T extends wgsl.AnyIntegerVecInstance, U extends wgsl.AnyUnsignedVecInstance>(a: T, b: U) => T>;
     bitShiftRight: Record<VecKind, <T extends wgsl.AnyIntegerVecInstance, U extends wgsl.AnyUnsignedVecInstance>(a: T, b: U) => T>;
     bitcastU32toF32: Record<VecKind, <T extends wgsl.AnyUnsignedVecInstance>(v: T) => T extends wgsl.v2u ? wgsl.v2f : T extends wgsl.v3u ? wgsl.v3f : wgsl.v4f>;