typegpu 0.11.1 → 0.11.3

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;
+declare const textureSample: DualFn<typeof sampleCpu>;
 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;
+declare const textureSampleBias: DualFn<typeof sampleBiasCpu>;
 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;
+declare const textureSampleLevel: DualFn<typeof sampleLevelCpu>;
 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;
+declare const textureLoad: DualFn<typeof textureLoadCpu>;
 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;
+declare const textureStore: DualFn<typeof textureStoreCpu>;
 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;
+declare const textureDimensions: DualFn<typeof textureDimensionsCpu>;
 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,21 +87,21 @@ type TextureGatherCpuFn = {
   (...args: GatherDepthCubeArgs): v4f;
   (...args: GatherDepthCubeArrayArgs): v4f;
 };
-declare const textureGather: DualFn;
+declare const textureGather: DualFn<TextureGatherCpuFn>;
 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;
+declare const textureSampleCompare: DualFn<typeof textureSampleCompareCpu>;
 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;
+declare const textureSampleCompareLevel: DualFn<typeof textureSampleCompareLevelCpu>;
 declare function textureSampleBaseClampToEdgeCpu<T extends texture2d | textureExternal>(_texture: T, _sampler: sampler, _coords: v2f): v4f;
 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;
@@ -111,7 +111,7 @@ declare function sampleGradCpu<T extends texture3d>(texture: T, sampler: sampler
 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;
+declare const textureSampleGrad: DualFn<typeof sampleGradCpu>;
+declare const textureSampleBaseClampToEdge: DualFn<typeof textureSampleBaseClampToEdgeCpu>;
 //#endregion
 export { textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore };

package/std/texture.js

@@ -5,6 +5,7 @@ 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");
@@ -123,14 +124,14 @@ const textureGather = dualImpl({
 	codegenImpl: (_ctx, args) => stitch`textureGather(${args})`,
 	signature: (...args) => {
 		if (args[0].type.startsWith("texture")) {
-			const [texture, sampler, coords, _, ...rest] = args;
+			const [texture$1, sampler$1, coords$1, _$1, ...rest$1] = args;
 			return {
-				argTypes: texture.type === "texture_depth_2d_array" || texture.type === "texture_depth_cube_array" ? [
-					texture,
-					sampler,
-					coords,
+				argTypes: texture$1.type === "texture_depth_2d_array" || texture$1.type === "texture_depth_cube_array" ? [
+					texture$1,
+					sampler$1,
+					coords$1,
 					[u32, i32],
-					...rest
+					...rest$1
 				] : args,
 				returnType: vec4f
 			};
@@ -203,5 +204,6 @@ const textureSampleBaseClampToEdge = dualImpl({
 		returnType: vec4f
 	})
 });
+
 //#endregion
-export { textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore };
+export { textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore };

package/tgpu.js

@@ -1,4 +1,4 @@
-import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { __export } from "./_virtual/rolldown_runtime.js";
 import { comptime } from "./core/function/comptime.js";
 import { constant } from "./core/constant/tgpuConstant.js";
 import { fn } from "./core/function/tgpuFn.js";
@@ -15,8 +15,9 @@ 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({
+var tgpu_exports = /* @__PURE__ */ __export({
 	accessor: () => accessor,
 	bindGroupLayout: () => bindGroupLayout,
 	comptime: () => comptime,
@@ -38,5 +39,6 @@ var tgpu_exports = /* @__PURE__ */ __exportAll({
 	workgroupVar: () => workgroupVar,
 	"~unstable": () => tgpuUnstable_exports
 });
+
 //#endregion
-export { tgpu_exports };
+export { tgpu_exports };

package/tgpuBindGroupLayout.d.ts

@@ -17,6 +17,7 @@ import { PropsForSchema, TgpuTexture, TgpuTextureView } from "./core/texture/tex
 import { InferGPU, MemIdentity } from "./shared/repr.js";
 
 //#region src/tgpuBindGroupLayout.d.ts
+
 type TgpuLayoutEntryBase = {
   /**
    * Limits this resource's visibility to specific shader stages.
@@ -33,7 +34,8 @@ type TgpuLayoutUniform = TgpuLayoutEntryBase & {
   uniform: BaseData;
 };
 type TgpuLayoutStorage = TgpuLayoutEntryBase & {
-  storage: BaseData | ((arrayLength: number) => BaseData); /** @default 'readonly' */
+  storage: BaseData | ((arrayLength: number) => BaseData);
+  /** @default 'readonly' */
   access?: 'mutable' | 'readonly';
 };
 type TgpuLayoutSampler = TgpuLayoutEntryBase & {
@@ -42,12 +44,12 @@ type TgpuLayoutSampler = TgpuLayoutEntryBase & {
 type TgpuLayoutComparisonSampler = TgpuLayoutEntryBase & {
   sampler: 'comparison';
 };
-type TgpuLayoutTexture<TSchema extends WgslTexture = WgslTexture> = TgpuLayoutEntryBase & {
-  texture: TSchema;
+type TgpuLayoutTexture<TSchema$1 extends WgslTexture = WgslTexture> = TgpuLayoutEntryBase & {
+  texture: TSchema$1;
   sampleType?: GPUTextureSampleType;
 };
-type TgpuLayoutStorageTexture<TSchema extends WgslStorageTexture = WgslStorageTexture> = TgpuLayoutEntryBase & {
-  storageTexture: TSchema;
+type TgpuLayoutStorageTexture<TSchema$1 extends WgslStorageTexture = WgslStorageTexture> = TgpuLayoutEntryBase & {
+  storageTexture: TSchema$1;
 };
 type TgpuLayoutExternalTexture = TgpuLayoutEntryBase & {
   externalTexture: WgslExternalTexture;
@@ -71,8 +73,10 @@ type TgpuLegacyLayoutTexture<TSampleType extends GPUTextureSampleType = GPUTextu
   multisampled?: boolean;
 };
 type TgpuLegacyLayoutStorageTexture<TFormat extends StorageTextureFormats = StorageTextureFormats> = TgpuLayoutEntryBase & {
-  storageTexture: TFormat; /** @default 'writeonly' */
-  access?: 'readonly' | 'writeonly' | 'mutable'; /** @default '2d' */
+  storageTexture: TFormat;
+  /** @default 'writeonly' */
+  access?: 'readonly' | 'writeonly' | 'mutable';
+  /** @default '2d' */
   viewDimension?: StorageTextureDimension;
 };
 type TgpuLegacyLayoutExternalTexture = TgpuLayoutEntryBase & {

package/tgpuBindGroupLayout.js

@@ -12,6 +12,7 @@ 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
@@ -268,5 +269,6 @@ var TgpuBindGroupImpl = class {
 		});
 	}
 };
+
 //#endregion
-export { TgpuBindGroupImpl, bindGroupLayout, isBindGroup, isBindGroupLayout };
+export { TgpuBindGroupImpl, bindGroupLayout, isBindGroup, isBindGroupLayout };

package/tgpuUnstable.js

@@ -1,4 +1,4 @@
-import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { __export } from "./_virtual/rolldown_runtime.js";
 import { comptime } from "./core/function/comptime.js";
 import { constant } from "./core/constant/tgpuConstant.js";
 import { fn } from "./core/function/tgpuFn.js";
@@ -14,8 +14,9 @@ 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({
+var tgpuUnstable_exports = /* @__PURE__ */ __export({
 	accessor: () => _accessor,
 	comptime: () => _comptime,
 	computeFn: () => _computeFn,
@@ -60,5 +61,6 @@ 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

@@ -1,5 +1,5 @@
 import { isNaturallyEphemeral, isPtr, isVec, isWgslArray, isWgslStruct } from "../data/wgslTypes.js";
-import { MatrixColumnsAccess, UnknownData, isDisarray } from "../data/dataTypes.js";
+import { MatrixColumnsAccess, isDisarray } from "../data/dataTypes.js";
 import { isEphemeralSnippet, snip } from "../data/snippet.js";
 import { isKnownAtComptime } from "../types.js";
 import { stitch } from "../core/resolve/stitch.js";
@@ -7,6 +7,7 @@ import { derefSnippet } from "../data/ref.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,
@@ -36,8 +37,9 @@ function accessIndex(target, indexArg) {
 		return snip(stitch`${target.value.matrix}[${index}]`, propType, target.origin);
 	}
 	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) || target.dataType === UnknownData) return coerceToSnippet(target.value[index.value]);
+	if (isKnownAtComptime(target) && isKnownAtComptime(index)) 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

@@ -1,7 +1,7 @@
 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, snip } from "../data/snippet.js";
+import { isEphemeralSnippet, isSnippet, snip } from "../data/snippet.js";
 import { isKnownAtComptime } from "../types.js";
 import { stitch } from "../core/resolve/stitch.js";
 import { derefSnippet } from "../data/ref.js";
@@ -11,6 +11,7 @@ import { vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, v
 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";
+
 //#region src/tgsl/accessProp.ts
 const infixKinds = [
 	"vec2f",
@@ -91,7 +92,12 @@ 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 (target.dataType instanceof EntryInputRouter) {
+		const result = target.dataType.accessProp(propName);
+		if (isSnippet(result)) return result;
+		if (result) return accessProp(result.target, result.prop);
+		return;
+	}
 	if (isPtr(target.dataType)) {
 		const derefed = derefSnippet(target);
 		if (propName === "$") return derefed;
@@ -111,5 +117,6 @@ 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,6 +5,7 @@ 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);
@@ -111,5 +112,6 @@ function logDataFromGPU(resources) {
 	dataBuffer.buffer.clear();
 	indexBuffer.buffer.clear();
 }
+
 //#endregion
-export { logDataFromGPU };
+export { logDataFromGPU };

package/tgsl/consoleLog/logGenerator.js

@@ -1,16 +1,19 @@
 import { $internal } from "../../shared/symbols.js";
 import { Void } from "../../data/wgslTypes.js";
-import { UnknownData } from "../../data/dataTypes.js";
+import { UnknownData, unptr } from "../../data/dataTypes.js";
 import { snip } from "../../data/snippet.js";
+import { invariant } from "../../errors.js";
 import { stitch } from "../../core/resolve/stitch.js";
+import { convertToCommonType } from "../conversion.js";
 import { u32 } from "../../data/numeric.js";
-import { concretizeSnippets } from "../generationHelpers.js";
+import { concretizeSnippet } 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,
@@ -60,16 +63,21 @@ var LogGeneratorImpl = class {
 			console.warn(`Unsupported log method '${op}'.`);
 			return fallbackSnippet;
 		}
-		const concreteArgs = concretizeSnippets(args);
 		const id = this.#firstUnusedId++;
-		const nonStringArgs = concreteArgs.filter((e) => e.dataType !== UnknownData);
-		const logFn = createLoggingFunction(id, nonStringArgs.map((e) => e.dataType), this.#dataBuffer, this.#indexBuffer, this.#options);
-		const argTypes = concreteArgs.map((e) => e.dataType === UnknownData ? e.value : e.dataType);
+		const concreteArgsWithStrings = args.map((arg) => {
+			if (arg.dataType === UnknownData) return arg;
+			const converted = convertToCommonType(ctx, [arg], [unptr(arg.dataType)])?.[0];
+			invariant(converted, `Internal error. Expected type ${arg.dataType} to be convertible to ${unptr(arg.dataType)}`);
+			return converted;
+		}).map(concretizeSnippet);
+		const concreteArgs = concreteArgsWithStrings.filter((arg) => arg.dataType !== UnknownData);
+		const logFn = createLoggingFunction(id, concreteArgs.map((e) => e.dataType), this.#dataBuffer, this.#indexBuffer, this.#options);
+		const functionSnippet = snip(stitch`${ctx.resolve(logFn).value}(${concreteArgs})`, Void, "runtime");
 		this.#logIdToMeta.set(id, {
 			op,
-			argTypes
+			argTypes: concreteArgsWithStrings.map((e) => e?.dataType === UnknownData ? e?.value : e?.dataType)
 		});
-		return snip(stitch`${ctx.resolve(logFn).value}(${nonStringArgs})`, Void, "runtime");
+		return functionSnippet;
 	}
 	get logResources() {
 		return this.#firstUnusedId === 1 ? void 0 : {
@@ -80,5 +88,6 @@ var LogGeneratorImpl = class {
 		};
 	}
 };
+
 //#endregion
-export { LogGeneratorImpl, LogGeneratorNullImpl };
+export { LogGeneratorImpl, LogGeneratorNullImpl };

package/tgsl/consoleLog/serializers.js

@@ -7,6 +7,7 @@ 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");
@@ -219,5 +220,6 @@ function createLoggingFunction(id, dataTypes, dataBuffer, indexBuffer, logOption
 		compoundSerializer
 	}).$name(`log${id}`);
 }
+
 //#endregion
-export { createLoggingFunction };
+export { createLoggingFunction };

package/tgsl/consoleLog/types.d.ts

@@ -1,7 +1,10 @@
+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
+
 /**
  * Options for configuring GPU log generation.
  */

package/tgsl/consoleLog/types.js

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

package/tgsl/conversion.js

@@ -8,6 +8,7 @@ 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,
@@ -89,14 +90,19 @@ function getImplicitConversionRank(src, dest) {
 			};
 		}
 	}
+	if ((trueSrc.type === "u32" || trueSrc.type === "i32") && trueDst.type === "abstractFloat") return {
+		rank: 1,
+		action: "cast",
+		targetType: trueDst.concretized
+	};
 	if (trueSrc.type === "abstractFloat") {
-		if (trueDst.type === "u32") return {
+		if (trueDst.type === "i32") return {
 			rank: 2,
 			action: "cast",
 			targetType: trueDst
 		};
-		if (trueDst.type === "i32") return {
-			rank: 1,
+		if (trueDst.type === "u32") return {
+			rank: 3,
 			action: "cast",
 			targetType: trueDst
 		};
@@ -112,6 +118,10 @@ function getConversionRank(src, dest, allowImplicit) {
 function findBestType(types, uniqueTypes, allowImplicit) {
 	let bestResult;
 	for (const targetType of uniqueTypes) {
+		/**
+		* The type we end up converting to. Will be different than `targetType` if `targetType === abstractFloat`
+		*/
+		let destType = targetType;
 		const details = [];
 		let sum = 0;
 		for (const sourceType of types) {
@@ -119,9 +129,10 @@ function findBestType(types, uniqueTypes, allowImplicit) {
 			sum += conversion.rank;
 			if (conversion.rank === Number.POSITIVE_INFINITY) break;
 			details.push(conversion);
+			if (conversion.action === "cast") destType = conversion.targetType;
 		}
 		if (sum < (bestResult?.sum ?? Number.POSITIVE_INFINITY)) bestResult = {
-			type: targetType,
+			type: destType,
 			details,
 			sum
 		};
@@ -167,7 +178,7 @@ function convertToCommonType(ctx, values, restrictTo, verbose = true) {
 	if (DEV && Array.isArray(restrictTo) && restrictTo.length === 0) console.warn("convertToCommonType was called with an empty restrictTo array, which prevents any conversions from being made. If you intend to allow all conversions, pass undefined instead. If this was intended call the function conditionally since the result will always be undefined.");
 	const conversion = getBestConversion(types, restrictTo);
 	if (!conversion) return;
-	if ((TEST || DEV) && verbose && conversion.hasImplicitConversions) console.warn(`Implicit conversions from [\n${values.map((v) => `  ${v.value}: ${safeStringify(v.dataType)}`).join(",\n")}\n] to ${conversion.targetType.type} are supported, but not recommended.
+	if ((TEST || DEV) && verbose && conversion.hasImplicitConversions) console.warn(`Implicit conversions from [\n${values.map((v) => `  ${ctx.resolveSnippet(v).value}: ${safeStringify(v.dataType)}`).join(",\n")}\n] to ${conversion.targetType.type} are supported, but not recommended.
 Consider using explicit conversions instead.`);
 	return values.map((value, index) => {
 		const action = conversion.actions[index];
@@ -194,5 +205,6 @@ 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

@@ -10,6 +10,7 @@ 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";
@@ -32,12 +33,20 @@ function getElementType(elementSnippet, iterableSnippet) {
 }
 function getRangeSnippets(ctx, iterableSnippet, unroll = false) {
 	const { value, dataType } = iterableSnippet;
-	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 (isTgpuRange(value)) {
+		const { start, end, step } = value;
+		const dataType$1 = [
+			start,
+			end,
+			step
+		].every((v) => v >= 0) ? u32 : i32;
+		return {
+			start: snip(start, dataType$1, "constant"),
+			end: snip(end, dataType$1, "constant"),
+			step: snip(step, dataType$1, "constant"),
+			comparison: 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.
@@ -67,5 +76,6 @@ You can wrap iterable with \`tgpu.unroll(...)\`. If iterable is known at comptim
 	}
 	throw new WgslTypeError("`for ... of ...` loops only support array or vector iterables");
 }
+
 //#endregion
-export { getElementSnippet, getElementType, getLoopVarKind, getRangeSnippets };
+export { getElementSnippet, getElementType, getLoopVarKind, getRangeSnippets };

package/tgsl/generationHelpers.d.ts

@@ -4,6 +4,7 @@ import { FunctionScopeLayer, ResolutionCtx } from "../types.js";
 import { BaseData } from "../data/wgslTypes.js";
 
 //#region src/tgsl/generationHelpers.d.ts
+
 type GenerationCtx = ResolutionCtx & {
   readonly pre: string;
   /**

package/tgsl/generationHelpers.js

@@ -7,6 +7,7 @@ import { getOwnSnippet } from "../types.js";
 import { stitch } from "../core/resolve/stitch.js";
 import { isRef } from "../data/ref.js";
 import { abstractFloat, abstractInt, bool, f32, i32 } from "../data/numeric.js";
+
 //#region src/tgsl/generationHelpers.ts
 function numericLiteralToSnippet(value) {
 	if (value >= 2 ** 63 || value < -(2 ** 63)) return snip(value, abstractFloat, "constant");
@@ -24,9 +25,6 @@ function concretize(type) {
 function concretizeSnippet(snippet) {
 	return snip(snippet.value, concretize(snippet.dataType), snippet.origin);
 }
-function concretizeSnippets(args) {
-	return args.map(concretizeSnippet);
-}
 function coerceToSnippet(value) {
 	if (isSnippet(value)) return value;
 	if (isRef(value)) throw new Error("Cannot use refs (d.ref(...)) from the outer scope.");
@@ -63,5 +61,6 @@ var ArrayExpression = class {
 		return snip(stitch`${`array<${ctx.resolve(this.type.elementType).value}, ${this.elements.length}>`}(${this.elements})`, this.type, "runtime");
 	}
 };
+
 //#endregion
-export { ArrayExpression, coerceToSnippet, concretize, concretizeSnippets, numericLiteralToSnippet };
+export { ArrayExpression, coerceToSnippet, concretize, concretizeSnippet, numericLiteralToSnippet };

package/tgsl/math.js

@@ -1,5 +1,6 @@
 import { f32 } from "../data/numeric.js";
 import { abs, acos, acosh, asin, asinh, atan, atan2, atanh, ceil, cos, cosh, countLeadingZeros, exp, floor, log, log2, max, min, pow, sign, sin, sinh, sqrt, tan, tanh, trunc } from "../std/numeric.js";
+
 //#region src/tgsl/math.ts
 const mathToStd = {
 	abs,
@@ -39,5 +40,6 @@ const mathToStd = {
 	imul: void 0,
 	round: void 0
 };
+
 //#endregion
-export { mathToStd };
+export { mathToStd };

package/tgsl/shaderGenerator.d.ts

@@ -1,9 +1,10 @@
 import { ResolvedSnippet, Snippet } from "../data/snippet.js";
 import { GenerationCtx } from "./generationHelpers.js";
+import { FunctionDefinitionOptions } from "./shaderGenerator_members.js";
 import { BaseData } from "../data/wgslTypes.js";
-import { Block } from "tinyest";
 
 //#region src/tgsl/shaderGenerator.d.ts
+
 /**
  * **NOTE: This is an unstable API and may change in the future.**
  *
@@ -12,7 +13,7 @@ import { Block } from "tinyest";
  */
 interface ShaderGenerator {
   initGenerator(ctx: GenerationCtx): void;
-  functionDefinition(body: Block): string;
+  functionDefinition(options: FunctionDefinitionOptions): string;
   typeInstantiation(schema: BaseData, args: readonly Snippet[]): ResolvedSnippet;
   typeAnnotation(schema: BaseData): string;
 }

package/tgsl/shaderGenerator_members.d.ts

@@ -1,2 +1,15 @@
-import { ResolutionCtx } from "../types.js";
-import { UnknownData } from "../data/dataTypes.js";
+import { Origin, Snippet } from "../data/snippet.js";
+import { FunctionArgument, ResolutionCtx, TgpuShaderStage } from "../types.js";
+import { BaseData } from "../data/wgslTypes.js";
+import { UnknownData } from "../data/dataTypes.js";
+import { Block } from "tinyest";
+
+//#region src/tgsl/shaderGenerator_members.d.ts
+interface FunctionDefinitionOptions {
+  readonly functionType: 'normal' | TgpuShaderStage;
+  readonly args: readonly FunctionArgument[];
+  readonly body: Block;
+  determineReturnType(): BaseData;
+}
+//#endregion
+export { FunctionDefinitionOptions };

package/tgsl/shaderGenerator_members.js

@@ -1,6 +1,8 @@
-import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { __export } from "../_virtual/rolldown_runtime.js";
 import { UnknownData } from "../data/dataTypes.js";
+
 //#region src/tgsl/shaderGenerator_members.ts
-var shaderGenerator_members_exports = /* @__PURE__ */ __exportAll({ UnknownData: () => UnknownData });
+var shaderGenerator_members_exports = /* @__PURE__ */ __export({ UnknownData: () => UnknownData });
+
 //#endregion
-export { shaderGenerator_members_exports };
+export { shaderGenerator_members_exports };