typegpu 0.10.2 → 0.11.0

package/std/subgroup.d.ts

@@ -22,26 +22,26 @@ interface IdentityNumOrVecWithMask {
   (e: number, mask: number): number;
   <T extends AnyNumericVecInstance>(e: T, mask: number): T;
 }
-declare const subgroupAdd: DualFn<IdentityNumOrVec>;
-declare const subgroupExclusiveAdd: DualFn<IdentityNumOrVec>;
-declare const subgroupInclusiveAdd: DualFn<IdentityNumOrVec>;
-declare const subgroupAll: DualFn<(e: boolean) => boolean>;
-declare const subgroupAnd: DualFn<IdentityIntNumOrVec>;
-declare const subgroupAny: DualFn<(e: boolean) => boolean>;
-declare const subgroupBallot: DualFn<(e: boolean) => v4u>;
-declare const subgroupBroadcast: DualFn<IdentityNumOrVecWithIdx>;
-declare const subgroupBroadcastFirst: DualFn<IdentityNumOrVec>;
-declare const subgroupElect: DualFn<() => boolean>;
-declare const subgroupMax: DualFn<IdentityNumOrVec>;
-declare const subgroupMin: DualFn<IdentityNumOrVec>;
-declare const subgroupMul: DualFn<IdentityNumOrVec>;
-declare const subgroupExclusiveMul: DualFn<IdentityNumOrVec>;
-declare const subgroupInclusiveMul: DualFn<IdentityNumOrVec>;
-declare const subgroupOr: DualFn<IdentityIntNumOrVec>;
-declare const subgroupShuffle: DualFn<IdentityNumOrVecWithIdx>;
-declare const subgroupShuffleDown: DualFn<IdentityNumOrVecWithDelta>;
-declare const subgroupShuffleUp: DualFn<IdentityNumOrVecWithDelta>;
-declare const subgroupShuffleXor: DualFn<IdentityNumOrVecWithMask>;
-declare const subgroupXor: DualFn<IdentityIntNumOrVec>;
+declare const subgroupAdd: DualFn;
+declare const subgroupExclusiveAdd: DualFn;
+declare const subgroupInclusiveAdd: DualFn;
+declare const subgroupAll: DualFn;
+declare const subgroupAnd: DualFn;
+declare const subgroupAny: DualFn;
+declare const subgroupBallot: DualFn;
+declare const subgroupBroadcast: DualFn;
+declare const subgroupBroadcastFirst: DualFn;
+declare const subgroupElect: DualFn;
+declare const subgroupMax: DualFn;
+declare const subgroupMin: DualFn;
+declare const subgroupMul: DualFn;
+declare const subgroupExclusiveMul: DualFn;
+declare const subgroupInclusiveMul: DualFn;
+declare const subgroupOr: DualFn;
+declare const subgroupShuffle: DualFn;
+declare const subgroupShuffleDown: DualFn;
+declare const subgroupShuffleUp: DualFn;
+declare const subgroupShuffleXor: DualFn;
+declare const subgroupXor: DualFn;
 //#endregion
 export { subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor };

package/std/subgroup.js

@@ -3,7 +3,6 @@ import { unify } from "../tgsl/conversion.js";
 import { bool, i32, u32 } from "../data/numeric.js";
 import { vec4u } from "../data/vector.js";
 import { dualImpl } from "../core/function/dualImpl.js";
-
 //#region src/std/subgroup.ts
 const errorMessage = "Subgroup operations can only be used in the GPU context.";
 const subgroupAdd = dualImpl({
@@ -215,6 +214,5 @@ const subgroupXor = dualImpl({
 	normalImpl: errorMessage,
 	codegenImpl: (_ctx, [e]) => stitch`subgroupXor(${e})`
 });
-
 //#endregion
-export { subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor };
+export { subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor };

package/std/texture.d.ts

@@ -15,13 +15,13 @@ declare function sampleCpu<T extends textureCubeArray>(texture: T, sampler: samp
 declare function sampleCpu<T extends textureDepth2d>(texture: T, sampler: sampler, coords: v2f, offset?: v2i): number;
 declare function sampleCpu<T extends textureDepth2dArray>(texture: T, sampler: sampler, coords: v2f, arrayIndex: number, offset?: v2i): number;
 declare function sampleCpu<T extends textureDepthCube>(texture: T, sampler: sampler, coords: v3f, arrayIndex?: number): number;
-declare const textureSample: DualFn<typeof sampleCpu>;
+declare const textureSample: DualFn;
 declare function sampleBiasCpu<T extends texture1d>(texture: T, sampler: sampler, coords: number, bias: number): v4f;
 declare function sampleBiasCpu<T extends texture2d>(texture: T, sampler: sampler, coords: v2f, bias: number, offset?: v2i): v4f;
 declare function sampleBiasCpu<T extends texture2dArray>(texture: T, sampler: sampler, coords: v2f, arrayIndex: number, bias: number, offset?: v2i): v4f;
 declare function sampleBiasCpu<T extends texture3d | textureCube>(texture: T, sampler: sampler, coords: v3f, bias: number, offset?: v3i): v4f;
 declare function sampleBiasCpu<T extends textureCubeArray>(texture: T, sampler: sampler, coords: v3f, arrayIndex: number, bias: number): v4f;
-declare const textureSampleBias: DualFn<typeof sampleBiasCpu>;
+declare const textureSampleBias: DualFn;
 declare function sampleLevelCpu<T extends texture1d>(texture: T, sampler: sampler, coords: number, level: number): v4f;
 declare function sampleLevelCpu<T extends texture2d>(texture: T, sampler: sampler, coords: v2f, level: number): v4f;
 declare function sampleLevelCpu<T extends texture2d>(texture: T, sampler: sampler, coords: v2f, level: number, offset: v2i): v4f;
@@ -36,7 +36,7 @@ declare function sampleLevelCpu<T extends textureDepth2dArray>(texture: T, sampl
 declare function sampleLevelCpu<T extends textureDepth2dArray>(texture: T, sampler: sampler, coords: v2f, arrayIndex: number, level: number, offset: v2i): number;
 declare function sampleLevelCpu<T extends textureDepthCube>(texture: T, sampler: sampler, coords: v3f, level: number): number;
 declare function sampleLevelCpu<T extends textureCubeArray>(texture: T, sampler: sampler, coords: v3f, arrayIndex: number, level: number): number;
-declare const textureSampleLevel: DualFn<typeof sampleLevelCpu>;
+declare const textureSampleLevel: DualFn;
 type PrimitiveToLoadedType = {
   f32: v4f;
   i32: v4i;
@@ -56,19 +56,19 @@ declare function textureLoadCpu<T extends textureStorage1d>(texture: T, coords:
 declare function textureLoadCpu<T extends textureStorage2d>(texture: T, coords: v2i | v2u): TexelFormatToInstanceType<T[typeof $internal][0]>;
 declare function textureLoadCpu<T extends textureStorage2dArray>(texture: T, coords: v2i | v2u, arrayIndex: number): TexelFormatToInstanceType<T[typeof $internal][0]>;
 declare function textureLoadCpu<T extends textureStorage3d>(texture: T, coords: v3i | v3u): TexelFormatToInstanceType<T[typeof $internal][0]>;
-declare const textureLoad: DualFn<typeof textureLoadCpu>;
+declare const textureLoad: DualFn;
 declare function textureStoreCpu<T extends textureStorage1d>(texture: T, coords: number, value: TexelFormatToInstanceType<T[typeof $internal][0]>): void;
 declare function textureStoreCpu<T extends textureStorage2d>(texture: T, coords: v2i | v2u, value: TexelFormatToInstanceType<T[typeof $internal][0]>): void;
 declare function textureStoreCpu<T extends textureStorage2dArray>(texture: T, coords: v2i | v2u, arrayIndex: number, value: TexelFormatToInstanceType<T[typeof $internal][0]>): void;
 declare function textureStoreCpu<T extends textureStorage3d>(texture: T, coords: v3i | v3u, value: TexelFormatToInstanceType<T[typeof $internal][0]>): void;
-declare const textureStore: DualFn<typeof textureStoreCpu>;
+declare const textureStore: DualFn;
 declare function textureDimensionsCpu<T extends texture1d | textureStorage1d>(texture: T): number;
 declare function textureDimensionsCpu<T extends texture1d>(texture: T, level: number): number;
 declare function textureDimensionsCpu<T extends texture2d | texture2dArray | textureCube | textureCubeArray | textureStorage2d | textureStorage2dArray | textureExternal>(texture: T): v2u;
 declare function textureDimensionsCpu<T extends texture2d | texture2dArray | textureCube | textureCubeArray>(texture: T, level: number): v2u;
 declare function textureDimensionsCpu<T extends texture3d | textureStorage3d>(texture: T): v3u;
 declare function textureDimensionsCpu<T extends texture3d>(texture: T, level: number): v3u;
-declare const textureDimensions: DualFn<typeof textureDimensionsCpu>;
+declare const textureDimensions: DualFn;
 type Gather2dArgs<T extends texture2d = texture2d> = [component: number, texture: T, sampler: sampler, coords: v2f, offset?: v2i];
 type Gather2dArrayArgs<T extends texture2dArray = texture2dArray> = [component: number, texture: T, sampler: sampler, coords: v2f, arrayIndex: number, offset?: v2i];
 type GatherCubeArgs<T extends textureCube = textureCube> = [component: number, texture: T, sampler: sampler, coords: v3f];
@@ -87,22 +87,31 @@ type TextureGatherCpuFn = {
   (...args: GatherDepthCubeArgs): v4f;
   (...args: GatherDepthCubeArrayArgs): v4f;
 };
-declare const textureGather: DualFn<TextureGatherCpuFn>;
+declare const textureGather: DualFn;
 declare function textureSampleCompareCpu<T extends textureDepth2d>(texture: T, sampler: comparisonSampler, coords: v2f, depthRef: number): number;
 declare function textureSampleCompareCpu<T extends textureDepth2d>(texture: T, sampler: comparisonSampler, coords: v2f, depthRef: number, offset: v2i): number;
 declare function textureSampleCompareCpu<T extends textureDepth2dArray>(texture: T, sampler: comparisonSampler, coords: v2f, arrayIndex: number, depthRef: number): number;
 declare function textureSampleCompareCpu<T extends textureDepth2dArray>(texture: T, sampler: comparisonSampler, coords: v2f, arrayIndex: number, depthRef: number, offset: v2i): number;
 declare function textureSampleCompareCpu<T extends textureDepthCube>(texture: T, sampler: comparisonSampler, coords: v3f, depthRef: number): number;
 declare function textureSampleCompareCpu<T extends textureDepthCubeArray>(texture: T, sampler: comparisonSampler, coords: v3f, arrayIndex: number, depthRef: number): number;
-declare const textureSampleCompare: DualFn<typeof textureSampleCompareCpu>;
+declare const textureSampleCompare: DualFn;
 declare function textureSampleCompareLevelCpu<T extends textureDepth2d>(texture: T, sampler: comparisonSampler, coords: v2f, depthRef: number): number;
 declare function textureSampleCompareLevelCpu<T extends textureDepth2d>(texture: T, sampler: comparisonSampler, coords: v2f, depthRef: number, offset: v2i): number;
 declare function textureSampleCompareLevelCpu<T extends textureDepth2dArray>(texture: T, sampler: comparisonSampler, coords: v2f, arrayIndex: number, depthRef: number): number;
 declare function textureSampleCompareLevelCpu<T extends textureDepth2dArray>(texture: T, sampler: comparisonSampler, coords: v2f, arrayIndex: number, depthRef: number, offset: v2i): number;
 declare function textureSampleCompareLevelCpu<T extends textureDepthCube>(texture: T, sampler: comparisonSampler, coords: v3f, depthRef: number): number;
 declare function textureSampleCompareLevelCpu<T extends textureDepthCubeArray>(texture: T, sampler: comparisonSampler, coords: v3f, arrayIndex: number, depthRef: number): number;
-declare const textureSampleCompareLevel: DualFn<typeof textureSampleCompareLevelCpu>;
+declare const textureSampleCompareLevel: DualFn;
 declare function textureSampleBaseClampToEdgeCpu<T extends texture2d | textureExternal>(_texture: T, _sampler: sampler, _coords: v2f): v4f;
-declare const textureSampleBaseClampToEdge: DualFn<typeof textureSampleBaseClampToEdgeCpu>;
+declare function sampleGradCpu<T extends texture2d>(texture: T, sampler: sampler, coords: v2f, ddx: v2f, ddy: v2f): v4f;
+declare function sampleGradCpu<T extends texture2d>(texture: T, sampler: sampler, coords: v2f, ddx: v2f, ddy: v2f, offset: v2i): v4f;
+declare function sampleGradCpu<T extends texture2dArray>(texture: T, sampler: sampler, coords: v2f, arrayIndex: number, ddx: v2f, ddy: v2f): v4f;
+declare function sampleGradCpu<T extends texture2dArray>(texture: T, sampler: sampler, coords: v2f, arrayIndex: number, ddx: v2f, ddy: v2f, offset: v2i): v4f;
+declare function sampleGradCpu<T extends texture3d>(texture: T, sampler: sampler, coords: v3f, ddx: v3f, ddy: v3f): v4f;
+declare function sampleGradCpu<T extends texture3d>(texture: T, sampler: sampler, coords: v3f, ddx: v3f, ddy: v3f, offset: v3i): v4f;
+declare function sampleGradCpu<T extends textureCube>(texture: T, sampler: sampler, coords: v3f, ddx: v3f, ddy: v3f): v4f;
+declare function sampleGradCpu<T extends textureCubeArray>(texture: T, sampler: sampler, coords: v3f, arrayIndex: number, ddx: v3f, ddy: v3f): v4f;
+declare const textureSampleGrad: DualFn;
+declare const textureSampleBaseClampToEdge: DualFn;
 //#endregion
-export { textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleLevel, textureStore };
+export { textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore };

package/std/texture.js

@@ -5,7 +5,6 @@ import { vec2u, vec3u, vec4f, vec4i, vec4u } from "../data/vector.js";
 import { MissingCpuImplError, dualImpl } from "../core/function/dualImpl.js";
 import { isWgslExternalTexture, isWgslTexture } from "../data/texture.js";
 import { getTextureFormatInfo } from "../core/texture/textureFormats.js";
-
 //#region src/std/texture.ts
 function sampleCpu(_texture, _sampler, _coords, _offsetOrArrayIndex, _maybeOffset) {
 	throw new MissingCpuImplError("Texture sampling relies on GPU resources and cannot be executed outside of a draw call");
@@ -183,6 +182,18 @@ const textureSampleCompareLevel = dualImpl({
 function textureSampleBaseClampToEdgeCpu(_texture, _sampler, _coords) {
 	throw new MissingCpuImplError("Texture sampling with base clamp to edge is not supported outside of GPU mode.");
 }
+function sampleGradCpu(_texture, _sampler, _coords, _ddxOrArrayIndex, _ddyOrDdx, _offsetOrDdy, _maybeOffset) {
+	throw new MissingCpuImplError("Texture sampling with gradients relies on GPU resources and cannot be executed outside of a draw call");
+}
+const textureSampleGrad = dualImpl({
+	name: "textureSampleGrad",
+	normalImpl: sampleGradCpu,
+	codegenImpl: (_ctx, args) => stitch`textureSampleGrad(${args})`,
+	signature: (...args) => ({
+		argTypes: args,
+		returnType: vec4f
+	})
+});
 const textureSampleBaseClampToEdge = dualImpl({
 	name: "textureSampleBaseClampToEdge",
 	normalImpl: textureSampleBaseClampToEdgeCpu,
@@ -192,6 +203,5 @@ const textureSampleBaseClampToEdge = dualImpl({
 		returnType: vec4f
 	})
 });
-
 //#endregion
-export { textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleLevel, textureStore };
+export { textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore };

package/tgpu.js

@@ -15,7 +15,6 @@ import { accessor, mutableAccessor } from "./core/slot/accessor.js";
 import { fragmentFn } from "./core/function/tgpuFragmentFn.js";
 import { vertexFn } from "./core/function/tgpuVertexFn.js";
 import { tgpuUnstable_exports } from "./tgpuUnstable.js";
-
 //#region src/tgpu.ts
 var tgpu_exports = /* @__PURE__ */ __exportAll({
 	accessor: () => accessor,
@@ -39,6 +38,5 @@ var tgpu_exports = /* @__PURE__ */ __exportAll({
 	workgroupVar: () => workgroupVar,
 	"~unstable": () => tgpuUnstable_exports
 });
-
 //#endregion
-export { tgpu_exports };
+export { tgpu_exports };

package/tgpuBindGroupLayout.js

@@ -3,16 +3,15 @@ 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 { comparisonSampler, sampler } from "./data/sampler.js";
-import { textureDescriptorToSchema } from "./data/texture.js";
 import { NotStorageError, isUsableAsStorage } from "./extension.js";
 import { TgpuLaidOutBufferImpl, isUsableAsUniform } from "./core/buffer/bufferUsage.js";
 import { isBuffer } from "./core/buffer/buffer.js";
+import { comparisonSampler, sampler } from "./data/sampler.js";
 import { TgpuLaidOutSamplerImpl, isComparisonSampler, isSampler } from "./core/sampler/sampler.js";
+import { textureDescriptorToSchema } from "./data/texture.js";
 import { TgpuExternalTextureImpl } from "./core/texture/externalTexture.js";
 import { TgpuLaidOutTextureViewImpl, isTexture, isTextureView } from "./core/texture/texture.js";
 import { NotSampledError, isUsableAsSampled } from "./core/texture/usageExtension.js";
-
 //#region src/tgpuBindGroupLayout.ts
 /**
 * Converts legacy entries to new API format
@@ -84,11 +83,12 @@ const DEFAULT_READONLY_VISIBILITY = [
 	"fragment"
 ];
 var TgpuBindGroupLayoutImpl = class {
+	#index;
 	[$internal];
-	_index;
 	resourceType = "bind-group-layout";
 	value = {};
 	$ = this.value;
+	entries;
 	get [$gpuValueOf]() {
 		return this.$;
 	}
@@ -126,7 +126,7 @@ var TgpuBindGroupLayoutImpl = class {
 		return `bindGroupLayout:${getName(this) ?? "<unnamed>"}`;
 	}
 	get index() {
-		return this._index;
+		return this.#index;
 	}
 	$name(label) {
 		setName(this, label);
@@ -136,7 +136,7 @@ var TgpuBindGroupLayoutImpl = class {
 		return this[$internal].bound;
 	}
 	$idx(index) {
-		this._index = index;
+		this.#index = index;
 		return this;
 	}
 	unwrap(unwrapper) {
@@ -188,6 +188,8 @@ var TgpuBindGroupLayoutImpl = class {
 };
 var TgpuBindGroupImpl = class {
 	resourceType = "bind-group";
+	layout;
+	entries;
 	constructor(layout, entries) {
 		this.layout = layout;
 		this.entries = entries;
@@ -266,6 +268,5 @@ var TgpuBindGroupImpl = class {
 		});
 	}
 };
-
 //#endregion
-export { TgpuBindGroupImpl, bindGroupLayout, isBindGroup, isBindGroupLayout };
+export { TgpuBindGroupImpl, bindGroupLayout, isBindGroup, isBindGroupLayout };

package/tgpuUnstable.js

@@ -14,7 +14,6 @@ import { vertexFn } from "./core/function/tgpuVertexFn.js";
 import { declare } from "./core/declare/tgpuDeclare.js";
 import { rawCodeSnippet } from "./core/rawCodeSnippet/tgpuRawCodeSnippet.js";
 import { simulate } from "./core/simulate/tgpuSimulate.js";
-
 //#region src/tgpuUnstable.ts
 var tgpuUnstable_exports = /* @__PURE__ */ __exportAll({
 	accessor: () => _accessor,
@@ -61,6 +60,5 @@ const _privateVar = privateVar;
 const _workgroupVar = workgroupVar;
 /** @deprecated This feature is now stable, use tgpu.vertexLayout. */
 const _vertexLayout = vertexLayout;
-
 //#endregion
-export { tgpuUnstable_exports };
+export { tgpuUnstable_exports };

package/tgsl/accessIndex.js

@@ -4,10 +4,9 @@ import { isEphemeralSnippet, snip } from "../data/snippet.js";
 import { isKnownAtComptime } from "../types.js";
 import { stitch } from "../core/resolve/stitch.js";
 import { derefSnippet } from "../data/ref.js";
-import { vec2f, vec3f, vec4f } from "../data/vector.js";
 import { coerceToSnippet } from "./generationHelpers.js";
+import { vec2f, vec3f, vec4f } from "../data/vector.js";
 import { accessProp } from "./accessProp.js";
-
 //#region src/tgsl/accessIndex.ts
 const indexableTypeToResult = {
 	mat2x2f: vec2f,
@@ -40,6 +39,5 @@ function accessIndex(target, indexArg) {
 	if (isKnownAtComptime(target) && isKnownAtComptime(index) || target.dataType === UnknownData) return coerceToSnippet(target.value[index.value]);
 	if (isWgslStruct(target.dataType) && isKnownAtComptime(index) && typeof index.value === "string") return accessProp(target, index.value);
 }
-
 //#endregion
-export { accessIndex };
+export { accessIndex };

package/tgsl/accessProp.js

@@ -6,11 +6,11 @@ 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 { 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 { coerceToSnippet } from "./generationHelpers.js";
-import { add, div, mod, mul, sub } from "../std/operators.js";
-
+import { EntryInputRouter } from "../core/function/entryInputRouter.js";
+import { add, bitShiftLeft, bitShiftRight, div, mod, mul, sub } from "../std/operators.js";
 //#region src/tgsl/accessProp.ts
 const infixKinds = [
 	"vec2f",
@@ -34,7 +34,9 @@ const infixOperators = {
 	sub,
 	mul,
 	div,
-	mod
+	mod,
+	bitShiftLeft,
+	bitShiftRight
 };
 const swizzleLenToType = {
 	f: {
@@ -89,6 +91,7 @@ function accessProp(target, propName) {
 		if (!result) return;
 		return snip(stitch`${target}.${result.prop}`, result.type, "argument");
 	}
+	if (target.dataType instanceof EntryInputRouter) return target.dataType.accessProp(propName);
 	if (isPtr(target.dataType)) {
 		const derefed = derefSnippet(target);
 		if (propName === "$") return derefed;
@@ -108,6 +111,5 @@ function accessProp(target, propName) {
 	}
 	if (isKnownAtComptime(target) || target.dataType === UnknownData) return coerceToSnippet(target.value[propName]);
 }
-
 //#endregion
-export { accessProp, infixOperators };
+export { accessProp, infixOperators };

package/tgsl/consoleLog/deserializers.js

@@ -5,7 +5,6 @@ import { sizeOf } from "../../data/sizeOf.js";
 import { mat2x2f, mat3x3f, mat4x4f } from "../../data/matrix.js";
 import { bitcastU32toF32, bitcastU32toI32 } from "../../std/bitcast.js";
 import { unpack2x16float } from "../../std/packing.js";
-
 //#region src/tgsl/consoleLog/deserializers.ts
 const toF = (n) => bitcastU32toF32(n ?? 0);
 const toI = (n) => bitcastU32toI32(n ?? 0);
@@ -112,6 +111,5 @@ function logDataFromGPU(resources) {
 	dataBuffer.buffer.clear();
 	indexBuffer.buffer.clear();
 }
-
 //#endregion
-export { logDataFromGPU };
+export { logDataFromGPU };

package/tgsl/consoleLog/logGenerator.js

@@ -4,14 +4,13 @@ import { UnknownData } from "../../data/dataTypes.js";
 import { snip } from "../../data/snippet.js";
 import { stitch } from "../../core/resolve/stitch.js";
 import { u32 } from "../../data/numeric.js";
-import { struct } from "../../data/struct.js";
 import { concretizeSnippets } from "../generationHelpers.js";
+import { struct } from "../../data/struct.js";
 import { shaderStageSlot } from "../../core/slot/internalSlots.js";
 import { arrayOf } from "../../data/array.js";
 import { atomic } from "../../data/atomic.js";
 import { createLoggingFunction } from "./serializers.js";
 import { supportedLogOps } from "./types.js";
-
 //#region src/tgsl/consoleLog/logGenerator.ts
 const defaultOptions = {
 	logCountLimit: 64,
@@ -81,6 +80,5 @@ var LogGeneratorImpl = class {
 		};
 	}
 };
-
 //#endregion
-export { LogGeneratorImpl, LogGeneratorNullImpl };
+export { LogGeneratorImpl, LogGeneratorNullImpl };

package/tgsl/consoleLog/serializers.js

@@ -7,7 +7,6 @@ import { mat2x2f, mat3x3f, mat4x4f } from "../../data/matrix.js";
 import { fn } from "../../core/function/tgpuFn.js";
 import { slot } from "../../core/slot/slot.js";
 import { privateVar } from "../../core/variable/tgpuVariable.js";
-
 //#region src/tgsl/consoleLog/serializers.ts
 const dataBlockIndex = privateVar(u32, 0).$name("dataBlockIndex");
 const dataByteIndex = privateVar(u32, 0).$name("dataByteIndex");
@@ -19,99 +18,99 @@ const nextByteIndex = fn([], u32)`() {
 }`.$uses({ dataByteIndex }).$name("nextByteIndex");
 const nextU32 = "dataBuffer[dataBlockIndex].serializedData[nextByteIndex()]";
 const serializerMap = {
-	f32: fn([f32])`(n) => {
+	f32: fn([f32])`(n) {
   ${nextU32} = bitcast<u32>(n);
 }`,
-	f16: fn([f16])`(n) => {
+	f16: fn([f16])`(n) {
   ${nextU32} = pack2x16float(vec2f(f32(n), 0.0));
 }`,
-	i32: fn([i32])`(n) => {
+	i32: fn([i32])`(n) {
   ${nextU32} = bitcast<u32>(n);
 }`,
-	u32: fn([u32])`(n) => {
+	u32: fn([u32])`(n) {
   ${nextU32} = n;
 }`,
-	bool: fn([bool])`(b) => {
+	bool: fn([bool])`(b) {
   ${nextU32} = u32(b);
 }`,
-	vec2f: fn([vec2f])`(v) => {
+	vec2f: fn([vec2f])`(v) {
   ${nextU32} = bitcast<u32>(v.x);
   ${nextU32} = bitcast<u32>(v.y);
 }`,
-	vec3f: fn([vec3f])`(v) => {
+	vec3f: fn([vec3f])`(v) {
   ${nextU32} = bitcast<u32>(v.x);
   ${nextU32} = bitcast<u32>(v.y);
   ${nextU32} = bitcast<u32>(v.z);
 }`,
-	vec4f: fn([vec4f])`(v) => {
+	vec4f: fn([vec4f])`(v) {
   ${nextU32} = bitcast<u32>(v.x);
   ${nextU32} = bitcast<u32>(v.y);
   ${nextU32} = bitcast<u32>(v.z);
   ${nextU32} = bitcast<u32>(v.w);
 }`,
-	vec2h: fn([vec2h])`(v) => {
+	vec2h: fn([vec2h])`(v) {
   ${nextU32} = pack2x16float(vec2f(f32(v.x), f32(v.y)));
 }`,
-	vec3h: fn([vec3h])`(v) => {
+	vec3h: fn([vec3h])`(v) {
   ${nextU32} = pack2x16float(vec2f(f32(v.x), f32(v.y)));
   ${nextU32} = pack2x16float(vec2f(f32(v.z), 0.0));
 }`,
-	vec4h: fn([vec4h])`(v) => {
+	vec4h: fn([vec4h])`(v) {
   ${nextU32} = pack2x16float(vec2f(f32(v.x), f32(v.y)));
   ${nextU32} = pack2x16float(vec2f(f32(v.z), f32(v.w)));
 }`,
-	vec2i: fn([vec2i])`(v) => {
+	vec2i: fn([vec2i])`(v) {
   ${nextU32} = bitcast<u32>(v.x);
   ${nextU32} = bitcast<u32>(v.y);
 }`,
-	vec3i: fn([vec3i])`(v) => {
+	vec3i: fn([vec3i])`(v) {
   ${nextU32} = bitcast<u32>(v.x);
   ${nextU32} = bitcast<u32>(v.y);
   ${nextU32} = bitcast<u32>(v.z);
 }`,
-	vec4i: fn([vec4i])`(v) => {
+	vec4i: fn([vec4i])`(v) {
   ${nextU32} = bitcast<u32>(v.x);
   ${nextU32} = bitcast<u32>(v.y);
   ${nextU32} = bitcast<u32>(v.z);
   ${nextU32} = bitcast<u32>(v.w);
 }`,
-	vec2u: fn([vec2u])`(v) => {
+	vec2u: fn([vec2u])`(v) {
   ${nextU32} = v.x;
   ${nextU32} = v.y;
 }`,
-	vec3u: fn([vec3u])`(v) => {
+	vec3u: fn([vec3u])`(v) {
   ${nextU32} = v.x;
   ${nextU32} = v.y;
   ${nextU32} = v.z;
 }`,
-	vec4u: fn([vec4u])`(v) => {
+	vec4u: fn([vec4u])`(v) {
   ${nextU32} = v.x;
   ${nextU32} = v.y;
   ${nextU32} = v.z;
   ${nextU32} = v.w;
 }`,
-	"vec2<bool>": fn([vec2b])`(v) => {
+	"vec2<bool>": fn([vec2b])`(v) {
   ${nextU32} = u32(v.x);
   ${nextU32} = u32(v.y);
 }`,
-	"vec3<bool>": fn([vec3b])`(v) => {
+	"vec3<bool>": fn([vec3b])`(v) {
   ${nextU32} = u32(v.x);
   ${nextU32} = u32(v.y);
   ${nextU32} = u32(v.z);
 }`,
-	"vec4<bool>": fn([vec4b])`(v) => {
+	"vec4<bool>": fn([vec4b])`(v) {
   ${nextU32} = u32(v.x);
   ${nextU32} = u32(v.y);
   ${nextU32} = u32(v.z);
   ${nextU32} = u32(v.w);
 }`,
-	mat2x2f: fn([mat2x2f])`(m) => {
+	mat2x2f: fn([mat2x2f])`(m) {
   ${nextU32} = bitcast<u32>(m[0][0]);
   ${nextU32} = bitcast<u32>(m[0][1]);
   ${nextU32} = bitcast<u32>(m[1][0]);
   ${nextU32} = bitcast<u32>(m[1][1]);
 }`,
-	mat3x3f: fn([mat3x3f])`(m) => {
+	mat3x3f: fn([mat3x3f])`(m) {
   ${nextU32} = bitcast<u32>(m[0][0]);
   ${nextU32} = bitcast<u32>(m[0][1]);
   ${nextU32} = bitcast<u32>(m[0][2]);
@@ -125,7 +124,7 @@ const serializerMap = {
   ${nextU32} = bitcast<u32>(m[2][2]);
   ${nextU32} = 0u;
 }`,
-	mat4x4f: fn([mat4x4f])`(m) => {
+	mat4x4f: fn([mat4x4f])`(m) {
   ${nextU32} = bitcast<u32>(m[0][0]);
   ${nextU32} = bitcast<u32>(m[0][1]);
   ${nextU32} = bitcast<u32>(m[0][2]);
@@ -220,6 +219,5 @@ function createLoggingFunction(id, dataTypes, dataBuffer, indexBuffer, logOption
 		compoundSerializer
 	}).$name(`log${id}`);
 }
-
 //#endregion
-export { createLoggingFunction };
+export { createLoggingFunction };

package/tgsl/consoleLog/types.d.ts

@@ -1,6 +1,4 @@
-import "../../data/snippet.js";
 import { TgpuMutable } from "../../core/buffer/bufferShorthand.js";
-import "../generationHelpers.js";
 import { AnyWgslData, Atomic, U32, WgslArray, WgslStruct } from "../../data/wgslTypes.js";
 
 //#region src/tgsl/consoleLog/types.d.ts

package/tgsl/consoleLog/types.js

@@ -7,6 +7,5 @@ const supportedLogOps = [
 	"error",
 	"clear"
 ];
-
 //#endregion
-export { supportedLogOps };
+export { supportedLogOps };

package/tgsl/conversion.js

@@ -8,7 +8,6 @@ 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
 const INFINITE_RANK = {
 	rank: Number.POSITIVE_INFINITY,
@@ -195,6 +194,5 @@ function convertStructValues(ctx, structType, values) {
 		return convertToCommonType(ctx, [val], [targetType])?.[0] ?? val;
 	});
 }
-
 //#endregion
-export { convertStructValues, convertToCommonType, getBestConversion, tryConvertSnippet, unify };
+export { convertStructValues, convertToCommonType, getBestConversion, tryConvertSnippet, unify };

package/tgsl/forOfUtils.js

@@ -5,11 +5,11 @@ import { isEphemeralSnippet, snip } from "../data/snippet.js";
 import { WgslTypeError, invariant } from "../errors.js";
 import { stitch } from "../core/resolve/stitch.js";
 import { createPtrFromOrigin, implicitFrom } from "../data/ptr.js";
-import { u32 } from "../data/numeric.js";
+import { i32, u32 } from "../data/numeric.js";
 import { ArrayExpression, concretize } from "./generationHelpers.js";
 import { accessIndex } from "./accessIndex.js";
 import { arrayLength } from "../std/array.js";
-
+import { isTgpuRange } from "../std/range.js";
 //#region src/tgsl/forOfUtils.ts
 function getLoopVarKind(elementSnippet) {
 	return elementSnippet.origin === "constant-tgpu-const-ref" ? "const" : "let";
@@ -30,16 +30,42 @@ function getElementType(elementSnippet, iterableSnippet) {
 	}
 	return implicitFrom(elementType);
 }
-function getElementCountSnippet(ctx, iterableSnippet, unroll = false) {
+function getRangeSnippets(ctx, iterableSnippet, unroll = false) {
 	const { value, dataType } = iterableSnippet;
-	if (isWgslArray(dataType)) return dataType.elementCount > 0 ? snip(dataType.elementCount, u32, "constant") : arrayLength[$gpuCallable].call(ctx, [iterableSnippet]);
-	if (isVec(dataType)) return snip(dataType.componentCount, u32, "constant");
+	if (isTgpuRange(value)) return {
+		start: snip(value.start, i32, "constant"),
+		end: snip(value.end, i32, "constant"),
+		step: snip(value.step, i32, "constant"),
+		comparison: value.step < 0 ? ">" : "<"
+	};
+	if (!unroll && isEphemeralSnippet(iterableSnippet)) throw new Error(`\`for ... of ...\` loops only support std.range or iterables stored in variables.
+-----
+You can wrap iterable with \`tgpu.unroll(...)\`. If iterable is known at comptime, the loop will be unrolled.
+-----`);
+	const defaults = {
+		start: snip(0, u32, "constant"),
+		step: snip(1, u32, "constant"),
+		comparison: "<"
+	};
+	if (isWgslArray(dataType)) return {
+		...defaults,
+		end: dataType.elementCount > 0 ? snip(dataType.elementCount, u32, "constant") : arrayLength[$gpuCallable].call(ctx, [iterableSnippet])
+	};
+	if (isVec(dataType)) return {
+		...defaults,
+		end: snip(dataType.componentCount, u32, "constant")
+	};
 	if (unroll) {
-		if (Array.isArray(value)) return snip(value.length, u32, "constant");
-		if (value instanceof ArrayExpression) return snip(value.elements.length, u32, "constant");
+		if (Array.isArray(value)) return {
+			...defaults,
+			end: snip(value.length, u32, "constant")
+		};
+		if (value instanceof ArrayExpression) return {
+			...defaults,
+			end: snip(value.elements.length, u32, "constant")
+		};
 	}
 	throw new WgslTypeError("`for ... of ...` loops only support array or vector iterables");
 }
-
 //#endregion
-export { getElementCountSnippet, getElementSnippet, getElementType, getLoopVarKind };
+export { getElementSnippet, getElementType, getLoopVarKind, getRangeSnippets };