typegpu 0.11.1 → 0.11.2

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

@@ -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,
@@ -39,5 +40,6 @@ 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

@@ -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",
@@ -111,5 +112,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

@@ -11,6 +11,7 @@ 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,
@@ -80,5 +81,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,
@@ -194,5 +195,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";
@@ -67,5 +68,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");
@@ -63,5 +64,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, concretizeSnippets, 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,11 @@
 import { ResolvedSnippet, Snippet } from "../data/snippet.js";
 import { GenerationCtx } from "./generationHelpers.js";
+import "./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.**
  *

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 };

package/tgsl/shellless.js

@@ -5,6 +5,7 @@ import { WgslTypeError } from "../errors.js";
 import { RefOperator } from "../data/ref.js";
 import { concretize } from "./generationHelpers.js";
 import { createShelllessImpl } from "../core/function/shelllessImpl.js";
+
 //#region src/tgsl/shellless.ts
 function shallowEqualSchemas(a, b) {
 	if (a.type !== b.type) return false;
@@ -42,5 +43,6 @@ var ShelllessRepository = class {
 		return shellless;
 	}
 };
+
 //#endregion
-export { ShelllessRepository };
+export { ShelllessRepository };

package/tgsl/wgslGenerator.js

@@ -27,6 +27,7 @@ import { mathToStd } from "./math.js";
 import { isTgpuRange } from "../std/range.js";
 import { getElementSnippet, getElementType, getLoopVarKind, getRangeSnippets } from "./forOfUtils.js";
 import * as tinyest from "tinyest";
+
 //#region src/tgsl/wgslGenerator.ts
 const { NodeTypeCatalog: NODE } = tinyest;
 const parenthesizedOps = [
@@ -215,12 +216,12 @@ ${this.ctx.pre}}`;
 			const lhsExpr = this._expression(lhs);
 			if ((op === "||" || op === "&&") && isKnownAtComptime(lhsExpr)) {
 				if (!(op === "&&" ? lhsExpr.value : !lhsExpr.value)) return snip(op === "||", bool, "constant");
-				const rhsExpr = this._expression(rhs);
-				if (rhsExpr.dataType === UnknownData) throw new WgslTypeError(`Right-hand side of '${op}' is of unknown type`);
-				if (isKnownAtComptime(rhsExpr)) return snip(!!rhsExpr.value, bool, "constant");
-				const convRhs = tryConvertSnippet(this.ctx, rhsExpr, bool, false);
-				const rhsStr = this.ctx.resolve(convRhs.value, convRhs.dataType).value;
-				return snip(rhsStr, bool, "runtime");
+				const rhsExpr$1 = this._expression(rhs);
+				if (rhsExpr$1.dataType === UnknownData) throw new WgslTypeError(`Right-hand side of '${op}' is of unknown type`);
+				if (isKnownAtComptime(rhsExpr$1)) return snip(!!rhsExpr$1.value, bool, "constant");
+				const convRhs$1 = tryConvertSnippet(this.ctx, rhsExpr$1, bool, false);
+				const rhsStr$1 = this.ctx.resolve(convRhs$1.value, convRhs$1.dataType).value;
+				return snip(rhsStr$1, bool, "runtime");
 			}
 			const rhsExpr = this._expression(rhs);
 			if (rhsExpr.value instanceof RefOperator) throw new WgslTypeError(stitch`Cannot assign a ref to an existing variable '${lhsExpr}', define a new variable instead.`);
@@ -439,8 +440,8 @@ ${this.ctx.pre}}`;
 	_statement(statement) {
 		if (typeof statement === "string") {
 			const id = this._identifier(statement);
-			const resolved = id.value && this.ctx.resolve(id.value).value;
-			return resolved ? `${this.ctx.pre}${resolved};` : "";
+			const resolved$1 = id.value && this.ctx.resolve(id.value).value;
+			return resolved$1 ? `${this.ctx.pre}${resolved$1};` : "";
 		}
 		if (typeof statement === "boolean") return `${this.ctx.pre}${statement ? "true" : "false"};`;
 		if (statement[0] === NODE.return) {
@@ -500,12 +501,12 @@ ${this.ctx.pre}else ${alternate}`;
 			}
 			if (!ephemeral) {
 				if (stmtType === NODE.let) {
-					const rhsStr = this.ctx.resolve(eq.value).value;
+					const rhsStr$1 = this.ctx.resolve(eq.value).value;
 					const rhsTypeStr = this.ctx.resolve(unptr(eq.dataType)).value;
-					throw new WgslTypeError(`'let ${rawId} = ${rhsStr}' is invalid, because references cannot be assigned to 'let' variable declarations.
+					throw new WgslTypeError(`'let ${rawId} = ${rhsStr$1}' is invalid, because references cannot be assigned to 'let' variable declarations.
 -----
-- Try 'let ${rawId} = ${rhsTypeStr}(${rhsStr})' if you need to reassign '${rawId}' later
-- Try 'const ${rawId} = ${rhsStr}' if you won't reassign '${rawId}' later.
+- Try 'let ${rawId} = ${rhsTypeStr}(${rhsStr$1})' if you need to reassign '${rawId}' later
+- Try 'const ${rawId} = ${rhsStr$1}' if you won't reassign '${rawId}' later.
 -----`);
 				}
 				if (eq.origin === "constant-tgpu-const-ref") varType = "const";
@@ -524,12 +525,12 @@ ${this.ctx.pre}else ${alternate}`;
 				else if (naturallyEphemeral) varType = eq.origin === "constant" ? "const" : "let";
 			} else if (eq.origin === "argument") {
 				if (!naturallyEphemeral) {
-					const rhsStr = this.ctx.resolve(eq.value).value;
+					const rhsStr$1 = this.ctx.resolve(eq.value).value;
 					const rhsTypeStr = this.ctx.resolve(unptr(eq.dataType)).value;
-					throw new WgslTypeError(`'let ${rawId} = ${rhsStr}' is invalid, because references to arguments cannot be assigned to 'let' variable declarations.
+					throw new WgslTypeError(`'let ${rawId} = ${rhsStr$1}' is invalid, because references to arguments cannot be assigned to 'let' variable declarations.
   -----
-  - Try 'let ${rawId} = ${rhsTypeStr}(${rhsStr})' if you need to reassign '${rawId}' later
-  - Try 'const ${rawId} = ${rhsStr}' if you won't reassign '${rawId}' later.
+  - Try 'let ${rawId} = ${rhsTypeStr}(${rhsStr$1})' if you need to reassign '${rawId}' later
+  - Try 'const ${rawId} = ${rhsStr$1}' if you won't reassign '${rawId}' later.
   -----`);
 				}
 			}
@@ -591,7 +592,7 @@ ${this.ctx.pre}else ${alternate}`;
 					const length = range.end.value;
 					if (length === 0) return "";
 					const { value } = iterableSnippet;
-					const elements = isTgpuRange(value) ? value.map((i) => coerceToSnippet(i)) : value instanceof ArrayExpression ? value.elements : Array.from({ length }, (_, i) => getElementSnippet(iterableSnippet, snip(i, u32, "constant")));
+					const elements = isTgpuRange(value) ? value.map((i) => coerceToSnippet(i)) : value instanceof ArrayExpression ? value.elements : Array.from({ length }, (_$1, i) => getElementSnippet(iterableSnippet, snip(i, u32, "constant")));
 					if (isEphemeralSnippet(elements[0]) && !isNaturallyEphemeral(elements[0]?.dataType)) throw new WgslTypeError("Cannot unroll loop. The elements of iterable are emphemeral but not naturally ephemeral.");
 					return elements.map((e, i) => `${this.ctx.pre}// unrolled iteration #${i}\n${this.ctx.pre}${this._block(blockified, { [originalLoopVarName]: e })}`).join("\n");
 				}
@@ -644,5 +645,7 @@ function blockifySingleStatement(statement) {
 	return typeof statement !== "object" || statement[0] !== NODE.block ? [NODE.block, [statement]] : statement;
 }
 const wgslGenerator = new WgslGenerator();
+var wgslGenerator_default = wgslGenerator;
+
 //#endregion
-export { WgslGenerator, wgslGenerator as default };
+export { WgslGenerator, wgslGenerator_default as default };

package/types.d.ts

@@ -86,7 +86,6 @@ interface ItemStateStack {
    * The return type of the function. If undefined, the type should be inferred
    * from the implementation (relevant for shellless functions).
    */
-
   returnType: BaseData | undefined, externalMap: Record<string, unknown>): FunctionScopeLayer;
   pushBlockScope(): void;
   setBlockExternals(externals: Record<string, Snippet>): void;

package/types.js

@@ -2,6 +2,7 @@ import { $cast, $gpuCallable, $ownSnippet, $resolve } from "./shared/symbols.js"
 import { isWgslData } from "./data/wgslTypes.js";
 import { UnknownData } from "./data/dataTypes.js";
 import { isLazy, isProviding, isSlot } from "./core/slot/slotTypes.js";
+
 //#region src/types.ts
 var NormalState = class {
 	type = "normal";
@@ -39,5 +40,6 @@ function isWgsl(value) {
 function isGPUBuffer(value) {
 	return !!value && typeof value === "object" && "getMappedRange" in value && "mapAsync" in value;
 }
+
 //#endregion
-export { CodegenState, NormalState, SimulationState, getOwnSnippet, hasCast, isGPUBuffer, isGPUCallable, isKnownAtComptime, isSelfResolvable, isWgsl };
+export { CodegenState, NormalState, SimulationState, getOwnSnippet, hasCast, isGPUBuffer, isGPUCallable, isKnownAtComptime, isSelfResolvable, isWgsl };

package/wgslExtensions.js

@@ -13,5 +13,6 @@ const wgslExtensionToFeatureName = {
 	subgroups: "subgroups",
 	primitive_index: "primitive-index"
 };
+
 //#endregion
-export { wgslExtensionToFeatureName, wgslExtensions };
+export { wgslExtensionToFeatureName, wgslExtensions };