typegpu 0.11.6 → 0.11.8

package/shared/meta.js

@@ -1,63 +1,70 @@
 import { version } from "../package.js";
 import { DEV, TEST } from "./env.js";
 import { $getNameForward, isMarkedInternal } from "./symbols.js";
+import { normalizeMetadata } from "./normalizeMetadata.js";
 
 //#region src/shared/meta.ts
-const globalWithMeta = globalThis;
-if (globalWithMeta.__TYPEGPU_VERSION__ !== void 0) console.warn(`Found duplicate TypeGPU version. First was ${globalWithMeta.__TYPEGPU_VERSION__}, this one is ${version}. This may cause unexpected behavior.`);
-globalWithMeta.__TYPEGPU_VERSION__ = version;
-globalWithMeta.__TYPEGPU_AUTONAME__ = (exp, label) => isNamable(exp) && isMarkedInternal(exp) && !getName(exp) ? exp.$name(label) : exp;
-/**
-* Performance measurements are only enabled in dev & test environments for now
-*/
-const PERF = (DEV || TEST) && {
-	get enabled() {
-		return !!globalWithMeta.__TYPEGPU_MEASURE_PERF__;
-	},
-	record(name, data) {
-		const records = globalWithMeta.__TYPEGPU_PERF_RECORDS__ ??= /* @__PURE__ */ new Map();
-		let entries = records.get(name);
-		if (!entries) {
-			entries = [];
-			records.set(name, entries);
-		}
-		entries.push(data);
-	}
-} || void 0;
+const globalExt = globalThis;
+if (globalExt.__TYPEGPU_VERSION__ !== void 0) console.warn(`Found duplicate TypeGPU version. First was ${globalExt.__TYPEGPU_VERSION__}, this one is ${version}. This may cause unexpected behavior.`);
+globalExt.__TYPEGPU_VERSION__ = version;
+globalExt.__TYPEGPU_AUTONAME__ = (exp, label) => isNamable(exp) && isMarkedInternal(exp) && !getName(exp) ? exp.$name(label) : exp;
+const nameMap = /* @__PURE__ */ new WeakMap();
+function isNamable(value) {
+	return !!value?.$name;
+}
 function isForwarded(value) {
 	return !!value?.[$getNameForward];
 }
 function getName(definition) {
 	if (isForwarded(definition)) return getName(definition[$getNameForward]);
-	return getMetaData(definition)?.name;
+	return nameMap.get(definition) ?? globalExt.__TYPEGPU_META__?.get(definition)?.name;
 }
 function setName(definition, name) {
 	if (isForwarded(definition)) {
 		setName(definition[$getNameForward], name);
 		return;
 	}
-	setMetaData(definition, { name });
+	nameMap.set(definition, name);
 }
-function isNamable(value) {
-	return !!value?.$name;
+const metadataMap = /* @__PURE__ */ new WeakMap();
+/**
+* Retrieves normalized (non-raw) function metadata.
+* If `globalExt.__TYPEGPU_META__` contains raw metadata for the function,
+* it is normalized, and then deleted to avoid unnecessary re-normalization.
+*/
+function getFunctionMetadata(definition) {
+	const maybeRawMeta = globalExt.__TYPEGPU_META__?.get(definition);
+	if (maybeRawMeta) {
+		globalExt.__TYPEGPU_META__?.delete(definition);
+		const normalized = normalizeMetadata(maybeRawMeta);
+		metadataMap.set(definition, normalized);
+		if (maybeRawMeta.name && nameMap.get(definition) === void 0) nameMap.set(definition, maybeRawMeta.name);
+	}
+	return metadataMap.get(definition);
 }
 /**
 * AST's are given to functions with a 'use gpu' directive, which this function checks for.
 */
 function hasTinyestMetadata(value) {
-	return !!getMetaData(value)?.ast;
-}
-function getMetaData(definition) {
-	return globalWithMeta.__TYPEGPU_META__.get(definition);
-}
-function setMetaData(definition, metaData) {
-	globalWithMeta.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap();
-	const map = globalWithMeta.__TYPEGPU_META__;
-	map.set(definition, {
-		...map.get(definition),
-		...metaData
-	});
+	return typeof value === "function" && !!getFunctionMetadata(value);
 }
+/**
+* Performance measurements are only enabled in dev & test environments for now
+*/
+const PERF = (DEV || TEST) && {
+	get enabled() {
+		return !!globalExt.__TYPEGPU_MEASURE_PERF__;
+	},
+	record(name, data) {
+		const records = globalExt.__TYPEGPU_PERF_RECORDS__ ??= /* @__PURE__ */ new Map();
+		let entries = records.get(name);
+		if (!entries) {
+			entries = [];
+			records.set(name, entries);
+		}
+		entries.push(data);
+	}
+} || void 0;
 
 //#endregion
-export { PERF, getMetaData, getName, hasTinyestMetadata, isNamable, setName };
+export { PERF, getFunctionMetadata, getName, hasTinyestMetadata, isNamable, setName };

package/shared/normalizeMetadata.d.ts

@@ -0,0 +1,32 @@
+import { Block, FuncParameter } from "tinyest";
+
+//#region src/shared/normalizeMetadata.d.ts
+interface RawMetadataV1 {
+  v: 1;
+  name: string;
+  ast: {
+    params: FuncParameter[];
+    body: Block;
+    externalNames: string[];
+  };
+  externals: Record<string, unknown> | (() => Record<string, unknown>);
+}
+interface ExternalsV2 {
+  [key: string]: ExternalsV2 | (() => unknown);
+}
+interface RawMetadataV2 {
+  v: 2;
+  name: string;
+  ast: {
+    params: FuncParameter[];
+    body: Block;
+    externalNames: string[];
+  };
+  externals: ExternalsV2;
+}
+/**
+ * Holds all function info collected by typegpu-unplugin
+ */
+type RawMetadata = RawMetadataV1 | RawMetadataV2;
+//#endregion
+export { RawMetadata };

package/shared/normalizeMetadata.js

@@ -0,0 +1,41 @@
+import { safeStringify } from "./stringify.js";
+
+//#region src/shared/normalizeMetadata.ts
+/**
+* The values of ExternalsV2 are zero-argument functions for accessing the value.
+* Since they would be recognized by the wgslGenerator as regular, non 'use gpu' functions,
+* we turn them into getters.
+*
+* @example
+* normalizeExternalsV2({ ext: { prop: () => ext.prop; }}); // { ext: { prop: [Getter] } }
+*/
+function normalizeExternalsV2(externals) {
+	const result = {};
+	for (const [key, value] of Object.entries(externals)) if (typeof value === "function") Object.defineProperty(result, key, {
+		get: value,
+		enumerable: true
+	});
+	else result[key] = normalizeExternalsV2(value);
+	return result;
+}
+function normalizeMetadata(meta) {
+	if (meta.v === 1) {
+		const rawExternals = meta.externals;
+		const externals = typeof rawExternals === "function" ? rawExternals : () => rawExternals;
+		return {
+			...meta,
+			externals
+		};
+	}
+	if (meta.v === 2) {
+		const externals = normalizeExternalsV2(meta?.externals);
+		return {
+			...meta,
+			externals: () => externals
+		};
+	}
+	throw new Error(`Unrecognized TypeGPU metadata format: ${safeStringify(meta)}`);
+}
+
+//#endregion
+export { normalizeMetadata };

package/std/atomic.js

@@ -1,6 +1,6 @@
 import { Void, isAtomic } from "../data/wgslTypes.js";
-import { stitch } from "../core/resolve/stitch.js";
 import { safeStringify } from "../shared/stringify.js";
+import { stitch } from "../core/resolve/stitch.js";
 import { i32, u32 } from "../data/numeric.js";
 import { dualImpl } from "../core/function/dualImpl.js";
 

package/std/boolean.js

@@ -2,8 +2,8 @@ import { isBool, isNumericSchema, isVec, isVecBool, isVecInstance } from "../dat
 import { isSnippetNumeric, snip } from "../data/snippet.js";
 import { stitch } from "../core/resolve/stitch.js";
 import { unify } from "../tgsl/conversion.js";
-import { bool, f32 } from "../data/numeric.js";
-import { vec2b, vec3b, vec4b } from "../data/vector.js";
+import { bool, f16, f32, i32, u32 } from "../data/numeric.js";
+import { vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u } from "../data/vector.js";
 import { dualImpl } from "../core/function/dualImpl.js";
 import { VectorOps } from "../data/vectorOps.js";
 import { sub } from "./operators.js";
@@ -271,6 +271,28 @@ function cpuSelect(f, t, cond) {
 	if (typeof cond === "boolean") return cond ? t : f;
 	return VectorOps.select[f.kind](f, t, cond);
 }
+const validSelectBranchTypes = [
+	f32,
+	f16,
+	i32,
+	u32,
+	bool,
+	vec2f,
+	vec3f,
+	vec4f,
+	vec2h,
+	vec3h,
+	vec4h,
+	vec2i,
+	vec3i,
+	vec4i,
+	vec2u,
+	vec3u,
+	vec4u,
+	vec2b,
+	vec3b,
+	vec4b
+];
 /**
 * Returns `t` if `cond` is `true`, and `f` otherwise.
 * Component-wise if `cond` is a vector.
@@ -283,7 +305,7 @@ function cpuSelect(f, t, cond) {
 const select = dualImpl({
 	name: "select",
 	signature: (f, t, cond) => {
-		const [uf, ut] = unify([f, t]) ?? [f, t];
+		const [uf, ut] = unify([f, t], validSelectBranchTypes) ?? [f, t];
 		return {
 			argTypes: [
 				uf,
@@ -294,8 +316,17 @@ const select = dualImpl({
 		};
 	},
 	normalImpl: cpuSelect,
-	codegenImpl: (_ctx, [f, t, cond]) => stitch`select(${f}, ${t}, ${cond})`
+	codegenImpl: (ctx, [f, t, cond]) => {
+		const result = stitch`select(${f}, ${t}, ${cond})`;
+		if (!validSelectBranchTypes.includes(f.dataType) || !validSelectBranchTypes.includes(t.dataType)) throw new Error(`'${result}' is invalid, std.select requires both branches to be either scalars or vectors.`);
+		if (f.dataType !== t.dataType) {
+			const fStr = ctx.resolve(f.dataType);
+			const tStr = ctx.resolve(t.dataType);
+			throw new Error(`'${result}' is invalid, std.select requires both branches to be the same type, got [${fStr.value}, ${tStr.value}].`);
+		}
+		return result;
+	}
 });
 
 //#endregion
-export { all, allEq, and, any, eq, ge, gt, isCloseTo, le, lt, ne, not, or, select };
+export { all, allEq, and, any, eq, ge, gt, isCloseTo, le, lt, ne, not, or, select, validSelectBranchTypes };

package/std/environment.d.ts

@@ -0,0 +1,48 @@
+import { DualFn } from "../types.js";
+import { TgpuComptime } from "../core/function/comptime.js";
+import "../indexNamedExports.js";
+
+//#region src/std/environment.d.ts
+
+/**
+ * Returns `true` when the direct callee is being transpiled for GPU, otherwise `false`.
+ *
+ * @example
+ * const f = () => {
+ *   'use gpu';
+ *   return isBeingTranspiled() ? 1 : 0;
+ * };
+ *
+ * f(); // returns 0, but resolved WGSL looks like this:
+ *
+ * fn f() -> i32 {
+ *   return 1;
+ * }
+ *
+ * @note
+ * Inside `comptime`, `lazy` or `simulate`, it always returns `false`.
+ */
+declare const isBeingTranspiled: DualFn<() => boolean>;
+/**
+ * Returns `wgsl` if invoked during the resolution process; otherwise, returns `undefined`.
+ *
+ * @example
+ * const f = () => {
+ *   'use gpu';
+ *   return getTargetShaderLanguage() === 'wgsl';
+ * };
+ *
+ * f(); // returns false, but resolved WGSL looks like this:
+ *
+ * fn f() -> bool {
+ *   return true;
+ * }
+ *
+ * @note
+ * Inside `lazy`, it always returns `wgsl`.
+ * Inside `simulate`, it always returns `undefined`.
+ * Inside `comptime`, it returns `wgsl` if called during the resolution process; otherwise, `undefined`.
+ */
+declare const getTargetShaderLanguage: TgpuComptime<() => string | undefined>;
+//#endregion
+export { getTargetShaderLanguage, isBeingTranspiled };

package/std/environment.js

@@ -0,0 +1,57 @@
+import { $gpuCallable } from "../shared/symbols.js";
+import { getExecMode, getResolutionCtx } from "../execMode.js";
+import { coerceToSnippet } from "../tgsl/generationHelpers.js";
+import { comptime } from "../core/function/comptime.js";
+
+//#region src/std/environment.ts
+const impl = (() => false);
+impl.toString = () => "isBeingTranspiled";
+impl[$gpuCallable] = { call(_ctx, _args) {
+	return coerceToSnippet(true);
+} };
+/**
+* Returns `true` when the direct callee is being transpiled for GPU, otherwise `false`.
+*
+* @example
+* const f = () => {
+*   'use gpu';
+*   return isBeingTranspiled() ? 1 : 0;
+* };
+*
+* f(); // returns 0, but resolved WGSL looks like this:
+*
+* fn f() -> i32 {
+*   return 1;
+* }
+*
+* @note
+* Inside `comptime`, `lazy` or `simulate`, it always returns `false`.
+*/
+const isBeingTranspiled = impl;
+/**
+* Returns `wgsl` if invoked during the resolution process; otherwise, returns `undefined`.
+*
+* @example
+* const f = () => {
+*   'use gpu';
+*   return getTargetShaderLanguage() === 'wgsl';
+* };
+*
+* f(); // returns false, but resolved WGSL looks like this:
+*
+* fn f() -> bool {
+*   return true;
+* }
+*
+* @note
+* Inside `lazy`, it always returns `wgsl`.
+* Inside `simulate`, it always returns `undefined`.
+* Inside `comptime`, it returns `wgsl` if called during the resolution process; otherwise, `undefined`.
+*/
+const getTargetShaderLanguage = comptime((() => {
+	if (!getResolutionCtx()) return;
+	return getExecMode().type !== "simulate" ? "wgsl" : void 0;
+}));
+
+//#endregion
+export { getTargetShaderLanguage, isBeingTranspiled };

package/std/extensions.d.ts

@@ -1,8 +1,8 @@
-import { WgslExtension } from "../wgslExtensions.js";
+import { WgslEnableExtension } from "../wgslExtensions.js";
 import { TgpuComptime } from "../core/function/comptime.js";
 import "../indexNamedExports.js";
 
 //#region src/std/extensions.d.ts
-declare const extensionEnabled: TgpuComptime<(extensionName: WgslExtension) => boolean>;
+declare const extensionEnabled: TgpuComptime<(extensionName: WgslEnableExtension) => boolean>;
 //#endregion
 export { extensionEnabled };

package/std/extensions.js

@@ -1,12 +1,12 @@
 import { getResolutionCtx } from "../execMode.js";
 import { comptime } from "../core/function/comptime.js";
-import { wgslExtensions } from "../wgslExtensions.js";
+import { wgslEnableExtensions } from "../wgslExtensions.js";
 
 //#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}'`);
+	if (typeof extensionName !== "string" || !wgslEnableExtensions.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);
 });
 

package/std/index.d.ts

@@ -14,10 +14,11 @@ import { subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, sub
 import { extensionEnabled } from "./extensions.js";
 import { bitcastU32toF32, bitcastU32toI32 } from "./bitcast.js";
 import { range } from "./range.js";
+import { getTargetShaderLanguage, isBeingTranspiled } from "./environment.js";
 
 //#region src/std/index.d.ts
 declare namespace index_d_exports {
-  export { abs, acos, acosh, add, all, allEq, and, any, arrayLength, asin, asinh, atan, atan2, atanh, atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, bitShiftLeft, bitShiftRight, bitcastU32toF32, bitcastU32toI32, ceil, clamp, copy, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, discard, distance, div, dot, dot4I8Packed, dot4U8Packed, dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, eq, exp, exp2, extensionEnabled, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, fwidth, fwidthCoarse, fwidthFine, ge, gt, identity2, identity3, identity4, insertBits, inverseSqrt, isCloseTo, ldexp, le, length, log, log2, lt, max, min, mix, mod, modf, mul, ne, neg, normalize, not, or, pack2x16float, pack4x8unorm, pow, quantizeToF16, radians, range, reflect, refract, reverseBits, rotateX4, rotateY4, rotateZ4, rotationX4, rotationY4, rotationZ4, round, saturate, scale4, scaling4, select, sign, sin, sinh, smoothstep, sqrt, step, storageBarrier, sub, subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, tan, tanh, textureBarrier, textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore, translate4, translation4, transpose, trunc, unpack2x16float, unpack4x8unorm, workgroupBarrier };
+  export { abs, acos, acosh, add, all, allEq, and, any, arrayLength, asin, asinh, atan, atan2, atanh, atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, bitShiftLeft, bitShiftRight, bitcastU32toF32, bitcastU32toI32, ceil, clamp, copy, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, discard, distance, div, dot, dot4I8Packed, dot4U8Packed, dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, eq, exp, exp2, extensionEnabled, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, fwidth, fwidthCoarse, fwidthFine, ge, getTargetShaderLanguage, gt, identity2, identity3, identity4, insertBits, inverseSqrt, isBeingTranspiled, isCloseTo, ldexp, le, length, log, log2, lt, max, min, mix, mod, modf, mul, ne, neg, normalize, not, or, pack2x16float, pack4x8unorm, pow, quantizeToF16, radians, range, reflect, refract, reverseBits, rotateX4, rotateY4, rotateZ4, rotationX4, rotationY4, rotationZ4, round, saturate, scale4, scaling4, select, sign, sin, sinh, smoothstep, sqrt, step, storageBarrier, sub, subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, tan, tanh, textureBarrier, textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore, translate4, translation4, transpose, trunc, unpack2x16float, unpack4x8unorm, workgroupBarrier };
 }
 //#endregion
-export { abs, acos, acosh, add, all, allEq, and, any, arrayLength, asin, asinh, atan, atan2, atanh, atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, bitShiftLeft, bitShiftRight, bitcastU32toF32, bitcastU32toI32, ceil, clamp, copy, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, discard, distance, div, dot, dot4I8Packed, dot4U8Packed, dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, eq, exp, exp2, extensionEnabled, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, fwidth, fwidthCoarse, fwidthFine, ge, gt, identity2, identity3, identity4, index_d_exports, insertBits, inverseSqrt, isCloseTo, ldexp, le, length, log, log2, lt, max, min, mix, mod, modf, mul, ne, neg, normalize, not, or, pack2x16float, pack4x8unorm, pow, quantizeToF16, radians, range, reflect, refract, reverseBits, rotateX4, rotateY4, rotateZ4, rotationX4, rotationY4, rotationZ4, round, saturate, scale4, scaling4, select, sign, sin, sinh, smoothstep, sqrt, step, storageBarrier, sub, subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, tan, tanh, textureBarrier, textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore, translate4, translation4, transpose, trunc, unpack2x16float, unpack4x8unorm, workgroupBarrier };
+export { abs, acos, acosh, add, all, allEq, and, any, arrayLength, asin, asinh, atan, atan2, atanh, atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, bitShiftLeft, bitShiftRight, bitcastU32toF32, bitcastU32toI32, ceil, clamp, copy, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, discard, distance, div, dot, dot4I8Packed, dot4U8Packed, dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, eq, exp, exp2, extensionEnabled, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, fwidth, fwidthCoarse, fwidthFine, ge, getTargetShaderLanguage, gt, identity2, identity3, identity4, index_d_exports, insertBits, inverseSqrt, isBeingTranspiled, isCloseTo, ldexp, le, length, log, log2, lt, max, min, mix, mod, modf, mul, ne, neg, normalize, not, or, pack2x16float, pack4x8unorm, pow, quantizeToF16, radians, range, reflect, refract, reverseBits, rotateX4, rotateY4, rotateZ4, rotationX4, rotationY4, rotationZ4, round, saturate, scale4, scaling4, select, sign, sin, sinh, smoothstep, sqrt, step, storageBarrier, sub, subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, tan, tanh, textureBarrier, textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore, translate4, translation4, transpose, trunc, unpack2x16float, unpack4x8unorm, workgroupBarrier };

package/std/index.js

@@ -4,9 +4,9 @@ import { add, bitShiftLeft, bitShiftRight, div, mod, mul, neg, sub } from "./ope
 import { abs, acos, acosh, asin, asinh, atan, atan2, atanh, ceil, clamp, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, distance, dot, dot4I8Packed, dot4U8Packed, exp, exp2, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, insertBits, inverseSqrt, ldexp, length, log, log2, max, min, mix, modf, normalize, pow, quantizeToF16, radians, reflect, refract, reverseBits, round, saturate, sign, sin, sinh, smoothstep, sqrt, step, tan, tanh, transpose, trunc } from "./numeric.js";
 import { arrayLength } from "./array.js";
 import { range } from "./range.js";
+import { all, allEq, and, any, eq, ge, gt, isCloseTo, le, lt, ne, not, or, select } from "./boolean.js";
 import { bitcastU32toF32, bitcastU32toI32 } from "./bitcast.js";
 import { pack2x16float, pack4x8unorm, unpack2x16float, unpack4x8unorm } from "./packing.js";
-import { all, allEq, and, any, eq, ge, gt, isCloseTo, le, lt, ne, not, or, select } from "./boolean.js";
 import { copy } from "./copy.js";
 import { discard } from "./discard.js";
 import { rotateX4, rotateY4, rotateZ4, scale4, translate4 } from "./matrix.js";
@@ -15,6 +15,7 @@ import { dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, fwidth, fwidthC
 import { textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore } from "./texture.js";
 import { subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor } from "./subgroup.js";
 import { extensionEnabled } from "./extensions.js";
+import { getTargetShaderLanguage, isBeingTranspiled } from "./environment.js";
 
 //#region src/std/index.ts
 var std_exports = /* @__PURE__ */ __export({
@@ -84,12 +85,14 @@ var std_exports = /* @__PURE__ */ __export({
 	fwidthCoarse: () => fwidthCoarse,
 	fwidthFine: () => fwidthFine,
 	ge: () => ge,
+	getTargetShaderLanguage: () => getTargetShaderLanguage,
 	gt: () => gt,
 	identity2: () => identity2,
 	identity3: () => identity3,
 	identity4: () => identity4,
 	insertBits: () => insertBits,
 	inverseSqrt: () => inverseSqrt,
+	isBeingTranspiled: () => isBeingTranspiled,
 	isCloseTo: () => isCloseTo,
 	ldexp: () => ldexp,
 	le: () => le,
@@ -181,4 +184,4 @@ var std_exports = /* @__PURE__ */ __export({
 });
 
 //#endregion
-export { abs, acos, acosh, add, all, allEq, and, any, arrayLength, asin, asinh, atan, atan2, atanh, atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, bitShiftLeft, bitShiftRight, bitcastU32toF32, bitcastU32toI32, ceil, clamp, copy, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, discard, distance, div, dot, dot4I8Packed, dot4U8Packed, dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, eq, exp, exp2, extensionEnabled, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, fwidth, fwidthCoarse, fwidthFine, ge, gt, identity2, identity3, identity4, insertBits, inverseSqrt, isCloseTo, ldexp, le, length, log, log2, lt, max, min, mix, mod, modf, mul, ne, neg, normalize, not, or, pack2x16float, pack4x8unorm, pow, quantizeToF16, radians, range, reflect, refract, reverseBits, rotateX4, rotateY4, rotateZ4, rotationX4, rotationY4, rotationZ4, round, saturate, scale4, scaling4, select, sign, sin, sinh, smoothstep, sqrt, std_exports, step, storageBarrier, sub, subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, tan, tanh, textureBarrier, textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore, translate4, translation4, transpose, trunc, unpack2x16float, unpack4x8unorm, workgroupBarrier };
+export { abs, acos, acosh, add, all, allEq, and, any, arrayLength, asin, asinh, atan, atan2, atanh, atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, bitShiftLeft, bitShiftRight, bitcastU32toF32, bitcastU32toI32, ceil, clamp, copy, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, discard, distance, div, dot, dot4I8Packed, dot4U8Packed, dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, eq, exp, exp2, extensionEnabled, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, fwidth, fwidthCoarse, fwidthFine, ge, getTargetShaderLanguage, gt, identity2, identity3, identity4, insertBits, inverseSqrt, isBeingTranspiled, isCloseTo, ldexp, le, length, log, log2, lt, max, min, mix, mod, modf, mul, ne, neg, normalize, not, or, pack2x16float, pack4x8unorm, pow, quantizeToF16, radians, range, reflect, refract, reverseBits, rotateX4, rotateY4, rotateZ4, rotationX4, rotationY4, rotationZ4, round, saturate, scale4, scaling4, select, sign, sin, sinh, smoothstep, sqrt, std_exports, step, storageBarrier, sub, subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, tan, tanh, textureBarrier, textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore, translate4, translation4, transpose, trunc, unpack2x16float, unpack4x8unorm, workgroupBarrier };

package/tgpuBindGroupLayout.js

@@ -1,7 +1,7 @@
 import { $gpuValueOf, $internal } from "./shared/symbols.js";
+import { safeStringify } from "./shared/stringify.js";
 import { getName, setName } from "./shared/meta.js";
 import { NotUniformError } from "./errors.js";
-import { safeStringify } from "./shared/stringify.js";
 import { f32, i32, u32 } from "./data/numeric.js";
 import { NotStorageError, isUsableAsStorage } from "./extension.js";
 import { TgpuLaidOutBufferImpl, isUsableAsUniform } from "./core/buffer/bufferUsage.js";

package/tgsl/accessIndex.js

@@ -1,6 +1,6 @@
-import { isNaturallyEphemeral, isPtr, isVec, isWgslArray, isWgslStruct } from "../data/wgslTypes.js";
+import { isPtr, isVec, isWgslArray, isWgslStruct } from "../data/wgslTypes.js";
 import { MatrixColumnsAccess, isDisarray } from "../data/dataTypes.js";
-import { isEphemeralSnippet, snip } from "../data/snippet.js";
+import { snip } from "../data/snippet.js";
 import { isKnownAtComptime } from "../types.js";
 import { stitch } from "../core/resolve/stitch.js";
 import { derefSnippet } from "../data/ref.js";
@@ -18,24 +18,18 @@ function accessIndex(target, indexArg) {
 	const index = typeof indexArg === "number" ? coerceToSnippet(indexArg) : indexArg;
 	if (isWgslArray(target.dataType) || isDisarray(target.dataType)) {
 		const elementType = target.dataType.elementType;
-		const isElementNatEph = isNaturallyEphemeral(elementType);
-		const isTargetEphemeral = isEphemeralSnippet(target);
-		const isIndexConstant = index.origin === "constant";
 		let origin;
-		if (target.origin === "constant-tgpu-const-ref") if (isIndexConstant) origin = isElementNatEph ? "constant" : "constant-tgpu-const-ref";
-		else origin = isElementNatEph ? "runtime" : "runtime-tgpu-const-ref";
-		else if (target.origin === "runtime-tgpu-const-ref") origin = isElementNatEph ? "runtime" : "runtime-tgpu-const-ref";
-		else if (!isTargetEphemeral && !isElementNatEph) origin = target.origin;
-		else if (isIndexConstant && target.origin === "constant") origin = "constant";
-		else origin = "runtime";
+		if (target.origin === "constant-immutable-def") origin = index.origin === "constant" || index.origin === "constant-immutable-def" ? "constant-immutable-def" : "runtime-immutable-def";
+		else if (target.origin === "constant") origin = index.origin === "constant" || index.origin === "constant-immutable-def" ? "constant" : "runtime";
+		else origin = target.origin;
 		if (target.value instanceof ArrayExpression && isKnownAtComptime(index)) return target.value.elements[index.value];
-		return snip(isKnownAtComptime(target) && isKnownAtComptime(index) ? target.value[index.value] : stitch`${target}[${index}]`, elementType, origin);
+		return snip(isKnownAtComptime(target) && isKnownAtComptime(index) ? target.value[index.value] : stitch`${target}[${index}]`, elementType, origin, target.possibleSideEffects || index.possibleSideEffects);
 	}
-	if (isVec(target.dataType)) return snip(isKnownAtComptime(target) && isKnownAtComptime(index) ? target.value[index.value] : stitch`${target}[${index}]`, target.dataType.primitive, target.origin === "constant" || target.origin === "constant-tgpu-const-ref" ? "constant" : "runtime");
+	if (isVec(target.dataType)) return snip(isKnownAtComptime(target) && isKnownAtComptime(index) ? target.value[index.value] : stitch`${target}[${index}]`, target.dataType.primitive, target.origin, target.possibleSideEffects || index.possibleSideEffects);
 	if (isPtr(target.dataType)) return accessIndex(derefSnippet(target), index);
 	if (target.value instanceof MatrixColumnsAccess) {
 		const propType = indexableTypeToResult[target.value.matrix.dataType.type];
-		return snip(stitch`${target.value.matrix}[${index}]`, propType, target.origin);
+		return snip(stitch`${target.value.matrix}[${index}]`, propType, target.origin, target.possibleSideEffects || index.possibleSideEffects);
 	}
 	if (target.dataType.type in indexableTypeToResult) throw new Error("The only way of accessing matrix elements in TypeGPU functions is through the 'columns' property.");
 	if (isKnownAtComptime(target) && isKnownAtComptime(index)) return coerceToSnippet(target.value[index.value]);

package/tgsl/accessProp.js

@@ -1,16 +1,15 @@
-import { $gpuCallable } from "../shared/symbols.js";
-import { isMat, isNaturallyEphemeral, isPtr, isVec, isWgslArray, isWgslStruct } from "../data/wgslTypes.js";
-import { InfixDispatch, MatrixColumnsAccess, UnknownData, isUnstruct, undecorate } from "../data/dataTypes.js";
-import { isEphemeralSnippet, isSnippet, snip } from "../data/snippet.js";
+import { isMat, isPtr, isVec, isWgslArray, isWgslStruct } from "../data/wgslTypes.js";
+import { MatrixColumnsAccess, UnknownData, isUnstruct, undecorate } from "../data/dataTypes.js";
+import { isSnippet, snip } from "../data/snippet.js";
 import { isKnownAtComptime } from "../types.js";
 import { stitch } from "../core/resolve/stitch.js";
 import { derefSnippet } from "../data/ref.js";
-import { abstractInt, bool, f16, f32, i32, u32 } from "../data/numeric.js";
-import { coerceToSnippet } from "./generationHelpers.js";
+import { bool, f16, f32, i32, u32 } from "../data/numeric.js";
+import { coerceToSnippet, numericLiteralToSnippet } from "./generationHelpers.js";
 import { vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u } from "../data/vector.js";
 import { AutoStruct } from "../data/autoStruct.js";
 import { EntryInputRouter } from "../core/function/entryInputRouter.js";
-import { add, bitShiftLeft, bitShiftRight, div, mod, mul, sub } from "../std/operators.js";
+import { InfixDispatch, infixOperators } from "./infixDispatch.js";
 
 //#region src/tgsl/accessProp.ts
 const infixKinds = [
@@ -30,15 +29,6 @@ const infixKinds = [
 	"mat3x3f",
 	"mat4x4f"
 ];
-const infixOperators = {
-	add,
-	sub,
-	mul,
-	div,
-	mod,
-	bitShiftLeft,
-	bitShiftRight
-};
 const swizzleLenToType = {
 	f: {
 		1: f32,
@@ -74,23 +64,23 @@ const swizzleLenToType = {
 function accessProp(target, propName) {
 	if (infixKinds.includes(target.dataType.type) && propName in infixOperators) {
 		const operator = infixOperators[propName];
-		return snip(new InfixDispatch(propName, target, operator[$gpuCallable].call.bind(operator)), UnknownData, target.origin);
+		return snip(new InfixDispatch(target, operator), UnknownData, target.origin, target.possibleSideEffects);
 	}
 	if (isWgslArray(target.dataType) && propName === "length") {
-		if (target.dataType.elementCount === 0) return snip(stitch`arrayLength(&${target})`, u32, "runtime");
-		return snip(target.dataType.elementCount, abstractInt, "constant");
+		if (target.dataType.elementCount === 0) return snip(stitch`arrayLength(&${target})`, u32, "runtime", target.possibleSideEffects);
+		return numericLiteralToSnippet(target.dataType.elementCount);
 	}
-	if (isMat(target.dataType) && propName === "columns") return snip(new MatrixColumnsAccess(target), UnknownData, target.origin);
+	if (isMat(target.dataType) && propName === "columns") return snip(new MatrixColumnsAccess(target), UnknownData, target.origin, target.possibleSideEffects);
 	if (isWgslStruct(target.dataType) || isUnstruct(target.dataType)) {
 		let propType = target.dataType.propTypes[propName];
 		if (!propType) return;
 		propType = undecorate(propType);
-		return snip(stitch`${target}.${propName}`, propType, target.origin === "argument" ? "argument" : !isEphemeralSnippet(target) && !isNaturallyEphemeral(propType) ? target.origin : target.origin === "constant" || target.origin === "constant-tgpu-const-ref" ? "constant" : "runtime");
+		return snip(stitch`${target}.${propName}`, propType, target.origin, target.possibleSideEffects);
 	}
 	if (target.dataType instanceof AutoStruct) {
 		const result = target.dataType.accessProp(propName);
 		if (!result) return;
-		return snip(stitch`${target}.${result.prop}`, result.type, "argument");
+		return snip(stitch`${target}.${result.prop}`, result.type, "argument", target.possibleSideEffects);
 	}
 	if (target.dataType instanceof EntryInputRouter) {
 		const result = target.dataType.accessProp(propName);
@@ -104,19 +94,16 @@ function accessProp(target, propName) {
 		return accessProp(derefed, propName);
 	}
 	if (isVec(target.dataType)) {
-		if (propName === "kind") return snip(target.dataType.type, UnknownData, "constant");
+		if (propName === "kind") return snip(target.dataType.type, UnknownData, "constant", false);
 	}
 	const propLength = propName.length;
-	if (isVec(target.dataType) && propLength >= 1 && propLength <= 4) {
-		const isXYZW = /^[xyzw]+$/.test(propName);
-		const isRGBA = /^[rgba]+$/.test(propName);
-		if (!isXYZW && !isRGBA) return;
+	if (isVec(target.dataType) && propLength >= 1 && propLength <= 4 && /^[xyzw]+$|^[rgba]+$/.test(propName)) {
 		const swizzleType = swizzleLenToType[target.dataType.type.includes("bool") ? "b" : target.dataType.type[4]][propLength];
 		if (!swizzleType) return;
-		return snip(isKnownAtComptime(target) ? target.value[propName] : stitch`${target}.${propName}`, swizzleType, target.origin === "argument" && propLength === 1 ? "argument" : target.origin === "constant" || target.origin === "constant-tgpu-const-ref" ? "constant" : "runtime");
+		return snip(isKnownAtComptime(target) ? target.value[propName] : stitch`${target}.${propName}`, swizzleType, propLength === 1 ? target.origin : target.origin === "constant" || target.origin === "constant-immutable-def" ? "constant" : "runtime", target.possibleSideEffects);
 	}
 	if (isKnownAtComptime(target) || target.dataType === UnknownData) return coerceToSnippet(target.value[propName]);
 }
 
 //#endregion
-export { accessProp, infixOperators };
+export { accessProp };

package/tgsl/consoleLog/serializers.js

@@ -1,5 +1,5 @@
-import { getName } from "../../shared/meta.js";
 import { isWgslArray, isWgslStruct } from "../../data/wgslTypes.js";
+import { getName } from "../../shared/meta.js";
 import { bool, f16, f32, i32, u32 } from "../../data/numeric.js";
 import { vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u } from "../../data/vector.js";
 import { sizeOf } from "../../data/sizeOf.js";

package/tgsl/conversion.js

@@ -1,12 +1,12 @@
 import { DEV, TEST } from "../shared/env.js";
 import { isMat, isPtr, isVec } from "../data/wgslTypes.js";
+import { safeStringify } from "../shared/stringify.js";
 import { UnknownData, undecorate } from "../data/dataTypes.js";
-import { snip } from "../data/snippet.js";
+import { snip, withDataType } from "../data/snippet.js";
 import { WgslTypeError, invariant } from "../errors.js";
 import { stitch } from "../core/resolve/stitch.js";
 import { RefOperator, derefSnippet } from "../data/ref.js";
 import { schemaCallWrapperGPU } from "../data/schemaCallWrapper.js";
-import { safeStringify } from "../shared/stringify.js";
 import { assertExhaustive } from "../shared/utilityTypes.js";
 
 //#region src/tgsl/conversion.ts
@@ -160,7 +160,7 @@ function getBestConversion(types, targetTypes) {
 function applyActionToSnippet(ctx, snippet, action, targetType) {
 	if (action.action === "none") {
 		if (targetType === snippet.dataType) return snippet;
-		return snip(snippet.value, targetType, snippet.origin);
+		return withDataType(targetType, snippet);
 	}
 	switch (action.action) {
 		case "ref": return snip(new RefOperator(snippet, targetType), targetType, snippet.origin);