typegpu 0.12.4 → 0.12.5

package/bin.mjs

@@ -1,79 +1,51 @@
 #!/usr/bin/env node
-import { spawn } from 'node:child_process';
+import { execFile, spawn } from 'node:child_process';
+import { promisify } from 'node:util';
 import pkg from './package.json' with { type: 'json' };
 
-/**
- * Used to extract the version of `typegpu` that was used to
- * trigger the CLI, which then allows us to download the latest
- * version matching the major and minor of the `typegpu` package.
- */
-const versionPattern = /^(\d+)\.(\d+)\.(\d+)/;
-
-const result = versionPattern.exec(pkg.version);
-const [_, major, minor] = result;
+const [major, minor] = pkg.version.split('.');
+const semver = `^${major}.${minor}.0`;
 
-if (major === undefined || minor === undefined) {
-  throw new Error(`TypeGPU version doesn't match the expected major.minor.patch format`);
+const windows = process.platform === 'win32';
+const npm = windows ? 'npm.cmd' : 'npm';
+const npx = windows ? 'npx.cmd' : 'npx';
+const execFileAsync = promisify(execFile);
+
+/** True only when the registry confirms no `@typegpu/cli` satisfies `semver` */
+async function noMatchingCli() {
+  const args = ['view', `@typegpu/cli@${semver}`, 'version', '--json'];
+  try {
+    const { stdout } = await execFileAsync(npm, args, { shell: windows, timeout: 3_000 });
+    return ['', '[]'].includes(stdout.trim());
+  } catch (err) {
+    return /E404|ETARGET/.test(err.stderr ?? '');
+  }
 }
 
-/**
- * Targeting the latest version with the same major and minor as `typegpu`
- */
-const semver = `^${major}.${minor}.0`;
-
-/**
- * @returns {Promise<number | undefined>}
- */
-function asyncSpawn(...args) {
+/** Resolves with the child's exit code, re-raising a fatal signal on this process */
+function run(command, args) {
   return new Promise((resolve, reject) => {
-    const child = spawn(...args);
-
-    child.on('exit', (code, signal) => {
-      if (signal) {
-        process.kill(process.pid, signal);
-        process.exit(0);
-        return;
-      }
-
-      resolve(code);
-    });
-
-    child.on('error', (err) => {
-      reject(err);
-    });
+    spawn(command, args, { stdio: 'inherit', shell: windows })
+      .on('error', reject)
+      .on('exit', (code, signal) => {
+        if (signal) {
+          process.kill(process.pid, signal);
+        } else {
+          resolve(code ?? 1);
+        }
+      });
   });
 }
 
-/**
- * @param {string} label
- */
-function failedToRunErrHandler(label) {
-  return (err) => {
-    console.error(`Failed to run '${label}':`, err);
-    process.exit(1);
-  };
+const fallback = await noMatchingCli();
+if (fallback) {
+  console.warn(`Couldn't find @typegpu/cli version matching ${semver}, falling back to latest...`);
 }
+const spec = fallback ? '@typegpu/cli@latest' : `@typegpu/cli@${semver}`;
 
-(async () => {
-  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(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);
-  }
-
-  process.exit(code ?? 0);
-})();
+try {
+  process.exit(await run(npx, [spec, ...process.argv.slice(2)]));
+} catch (err) {
+  console.error(`Failed to run 'npx ${spec}':`, err);
+  process.exit(2);
+}

package/core/pipeline/computePipeline.d.ts

@@ -54,6 +54,11 @@ export interface TgpuComputePipeline extends TgpuNamable, SelfResolvable, Timeab
     with(encoder: TgpuCommandEncoder): this;
     with(encoder: GPUCommandEncoder): this;
     with(pass: GPUComputePassEncoder): this;
+    /**
+     * Applies a transform to this pipeline, letting packages hand out reusable
+     * configuration steps, e.g. `pipeline.pipe(cache.inject())`.
+     */
+    pipe<T>(transform: (pipeline: this) => T): T;
     dispatchWorkgroups(x: number, y?: number, z?: number): void;
     /**
      * Immediately resolves the pipeline, then awaits `device.createComputePipelineAsync()`.
@@ -111,6 +116,7 @@ declare class TgpuComputePipelineImpl implements TgpuComputePipeline {
     with(encoder: TgpuCommandEncoder): this;
     with(encoder: GPUCommandEncoder): this;
     with(pass: GPUComputePassEncoder): this;
+    pipe<T>(transform: (pipeline: this) => T): T;
     withPerformanceCallback(callback: (start: bigint, end: bigint) => void | Promise<void>): this;
     withTimestampWrites(options: {
         querySet: TgpuQuerySet<'timestamp'> | GPUQuerySet;

package/core/pipeline/computePipeline.js

@@ -111,6 +111,9 @@ class TgpuComputePipelineImpl {
         }
         throw new Error('Unsupported value passed into .with()');
     }
+    pipe(transform) {
+        return transform(this);
+    }
     withPerformanceCallback(callback) {
         const internals = this[$internal];
         if (internals.priors.timestampWrites) {

package/core/pipeline/renderPipeline.d.ts

@@ -89,6 +89,11 @@ export interface TgpuRenderPipeline<in Targets = never> extends TgpuNamable, Sel
     with(encoder: GPUCommandEncoder): this;
     with(pass: GPURenderPassEncoder): this;
     with(bundleEncoder: GPURenderBundleEncoder): this;
+    /**
+     * Applies a transform to this pipeline, letting packages hand out reusable
+     * configuration steps, e.g. `pipeline.pipe(mesh.inject())`.
+     */
+    pipe<T>(transform: (pipeline: this) => T): T;
     /**
      * Attaches texture views to the pipeline's targets (outputs).
      *
@@ -223,6 +228,7 @@ declare class TgpuRenderPipelineImpl implements TgpuRenderPipeline {
     with(encoder: GPUCommandEncoder): this;
     with(pass: GPURenderPassEncoder): this;
     with(bundleEncoder: GPURenderBundleEncoder): this;
+    pipe<T>(transform: (pipeline: this) => T): T;
     withPerformanceCallback(callback: (start: bigint, end: bigint) => void | Promise<void>): this;
     withTimestampWrites(options: {
         querySet: TgpuQuerySet<'timestamp'> | GPUQuerySet;

package/core/pipeline/renderPipeline.js

@@ -143,6 +143,9 @@ class TgpuRenderPipelineImpl {
         }
         throw new Error('Unsupported value passed into .with()');
     }
+    pipe(transform) {
+        return transform(this);
+    }
     withPerformanceCallback(callback) {
         const internals = this[$internal];
         if (internals.priors.timestampWrites) {

package/data/generalizeFn.d.ts

@@ -1,6 +1,7 @@
 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 Kind = 'number' | 'boolean' | Vec['kind'] | Mat['kind'];
 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;
 /**
@@ -15,11 +16,26 @@ export declare function generalizeFn<T extends Algebraic>(fn: (a: number, b: num
 /**
  * Analogous to `generalizeFn`, but the return type is a boolean vector instead.
  */
+export declare function generalizeBoolFn<T extends boolean | AnyBooleanVecInstance>(fn: (a: boolean) => boolean, args: [T]): T;
 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>;
+export declare function kindOf(v: Algebraic): Kind;
+export declare const u32Kind: Set<Kind>;
+export declare const f32Kind: Set<Kind>;
+export declare const f16Kind: Set<Kind>;
+export declare const matrixKind: Set<Kind>;
+export declare const booleanKind: Set<Kind>;
+export declare const floatKind: Set<Kind>;
+export declare const signedKind: Set<Kind>;
+export declare const numericKind: Set<Kind>;
+export declare const numericOrBooleanKind: Set<Kind>;
+export declare const numericOrMatrixKind: Set<Kind>;
+export declare const crossKind: Set<Kind>;
+export declare function assertKind(v: Algebraic | Algebraic[], valid: Set<Kind>, excludeScalar?: boolean): void;
+export declare function assertEqualKinds(...values: Algebraic[]): void;
 /**
  * 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 declare function upCast<T extends number | Vec | Mat>(args: [T, T]): [Exclude<T, number>, Exclude<T, number>];
 export {};

package/data/generalizeFn.js

@@ -1,7 +1,7 @@
 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";
+import { invariant, WgslTypeError } from "../errors.js";
 const booleanFor = {
     vec2f: vec2b,
     vec2h: vec2b,
@@ -62,7 +62,7 @@ export function generalizeFn(fn, args) {
 export function generalizeBoolFn(fn, args) {
     return applyArgs(fn, args, 'boolean');
 }
-function kindOf(v) {
+export function kindOf(v) {
     if (typeof v === 'number') {
         return 'number';
     }
@@ -71,6 +71,43 @@ function kindOf(v) {
     }
     return v.kind;
 }
+// Unless matrix is mentioned in the name, it is not included.
+const i32Kind = new Set(['number', 'vec2i', 'vec3i', 'vec4i']);
+export const u32Kind = new Set(['number', 'vec2u', 'vec3u', 'vec4u']);
+export const f32Kind = new Set(['number', 'vec2f', 'vec3f', 'vec4f']);
+export const f16Kind = new Set(['number', 'vec2h', 'vec3h', 'vec4h']);
+export const matrixKind = new Set(['mat2x2f', 'mat3x3f', 'mat4x4f']);
+export const booleanKind = new Set([
+    'boolean',
+    'vec2<bool>',
+    'vec3<bool>',
+    'vec4<bool>',
+]);
+export const floatKind = new Set([...f32Kind, ...f16Kind]);
+export const signedKind = new Set([...i32Kind, ...f32Kind, ...f16Kind]);
+export const numericKind = new Set([...signedKind, ...u32Kind]);
+export const numericOrBooleanKind = new Set([...numericKind, ...booleanKind]);
+export const numericOrMatrixKind = new Set([...numericKind, ...matrixKind]);
+export const crossKind = new Set(['vec3f', 'vec3h']);
+export function assertKind(v, valid, excludeScalar = false) {
+    if (!isVecInstance(v) && Array.isArray(v)) {
+        v.forEach((item) => assertKind(item, valid, excludeScalar));
+        return;
+    }
+    const kind = kindOf(v);
+    if (!valid.has(kind)) {
+        throw new WgslTypeError(`Unsupported signature. Expected one of '${[...valid].join(', ')}', got '${kind}'.`);
+    }
+    if (excludeScalar && (kind === 'number' || kind === 'boolean')) {
+        throw new WgslTypeError(`Unsupported signature. Expected kind to not be scalar, got '${kind}'.`);
+    }
+}
+export function assertEqualKinds(...values) {
+    const kinds = new Set(values.map(kindOf));
+    if (kinds.size !== 1) {
+        throw new WgslTypeError(`Unsupported signature. Expected the following kinds to be equal: '${[...kinds].join(', ')}'.`);
+    }
+}
 /**
  * If one of the arguments is a vector and other is a number,
  * the number is up-cased to a vector.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typegpu",
-  "version": "0.12.4",
+  "version": "0.12.5",
   "description": "A thin layer between JS and WebGPU/WGSL that improves development experience and allows for faster iteration.",
   "keywords": [
     "compute",

package/shared/meta.js

@@ -1,4 +1,4 @@
-const version = "0.12.4";
+const version = "0.12.5";
 import { DEV, TEST } from "./env.js";
 import { $getNameForward, $soul, isMarkedInternal } from "./symbols.js";
 import { normalizeMetadata } from "./normalizeMetadata.js";

package/shared/symbols.js

@@ -1,4 +1,4 @@
-const version = "0.12.4";
+const version = "0.12.5";
 export const $internal = Symbol(`typegpu:${version}:$internal`);
 /** A plain record of all definitional state of a resource, surviving transfer between runtimes */
 export const $soul = Symbol(`typegpu:${version}:$soul`);

package/shared/utilityTypes.d.ts

@@ -39,7 +39,7 @@ export type Assume<T, U> = T extends U ? T : U;
 /**
  * Any typed array
  */
-export type TypedArray = Uint8Array | Uint16Array | Uint32Array | Int32Array | Float32Array | Float64Array;
+export type TypedArray = Uint8Array | Uint16Array | Uint32Array | Int32Array | Float16Array | Float32Array | Float64Array;
 export declare function assertExhaustive(x: never, location: string): never;
 /**
  * Source: https://futurestud.io/tutorials/typescript-how-to-remove-index-signature-from-a-type

package/std/bitcast.js

@@ -9,6 +9,7 @@ import { SignatureNotSupportedError } from "../errors.js";
 import { getName } from "../shared/meta.js";
 import { comptime } from "../core/function/comptime.js";
 import { coerceToSnippet } from "../tgsl/generationHelpers.js";
+import { f32Kind, u32Kind, assertKind } from "../data/generalizeFn.js";
 const u32AllowedSchemas = [u32, vec2u, vec3u, vec4u];
 // TODO(#2731): Remove deprecated bitcasts. Remember about cpu implementations.
 /**
@@ -17,6 +18,7 @@ const u32AllowedSchemas = [u32, vec2u, vec3u, vec4u];
 export const bitcastU32toF32 = dualImpl({
     name: 'bitcastU32toF32',
     normalImpl: ((value) => {
+        assertKind(value, u32Kind);
         if (typeof value === 'number') {
             return bitcastU32toF32Impl(value);
         }
@@ -49,6 +51,7 @@ export const bitcastU32toF32 = dualImpl({
 export const bitcastU32toI32 = dualImpl({
     name: 'bitcastU32toI32',
     normalImpl: ((value) => {
+        assertKind(value, u32Kind);
         if (typeof value === 'number') {
             return bitcastU32toI32Impl(value);
         }
@@ -82,6 +85,7 @@ const f32AllowedSchemas = [f32, vec2f, vec3f, vec4f];
 export const bitcastF32toU32 = dualImpl({
     name: 'bitcastF32toU32',
     normalImpl: ((value) => {
+        assertKind(value, f32Kind);
         if (typeof value === 'number') {
             return bitcastF32toU32Impl(value);
         }

package/std/boolean.d.ts

@@ -93,7 +93,7 @@ export declare const and: import("../types.ts").DualFn<(<T extends AnyBooleanVec
  * all(vec2b(false, true)) // returns false
  * all(vec3b(true, true, true)) // returns true
  */
-export declare const all: import("../types.ts").DualFn<(value: AnyBooleanVecInstance) => boolean>;
+export declare const all: import("../types.ts").DualFn<(value: boolean | AnyBooleanVecInstance) => boolean>;
 /**
  * Returns `true` if any component of `value` is true.
  * @example

package/std/boolean.js

@@ -4,9 +4,9 @@ import { bool, f16, f32, i32, u32 } from "../data/numeric.js";
 import { isSnippetNumeric, snip } from "../data/snippet.js";
 import { vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u, } from "../data/vector.js";
 import { VectorOps } from "../data/vectorOps.js";
-import { generalizeBoolFn, generalizeFn } from "../data/generalizeFn.js";
-import { isBool, isVecBool, isVecBoolInstance, } from "../data/wgslTypes.js";
-import { SignatureNotSupportedError } from "../errors.js";
+import { booleanKind, floatKind, generalizeBoolFn, generalizeFn, kindOf, numericKind, numericOrBooleanKind, assertEqualKinds, assertKind, } from "../data/generalizeFn.js";
+import { isBool, isVecBool, isVecInstance, } from "../data/wgslTypes.js";
+import { SignatureNotSupportedError, WgslTypeError } from "../errors.js";
 import { unify } from "../tgsl/conversion.js";
 import { cpuCopy } from "./copy.js";
 function correspondingBooleanVectorSchema(dataType) {
@@ -33,7 +33,11 @@ export const allEq = dualImpl({
     codegenImpl: (_ctx, [lhs, rhs]) => stitch `all(${lhs} == ${rhs})`,
     sideEffects: false,
 });
-const cpuEq = (lhs, rhs) => generalizeBoolFn((a, b) => a === b, [lhs, rhs]);
+const cpuEq = (lhs, rhs) => {
+    assertKind([lhs, rhs], numericOrBooleanKind);
+    assertEqualKinds(lhs, rhs);
+    return generalizeBoolFn((a, b) => a === b, [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`.
@@ -71,7 +75,11 @@ export const ne = dualImpl({
     codegenImpl: (_ctx, [lhs, rhs]) => stitch `(${lhs} != ${rhs})`,
     sideEffects: false,
 });
-const cpuLt = (lhs, rhs) => generalizeBoolFn((a, b) => a < b, [lhs, rhs]);
+const cpuLt = (lhs, rhs) => {
+    assertKind([lhs, rhs], numericKind);
+    assertEqualKinds(lhs, rhs);
+    return generalizeBoolFn((a, b) => a < b, [lhs, rhs]);
+};
 /**
  * Checks **component-wise** whether `lhs < rhs`.
  * This function does **not** return `bool`, for that use-case, wrap the result in `all`.
@@ -145,20 +153,8 @@ export const ge = dualImpl({
     sideEffects: false,
 });
 function cpuNot(value) {
-    if (typeof value === 'boolean') {
-        return !value;
-    }
-    if (!isVecBoolInstance(value)) {
-        throw new Error(`'std.not' requires a boolean or boolean vector.`);
-    }
-    switch (value.length) {
-        case 2:
-            return vec2b(cpuNot(value.x), cpuNot(value.y));
-        case 3:
-            return vec3b(cpuNot(value.x), cpuNot(value.y), cpuNot(value.z));
-        case 4:
-            return vec4b(cpuNot(value.x), cpuNot(value.y), cpuNot(value.z), cpuNot(value.w));
-    }
+    assertKind(value, booleanKind);
+    return generalizeBoolFn((a) => !a, [value]);
 }
 /**
  * Returns the logical negation of the given value.
@@ -183,7 +179,11 @@ export const not = dualImpl({
     codegenImpl: (_ctx, [arg]) => stitch `!(${arg})`,
     sideEffects: false,
 });
-const cpuOr = (lhs, rhs) => generalizeBoolFn((a, b) => a || b, [lhs, rhs]);
+const cpuOr = (lhs, rhs) => {
+    assertKind([lhs, rhs], booleanKind);
+    assertEqualKinds(lhs, rhs);
+    return generalizeBoolFn((a, b) => a || b, [lhs, rhs]);
+};
 /**
  * Returns **component-wise** logical `or` result.
  * @example
@@ -212,7 +212,13 @@ export const and = dualImpl({
     sideEffects: false,
 });
 // logical aggregation
-const cpuAll = (value) => VectorOps.all[value.kind](value);
+const cpuAll = (value) => {
+    assertKind(value, booleanKind);
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    return VectorOps.all[value.kind](value);
+};
 /**
  * Returns `true` if each component of `value` is true.
  * @example
@@ -257,6 +263,8 @@ export const isCloseTo = dualImpl({
     }),
     // CPU implementation
     normalImpl: (lhs, rhs, precision = 0.01) => {
+        assertKind([lhs, rhs], floatKind);
+        assertEqualKinds(lhs, rhs);
         const componentResult = generalizeBoolFn((lhs, rhs) => Math.abs(lhs - rhs) < precision, [lhs, rhs]);
         return typeof componentResult === 'boolean' ? componentResult : all(componentResult);
     },
@@ -275,9 +283,15 @@ export const isCloseTo = dualImpl({
     sideEffects: false,
 });
 function cpuSelect(f, t, cond) {
+    assertKind([f, t], numericOrBooleanKind);
+    assertEqualKinds(f, t);
+    assertKind(cond, booleanKind);
     if (typeof cond === 'boolean') {
         return cpuCopy(cond ? t : f);
     }
+    if (!isVecInstance(f) || f.length !== cond.length) {
+        throw new WgslTypeError(`Select shape '(${kindOf(f)}, ${kindOf(t)}, ${kindOf(cond)})' is invalid.`);
+    }
     // generalizeFn will handle this fine, it just has no mixed type overload.
     return generalizeFn((f, t, c) => (c ? t : f), [f, t, cond]);
 }

package/std/derivative.js

@@ -5,7 +5,7 @@ export const dpdx = dualImpl({
     name: 'dpdx',
     normalImpl: derivativeNormalError,
     signature: (value) => ({ argTypes: [value], returnType: value }),
-    codegenImpl: (_ctx, [value]) => stitch `dpdx(${value})`,
+    codegenImpl: (ctx, [value]) => ctx.gen.emitCall('dpdx', [], [value]),
     sideEffects: false,
 });
 export const dpdxCoarse = dualImpl({
@@ -26,7 +26,7 @@ export const dpdy = dualImpl({
     name: 'dpdy',
     normalImpl: derivativeNormalError,
     signature: (value) => ({ argTypes: [value], returnType: value }),
-    codegenImpl: (_ctx, [value]) => stitch `dpdy(${value})`,
+    codegenImpl: (ctx, [value]) => ctx.gen.emitCall('dpdy', [], [value]),
     sideEffects: false,
 });
 export const dpdyCoarse = dualImpl({
@@ -47,7 +47,7 @@ export const fwidth = dualImpl({
     name: 'fwidth',
     normalImpl: derivativeNormalError,
     signature: (value) => ({ argTypes: [value], returnType: value }),
-    codegenImpl: (_ctx, [value]) => stitch `fwidth(${value})`,
+    codegenImpl: (ctx, [value]) => ctx.gen.emitCall('fwidth', [], [value]),
     sideEffects: false,
 });
 export const fwidthCoarse = dualImpl({

package/std/numeric.js

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

package/std/operators.d.ts

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

package/std/operators.js

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