typegpu 0.12.4 → 0.12.6

package/std/atomic.js

@@ -1,6 +1,9 @@
 import { dualImpl } from "../core/function/dualImpl.js";
 import { stitch } from "../core/resolve/stitch.js";
-import { i32, u32 } from "../data/numeric.js";
+import { unptr } from "../data/dataTypes.js";
+import { bool, i32, u32 } from "../data/numeric.js";
+import { derefSnippet } from "../data/ref.js";
+import { abstruct } from "../data/struct.js";
 import { isAtomic, Void, } from "../data/wgslTypes.js";
 import { safeStringify } from "../shared/stringify.js";
 export const workgroupBarrier = dualImpl({
@@ -24,33 +27,40 @@ export const textureBarrier = dualImpl({
     codegenImpl: () => 'textureBarrier()',
     sideEffects: true,
 });
-const atomicNormalError = 'Atomic operations are not supported outside of CODEGEN mode.';
-export 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 };
+export const workgroupUniformLoad = dualImpl({
+    name: 'workgroupUniformLoad',
+    normalImpl: 'workgroupUniformLoad is not supported outside of CODEGEN mode.',
+    signature: (value) => {
+        const inner = unptr(value);
+        return {
+            argTypes: [value],
+            returnType: isAtomic(inner) ? inner.inner : inner,
+        };
     },
-    codegenImpl: (_ctx, [a]) => stitch `atomicLoad(&${a})`,
+    codegenImpl: (_ctx, [value]) => stitch `workgroupUniformLoad(&${derefSnippet(value)})`,
     sideEffects: true,
 });
-const atomicActionSignature = (a) => {
-    if (!isAtomic(a)) {
+const atomicNormalError = 'Atomic operations are not supported outside of CODEGEN mode.';
+const unwrapAtomic = (a) => {
+    const inner = unptr(a);
+    if (!isAtomic(inner)) {
         throw new Error(`Invalid atomic type: ${safeStringify(a)}`);
     }
-    return {
-        argTypes: [a, a.inner.type === 'u32' ? u32 : i32],
-        returnType: Void,
-    };
+    return inner;
 };
+export const atomicLoad = dualImpl({
+    name: 'atomicLoad',
+    normalImpl: atomicNormalError,
+    signature: (a) => ({ argTypes: [a], returnType: unwrapAtomic(a).inner }),
+    codegenImpl: (_ctx, [a]) => stitch `atomicLoad(&${derefSnippet(a)})`,
+    sideEffects: true,
+});
+const atomicActionSignature = (a) => ({
+    argTypes: [a, unwrapAtomic(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;
+    const paramType = unwrapAtomic(a).inner.type === 'u32' ? u32 : i32;
     return {
         argTypes: [a, paramType],
         returnType: paramType,
@@ -60,55 +70,79 @@ export const atomicStore = dualImpl({
     name: 'atomicStore',
     normalImpl: atomicNormalError,
     signature: atomicActionSignature,
-    codegenImpl: (_ctx, [a, value]) => stitch `atomicStore(&${a}, ${value})`,
+    codegenImpl: (_ctx, [a, value]) => stitch `atomicStore(&${derefSnippet(a)}, ${value})`,
     sideEffects: true,
 });
 export const atomicAdd = dualImpl({
     name: 'atomicAdd',
     normalImpl: atomicNormalError,
     signature: atomicOpSignature,
-    codegenImpl: (_ctx, [a, value]) => stitch `atomicAdd(&${a}, ${value})`,
+    codegenImpl: (_ctx, [a, value]) => stitch `atomicAdd(&${derefSnippet(a)}, ${value})`,
     sideEffects: true,
 });
 export const atomicSub = dualImpl({
     name: 'atomicSub',
     normalImpl: atomicNormalError,
     signature: atomicOpSignature,
-    codegenImpl: (_ctx, [a, value]) => stitch `atomicSub(&${a}, ${value})`,
+    codegenImpl: (_ctx, [a, value]) => stitch `atomicSub(&${derefSnippet(a)}, ${value})`,
     sideEffects: true,
 });
 export const atomicMax = dualImpl({
     name: 'atomicMax',
     normalImpl: atomicNormalError,
     signature: atomicOpSignature,
-    codegenImpl: (_ctx, [a, value]) => stitch `atomicMax(&${a}, ${value})`,
+    codegenImpl: (_ctx, [a, value]) => stitch `atomicMax(&${derefSnippet(a)}, ${value})`,
     sideEffects: true,
 });
 export const atomicMin = dualImpl({
     name: 'atomicMin',
     normalImpl: atomicNormalError,
     signature: atomicOpSignature,
-    codegenImpl: (_ctx, [a, value]) => stitch `atomicMin(&${a}, ${value})`,
+    codegenImpl: (_ctx, [a, value]) => stitch `atomicMin(&${derefSnippet(a)}, ${value})`,
     sideEffects: true,
 });
 export const atomicAnd = dualImpl({
     name: 'atomicAnd',
     normalImpl: atomicNormalError,
     signature: atomicOpSignature,
-    codegenImpl: (_ctx, [a, value]) => stitch `atomicAnd(&${a}, ${value})`,
+    codegenImpl: (_ctx, [a, value]) => stitch `atomicAnd(&${derefSnippet(a)}, ${value})`,
     sideEffects: true,
 });
 export const atomicOr = dualImpl({
     name: 'atomicOr',
     normalImpl: atomicNormalError,
     signature: atomicOpSignature,
-    codegenImpl: (_ctx, [a, value]) => stitch `atomicOr(&${a}, ${value})`,
+    codegenImpl: (_ctx, [a, value]) => stitch `atomicOr(&${derefSnippet(a)}, ${value})`,
     sideEffects: true,
 });
 export const atomicXor = dualImpl({
     name: 'atomicXor',
     normalImpl: atomicNormalError,
     signature: atomicOpSignature,
-    codegenImpl: (_ctx, [a, value]) => stitch `atomicXor(&${a}, ${value})`,
+    codegenImpl: (_ctx, [a, value]) => stitch `atomicXor(&${derefSnippet(a)}, ${value})`,
+    sideEffects: true,
+});
+export const atomicExchange = dualImpl({
+    name: 'atomicExchange',
+    normalImpl: atomicNormalError,
+    signature: atomicOpSignature,
+    codegenImpl: (_ctx, [a, value]) => stitch `atomicExchange(&${derefSnippet(a)}, ${value})`,
+    sideEffects: true,
+});
+const AtomicCompareExchangeResults = {
+    i32: abstruct({ old_value: i32, exchanged: bool }),
+    u32: abstruct({ old_value: u32, exchanged: bool }),
+};
+export const atomicCompareExchangeWeak = dualImpl({
+    name: 'atomicCompareExchangeWeak',
+    normalImpl: atomicNormalError,
+    signature: (a) => {
+        const inner = unwrapAtomic(a).inner.type === 'u32' ? u32 : i32;
+        return {
+            argTypes: [a, inner, inner],
+            returnType: AtomicCompareExchangeResults[inner.type],
+        };
+    },
+    codegenImpl: (_ctx, [a, compare, value]) => stitch `atomicCompareExchangeWeak(&${derefSnippet(a)}, ${compare}, ${value})`,
     sideEffects: true,
 });

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

@@ -1,66 +1,71 @@
 import { dualImpl } from "../core/function/dualImpl.js";
 import { stitch } from "../core/resolve/stitch.js";
+import { f32 } from "../data/numeric.js";
+import { vec2f, vec3f, vec4f } from "../data/vector.js";
+import { unifyRestrictedSignature } from "./numeric.js";
 const derivativeNormalError = 'Derivative builtins are not allowed on the CPU';
+// WGSL derivative builtins only accept f32 and vecN<f32>
+const derivativeSignature = unifyRestrictedSignature([f32, vec2f, vec3f, vec4f]);
 export const dpdx = dualImpl({
     name: 'dpdx',
     normalImpl: derivativeNormalError,
-    signature: (value) => ({ argTypes: [value], returnType: value }),
-    codegenImpl: (_ctx, [value]) => stitch `dpdx(${value})`,
+    signature: derivativeSignature,
+    codegenImpl: (ctx, [value]) => ctx.gen.emitCall('dpdx', [], [value]),
     sideEffects: false,
 });
 export const dpdxCoarse = dualImpl({
     name: 'dpdxCoarse',
     normalImpl: derivativeNormalError,
-    signature: (value) => ({ argTypes: [value], returnType: value }),
+    signature: derivativeSignature,
     codegenImpl: (_ctx, [value]) => stitch `dpdxCoarse(${value})`,
     sideEffects: false,
 });
 export const dpdxFine = dualImpl({
     name: 'dpdxFine',
     normalImpl: derivativeNormalError,
-    signature: (value) => ({ argTypes: [value], returnType: value }),
+    signature: derivativeSignature,
     codegenImpl: (_ctx, [value]) => stitch `dpdxFine(${value})`,
     sideEffects: false,
 });
 export const dpdy = dualImpl({
     name: 'dpdy',
     normalImpl: derivativeNormalError,
-    signature: (value) => ({ argTypes: [value], returnType: value }),
-    codegenImpl: (_ctx, [value]) => stitch `dpdy(${value})`,
+    signature: derivativeSignature,
+    codegenImpl: (ctx, [value]) => ctx.gen.emitCall('dpdy', [], [value]),
     sideEffects: false,
 });
 export const dpdyCoarse = dualImpl({
     name: 'dpdyCoarse',
     normalImpl: derivativeNormalError,
-    signature: (value) => ({ argTypes: [value], returnType: value }),
+    signature: derivativeSignature,
     codegenImpl: (_ctx, [value]) => stitch `dpdyCoarse(${value})`,
     sideEffects: false,
 });
 export const dpdyFine = dualImpl({
     name: 'dpdyFine',
     normalImpl: derivativeNormalError,
-    signature: (value) => ({ argTypes: [value], returnType: value }),
+    signature: derivativeSignature,
     codegenImpl: (_ctx, [value]) => stitch `dpdyFine(${value})`,
     sideEffects: false,
 });
 export const fwidth = dualImpl({
     name: 'fwidth',
     normalImpl: derivativeNormalError,
-    signature: (value) => ({ argTypes: [value], returnType: value }),
-    codegenImpl: (_ctx, [value]) => stitch `fwidth(${value})`,
+    signature: derivativeSignature,
+    codegenImpl: (ctx, [value]) => ctx.gen.emitCall('fwidth', [], [value]),
     sideEffects: false,
 });
 export const fwidthCoarse = dualImpl({
     name: 'fwidthCoarse',
     normalImpl: derivativeNormalError,
-    signature: (value) => ({ argTypes: [value], returnType: value }),
+    signature: derivativeSignature,
     codegenImpl: (_ctx, [value]) => stitch `fwidthCoarse(${value})`,
     sideEffects: false,
 });
 export const fwidthFine = dualImpl({
     name: 'fwidthFine',
     normalImpl: derivativeNormalError,
-    signature: (value) => ({ argTypes: [value], returnType: value }),
+    signature: derivativeSignature,
     codegenImpl: (_ctx, [value]) => stitch `fwidthFine(${value})`,
     sideEffects: false,
 });

package/std/index.d.ts

@@ -8,12 +8,12 @@ export { add, bitShiftLeft, bitShiftRight, div, mod, mul, neg, sub } from './ope
 export { rotateX4, rotateY4, rotateZ4, scale4, translate4 } from './matrix.ts';
 export { identity2, identity3, identity4, rotationX4, rotationY4, rotationZ4, scaling4, translation4, } from '../data/matrix.ts';
 export { allEq, eq, ne, lt, le, gt, ge, not, or, and, all, any, isCloseTo, select, } from './boolean.ts';
-export { atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, workgroupBarrier, storageBarrier, textureBarrier, } from './atomic.ts';
+export { atomicAdd, atomicAnd, atomicCompareExchangeWeak, atomicExchange, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, workgroupBarrier, storageBarrier, textureBarrier, workgroupUniformLoad, } from './atomic.ts';
 export { dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, fwidth, fwidthCoarse, fwidthFine, } from './derivative.ts';
 export { arrayLength } from './array.ts';
-export { pack4x8unorm, pack2x16float, unpack4x8unorm, unpack2x16float, } from './packing.ts';
-export { textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore, } from './texture.ts';
-export { subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, } from './subgroup.ts';
+export { pack2x16float, pack2x16snorm, pack2x16unorm, pack4x8snorm, pack4x8unorm, pack4xI8, pack4xI8Clamp, pack4xU8, pack4xU8Clamp, unpack2x16float, unpack2x16snorm, unpack2x16unorm, unpack4x8snorm, unpack4x8unorm, unpack4xI8, unpack4xU8, } from './packing.ts';
+export { textureDimensions, textureGather, textureGatherCompare, textureLoad, textureNumLayers, textureNumLevels, textureNumSamples, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore, } from './texture.ts';
+export { subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, quadBroadcast, quadSwapDiagonal, quadSwapX, quadSwapY, } from './subgroup.ts';
 export { extensionEnabled } from './extensions.ts';
 export { bitcastU32toF32, bitcastU32toI32, bitcastF32toU32, bitcast } from './bitcast.ts';
 export { range } from './range.ts';

package/std/index.js

@@ -17,15 +17,15 @@ not, or, and,
 all, any, 
 // other
 isCloseTo, select, } from "./boolean.js";
-export { atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, 
+export { atomicAdd, atomicAnd, atomicCompareExchangeWeak, atomicExchange, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, 
 // synchronization
-workgroupBarrier, storageBarrier, textureBarrier, } from "./atomic.js";
+workgroupBarrier, storageBarrier, textureBarrier, workgroupUniformLoad, } from "./atomic.js";
 export { dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, fwidth, fwidthCoarse, fwidthFine, } from "./derivative.js";
 export { arrayLength } from "./array.js";
 // oxfmt-ignore
-export { pack4x8unorm, pack2x16float, unpack4x8unorm, unpack2x16float, } from "./packing.js";
-export { textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore, } from "./texture.js";
-export { subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, } from "./subgroup.js";
+export { pack2x16float, pack2x16snorm, pack2x16unorm, pack4x8snorm, pack4x8unorm, pack4xI8, pack4xI8Clamp, pack4xU8, pack4xU8Clamp, unpack2x16float, unpack2x16snorm, unpack2x16unorm, unpack4x8snorm, unpack4x8unorm, unpack4xI8, unpack4xU8, } from "./packing.js";
+export { textureDimensions, textureGather, textureGatherCompare, textureLoad, textureNumLayers, textureNumLevels, textureNumSamples, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore, } from "./texture.js";
+export { subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, quadBroadcast, quadSwapDiagonal, quadSwapX, quadSwapY, } from "./subgroup.js";
 export { extensionEnabled } from "./extensions.js";
 export { bitcastU32toF32, bitcastU32toI32, bitcastF32toU32, bitcast } from "./bitcast.js";
 export { range } from "./range.js";

package/std/numeric.d.ts

@@ -1,6 +1,10 @@
-import { type AnyFloat32VecInstance, type AnyFloatVecInstance, type AnyIntegerVecInstance, type AnyMatInstance, type AnyNumericVecInstance, type AnySignedVecInstance, type v2f, type v2h, type v2i, type v3f, type v3h, type v3i, type v4f, type v4h, type v4i, type Vec2f } from '../data/wgslTypes.ts';
+import { type AnyFloat32VecInstance, type AnyFloatVecInstance, type AnyIntegerVecInstance, type AnyMatInstance, type AnyNumericVecInstance, type AnySignedVecInstance, type BaseData, type v2f, type v2h, type v2i, type v3f, type v3h, type v3i, type v4f, type v4h, type v4i, type Vec2f } from '../data/wgslTypes.ts';
 import type { Infer } from '../shared/repr.ts';
 type NumVec = AnyNumericVecInstance;
+export declare const unifyRestrictedSignature: (restrict: BaseData[]) => (...args: BaseData[]) => {
+    argTypes: BaseData[];
+    returnType: BaseData;
+};
 declare function cpuAbs(value: number): number;
 declare function cpuAbs<T extends NumVec | number>(value: T): T;
 export declare const abs: import("../types.ts").DualFn<typeof cpuAbs>;