typegpu 0.11.5 → 0.11.7

package/data/index.js

@@ -12,7 +12,7 @@ import { PUBLIC_sizeOf } from "./sizeOf.js";
 import { align, interpolate, invariant, isBuiltin, location, size } from "./attributes.js";
 import { struct } from "./struct.js";
 import { MatBase, mat2x2f, mat3x3f, mat4x4f, matToArray } from "./matrix.js";
-import { infixOperators } from "../tgsl/accessProp.js";
+import { assignInfixOperator } from "../tgsl/infixDispatch.js";
 import { comparisonSampler, sampler } from "./sampler.js";
 import { texture1d, texture2d, texture2dArray, texture3d, textureCube, textureCubeArray, textureDepth2d, textureDepth2dArray, textureDepthCube, textureDepthCubeArray, textureDepthMultisampled2d, textureExternal, textureMultisampled2d, textureStorage1d, textureStorage2d, textureStorage2dArray, textureStorage3d } from "./texture.js";
 import { arrayOf } from "./array.js";
@@ -159,33 +159,16 @@ var data_exports = /* @__PURE__ */ __export({
 	vec4i: () => vec4i,
 	vec4u: () => vec4u
 });
-function assignInfixOperator(object, operator, operatorSymbol) {
-	const proto = object.prototype;
-	const opImpl = infixOperators[operator];
-	proto[operator] = function(other) {
-		return opImpl(this, other);
-	};
-	proto[operatorSymbol] = (lhs, rhs) => {
-		return opImpl(lhs, rhs);
-	};
-}
 assignInfixOperator(VecBase, "add", Operator.plus);
+assignInfixOperator(MatBase, "add", Operator.plus);
 assignInfixOperator(VecBase, "sub", Operator.minus);
+assignInfixOperator(MatBase, "sub", Operator.minus);
 assignInfixOperator(VecBase, "mul", Operator.star);
+assignInfixOperator(MatBase, "mul", Operator.star);
 assignInfixOperator(VecBase, "div", Operator.slash);
 assignInfixOperator(VecBase, "mod", Operator.percent);
-assignInfixOperator(MatBase, "add", Operator.plus);
-assignInfixOperator(MatBase, "sub", Operator.minus);
-assignInfixOperator(MatBase, "mul", Operator.star);
-{
-	const proto = VecBase.prototype;
-	proto.bitShiftLeft = function(other) {
-		return infixOperators.bitShiftLeft(this, other);
-	};
-	proto.bitShiftRight = function(other) {
-		return infixOperators.bitShiftRight(this, other);
-	};
-}
+assignInfixOperator(VecBase, "bitShiftLeft", Symbol());
+assignInfixOperator(VecBase, "bitShiftRight", Symbol());
 
 //#endregion
 export { Void, align, PUBLIC_alignmentOf as alignmentOf, arrayOf, atomic, bool, builtin, comparisonSampler, data_exports, deepEqual, disarrayOf, f16, f32, float16, float16x2, float16x4, float32, float32x2, float32x3, float32x4, formatToWGSLType, PUBLIC_getLongestContiguousPrefix as getLongestContiguousPrefix, i32, interpolate, invariant, isAlignAttrib, isAtomic, isBuiltin, isBuiltinAttrib, PUBLIC_isContiguous as isContiguous, isData, isDecorated, isDisarray, isInterpolateAttrib, isLocationAttrib, isLooseData, isLooseDecorated, isPackedData, isPtr, isSizeAttrib, isUnstruct, isWgslArray, isWgslData, isWgslStruct, location, mat2x2f, mat3x3f, mat4x4f, matToArray, memoryLayoutOf, packedFormats, ptrFn, ptrHandle, ptrPrivate, ptrStorage, ptrUniform, ptrWorkgroup, _ref as ref, sampler, sint16, sint16x2, sint16x4, sint32, sint32x2, sint32x3, sint32x4, sint8, sint8x2, sint8x4, size, PUBLIC_sizeOf as sizeOf, snorm16, snorm16x2, snorm16x4, snorm8, snorm8x2, snorm8x4, struct, texture1d, texture2d, texture2dArray, texture3d, textureCube, textureCubeArray, textureDepth2d, textureDepth2dArray, textureDepthCube, textureDepthCubeArray, textureDepthMultisampled2d, textureExternal, textureMultisampled2d, textureStorage1d, textureStorage2d, textureStorage2dArray, textureStorage3d, u16, u32, uint16, uint16x2, uint16x4, uint32, uint32x2, uint32x3, uint32x4, uint8, uint8x2, uint8x4, unorm10_10_10_2, unorm16, unorm16x2, unorm16x4, unorm8, unorm8x2, unorm8x4, unorm8x4_bgra, unstruct, vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u };

package/data/ref.js

@@ -1,8 +1,8 @@
 import { $gpuCallable, $internal, $ownSnippet, $resolve } from "../shared/symbols.js";
-import { setName } from "../shared/meta.js";
 import { isNaturallyEphemeral, isPtr } from "./wgslTypes.js";
+import { setName } from "../shared/meta.js";
 import { UnknownData } from "./dataTypes.js";
-import { snip } from "./snippet.js";
+import { isAlias, snip } from "./snippet.js";
 import { WgslTypeError } from "../errors.js";
 import { stitch } from "../core/resolve/stitch.js";
 import { createPtrFromOrigin, explicitFrom } from "./ptr.js";
@@ -13,8 +13,22 @@ const _ref = (() => {
 	setName(impl, "ref");
 	impl.toString = () => "ref";
 	impl[$internal] = true;
-	impl[$gpuCallable] = { call(_ctx, [value]) {
-		if (value.origin === "argument") throw new WgslTypeError(stitch`d.ref(${value}) is illegal, cannot take a reference of an argument. Copy the value locally first, and take a reference of the copy.`);
+	impl[$gpuCallable] = { call(ctx, [value]) {
+		if (value.origin === "argument") throw new WgslTypeError(stitch`d.ref(${value}) is illegal, cannot take a reference of an argument. Copy the value first, and take a reference of the copy.`);
+		if (value.origin === "constant-immutable-def" || value.origin === "runtime-immutable-def") {
+			const typeStr = ctx.resolve(value.dataType).value;
+			throw new WgslTypeError(stitch`d.ref(${value}) is illegal, cannot take a reference to a constant.
+-----
+- Try 'd.ref(${typeStr}(${value}));' instead to create a new referencable value.
+-----`);
+		}
+		if (isAlias(value) && isNaturallyEphemeral(value.dataType)) {
+			const typeStr = ctx.resolve(value.dataType).value;
+			throw new WgslTypeError(stitch`d.ref(${value}) is illegal, cannot take a reference to a scalar value.
+-----
+- Try 'd.ref(${typeStr}(${value}));' instead to create a new referencable scalar.
+-----`);
+		}
 		if (isPtr(value.dataType)) return snip(value.value, explicitFrom(value.dataType), value.origin);
 		/**
 		* Pointer type only exists if the ref was created from a reference (buttery-butter).
@@ -87,9 +101,8 @@ var RefOperator = class {
 function derefSnippet(snippet) {
 	if (!isPtr(snippet.dataType)) return snippet;
 	const innerType = snippet.dataType.inner;
-	const origin = isNaturallyEphemeral(innerType) ? "runtime" : snippet.origin;
-	if (snippet.value instanceof RefOperator) return snip(stitch`${snippet.value.snippet}`, innerType, origin);
-	return snip(stitch`(*${snippet})`, innerType, origin);
+	if (snippet.value instanceof RefOperator) return snip(stitch`${snippet.value.snippet}`, innerType, snippet.origin);
+	return snip(stitch`(*${snippet})`, innerType, snippet.origin);
 }
 
 //#endregion

package/data/snippet.d.ts

@@ -2,7 +2,7 @@ import { BaseData } from "./wgslTypes.js";
 import { UnknownData } from "./dataTypes.js";
 
 //#region src/data/snippet.d.ts
-type Origin = 'uniform' | 'readonly' | 'mutable' | 'workgroup' | 'private' | 'function' | 'this-function' | 'handle' | 'argument' | 'runtime' | 'constant' | 'constant-tgpu-const-ref' | 'runtime-tgpu-const-ref';
+type Origin = 'uniform' | 'readonly' | 'mutable' | 'workgroup' | 'private' | 'handle' | 'function' | 'local-def' | 'constant-immutable-def' | 'runtime-immutable-def' | 'argument' | 'runtime' | 'constant';
 interface Snippet {
   readonly value: unknown;
   /**
@@ -11,6 +11,7 @@ interface Snippet {
    */
   readonly dataType: BaseData | UnknownData;
   readonly origin: Origin;
+  readonly possibleSideEffects: boolean;
 }
 interface ResolvedSnippet extends Snippet {
   readonly value: string;

package/data/snippet.js

@@ -3,9 +3,6 @@ import { isNumericSchema } from "./wgslTypes.js";
 import { undecorate } from "./dataTypes.js";
 
 //#region src/data/snippet.ts
-function isEphemeralOrigin(space) {
-	return space === "runtime" || space === "constant" || space === "argument";
-}
 /**
 * What happens to a snippet's origin when it's deep copied in JS, and left as is in WGSL?
 * e.g. `vec3f(vec3f(0, 1, 2))`
@@ -14,8 +11,27 @@ function fallthroughCopyOrigin(origin) {
 	if (origin === "runtime" || origin === "constant") return origin;
 	return "runtime";
 }
-function isEphemeralSnippet(snippet) {
-	return isEphemeralOrigin(snippet.origin);
+/**
+* Whether a snippet aliases a value that lives outside the current expression.
+*
+* @example
+* ```ts
+* function foo(a: number) {
+*   const color = d.vec3f(1, 2, 3);
+*   return color * a;
+* }
+*
+* // References:
+* // -  color
+* // -  a
+* //
+* // Not references:
+* // - d.vec3f(1, 2, 3)
+* // - color * a
+* ```
+*/
+function isAlias(snippet) {
+	return !(snippet.origin === "runtime" || snippet.origin === "constant");
 }
 const originToPtrParams = {
 	uniform: {
@@ -42,7 +58,7 @@ const originToPtrParams = {
 		space: "function",
 		access: "read-write"
 	},
-	"this-function": {
+	"local-def": {
 		space: "function",
 		access: "read-write"
 	}
@@ -51,10 +67,12 @@ var SnippetImpl = class {
 	value;
 	dataType;
 	origin;
-	constructor(value, dataType, origin) {
+	possibleSideEffects;
+	constructor(value, dataType, origin, possibleSideEffects) {
 		this.value = value;
 		this.dataType = dataType;
 		this.origin = origin;
+		this.possibleSideEffects = possibleSideEffects;
 	}
 };
 function isSnippet(value) {
@@ -63,10 +81,19 @@ function isSnippet(value) {
 function isSnippetNumeric(snippet) {
 	return isNumericSchema(snippet.dataType);
 }
-function snip(value, dataType, origin) {
+function snip(value, dataType, origin, possibleSideEffects = true) {
 	if (DEV && isSnippet(value)) throw new Error("Cannot nest snippets");
-	return new SnippetImpl(value, undecorate(dataType), origin);
+	return new SnippetImpl(value, undecorate(dataType), origin, possibleSideEffects);
+}
+function withDataType(dataType, snippet) {
+	return new SnippetImpl(snippet.value, dataType, snippet.origin, snippet.possibleSideEffects);
+}
+function withSideEffects(possibleSideEffects, snippet) {
+	return new SnippetImpl(snippet.value, snippet.dataType, snippet.origin, possibleSideEffects);
+}
+function noSideEffects(snippet) {
+	return withSideEffects(false, snippet);
 }
 
 //#endregion
-export { fallthroughCopyOrigin, isEphemeralOrigin, isEphemeralSnippet, isSnippet, isSnippetNumeric, originToPtrParams, snip };
+export { fallthroughCopyOrigin, isAlias, isSnippet, isSnippetNumeric, noSideEffects, originToPtrParams, snip, withDataType };

package/errors.d.ts

@@ -32,9 +32,6 @@ declare class MissingSlotValueError extends Error {
 declare class NotUniformError extends Error {
   constructor(value: TgpuBuffer<BaseData>);
 }
-declare class MissingLinksError extends Error {
-  constructor(fnLabel: string | undefined, externalNames: string[]);
-}
 declare class MissingBindGroupsError extends Error {
   constructor(layouts: Iterable<TgpuBindGroupLayout>);
 }
@@ -42,4 +39,4 @@ declare class MissingVertexBuffersError extends Error {
   constructor(layouts: Iterable<TgpuVertexLayout>);
 }
 //#endregion
-export { MissingBindGroupsError, MissingLinksError, MissingSlotValueError, MissingVertexBuffersError, NotUniformError, ResolutionError };
+export { MissingBindGroupsError, MissingSlotValueError, MissingVertexBuffersError, NotUniformError, ResolutionError };

package/errors.js

@@ -86,12 +86,6 @@ var NotUniformError = class NotUniformError extends Error {
 		Object.setPrototypeOf(this, NotUniformError.prototype);
 	}
 };
-var MissingLinksError = class MissingLinksError extends Error {
-	constructor(fnLabel, externalNames) {
-		super(`The function '${fnLabel ?? "<unnamed>"}' is missing links to the following external values: ${externalNames}.`);
-		Object.setPrototypeOf(this, MissingLinksError.prototype);
-	}
-};
 var MissingBindGroupsError = class MissingBindGroupsError extends Error {
 	constructor(layouts) {
 		super(`Missing bind groups for layouts: '${[...layouts].map((layout) => getName(layout) ?? "<unnamed>").join(", ")}'. Please provide it using pipeline.with(bindGroup).(...)`);
@@ -130,4 +124,4 @@ var SignatureNotSupportedError = class SignatureNotSupportedError extends Error
 };
 
 //#endregion
-export { ExecutionError, IllegalBufferAccessError, IllegalVarAccessError, MissingBindGroupsError, MissingLinksError, MissingSlotValueError, MissingVertexBuffersError, NotUniformError, ResolutionError, SignatureNotSupportedError, WgslTypeError, invariant };
+export { ExecutionError, IllegalBufferAccessError, IllegalVarAccessError, MissingBindGroupsError, MissingSlotValueError, MissingVertexBuffersError, NotUniformError, ResolutionError, SignatureNotSupportedError, WgslTypeError, invariant };

package/index.d.ts

@@ -7,7 +7,7 @@ import { TgpuComputeFn, TgpuComputeFnShell, computeFn, isTgpuComputeFn } from ".
 import { TgpuVar, VariableScope, isVariable, privateVar, workgroupVar } from "./core/variable/tgpuVariable.js";
 import { Eventual, TgpuAccessor, TgpuLazy, TgpuMutableAccessor, TgpuSlot, isAccessor, isLazy, isMutableAccessor, isSlot } from "./core/slot/slotTypes.js";
 import { TgpuComputePipeline } from "./core/pipeline/computePipeline.js";
-import { AutoFragmentIn, AutoFragmentOut, AutoVertexOut, _AutoVertexIn } from "./core/function/autoIO.js";
+import { AnyAutoCustoms, AutoFragmentIn, AutoFragmentOut, AutoVertexOut, _AutoVertexIn } from "./core/function/autoIO.js";
 import { TgpuFragmentFn, TgpuFragmentFnShell, fragmentFn, isTgpuFragmentFn } from "./core/function/tgpuFragmentFn.js";
 import { TgpuVertexFn, TgpuVertexFnShell, isTgpuVertexFn, vertexFn } from "./core/function/tgpuVertexFn.js";
 import { TextureProps } from "./core/texture/textureProps.js";
@@ -36,7 +36,7 @@ import { tgpuUnstable_d_exports } from "./tgpuUnstable.js";
 import { index_d_exports as index_d_exports$1 } from "./data/index.js";
 import { index_d_exports as index_d_exports$2 } from "./std/index.js";
 import { index_d_exports } from "./common/index.js";
-import { MissingBindGroupsError, MissingLinksError, MissingSlotValueError, MissingVertexBuffersError, NotUniformError, ResolutionError } from "./errors.js";
+import { MissingBindGroupsError, MissingSlotValueError, MissingVertexBuffersError, NotUniformError, ResolutionError } from "./errors.js";
 import { WgslGenerator } from "./tgsl/wgslGenerator.js";
 import { readFromArrayBuffer, writeToArrayBuffer } from "./data/dataIO.js";
 import { patchArrayBuffer } from "./data/partialIO.js";
@@ -70,4 +70,4 @@ declare const tgpu: {
   '~unstable': typeof tgpuUnstable_d_exports;
 };
 //#endregion
-export { AutoFragmentIn, AutoFragmentOut, _AutoVertexIn as AutoVertexIn, AutoVertexOut, BindLayoutEntry, ColorAttachment, Configurable, Eventual, ExtractBindGroupInputFromLayout, INTERNAL_GlobalExt, IndexFlag, InitFromDeviceOptions, InitOptions, LayoutEntryToInput, MissingBindGroupsError, MissingLinksError, MissingSlotValueError, MissingVertexBuffersError, Namespace, NotUniformError, RawCodeSnippetOrigin, RenderFlag, ResolutionError, SampledFlag, ShaderGenerator, Storage, StorageFlag, TextureProps, TgpuAccessor, TgpuBindGroup, TgpuBindGroupLayout, TgpuBuffer, TgpuBufferMutable, TgpuBufferReadonly, TgpuBufferUniform, TgpuComparisonSampler, TgpuComptime, TgpuComputeFn, TgpuComputeFnShell, TgpuComputePipeline, TgpuConst, TgpuDeclare, TgpuFixedComparisonSampler, TgpuFixedSampler, TgpuFn, TgpuFnShell, TgpuFragmentFn, TgpuFragmentFnShell, TgpuGenericFn, TgpuGuardedComputePipeline, TgpuLayoutComparisonSampler, TgpuLayoutEntry, TgpuLayoutExternalTexture, TgpuLayoutSampler, TgpuLayoutStorage, TgpuLayoutTexture, TgpuLayoutUniform, TgpuLazy, TgpuMutable, TgpuMutableAccessor, TgpuPrimitiveState, TgpuQuerySet, TgpuRawCodeSnippet, TgpuReadonly, TgpuRenderPipeline, TgpuRenderPipelineDescriptor, TgpuRoot, TgpuSampler, TgpuSlot, TgpuTexture, TgpuTextureView, TgpuUniform, TgpuVar, TgpuVertexFn, TgpuVertexFnShell, TgpuVertexLayout, Uniform, UniformFlag, ValidUsagesFor, ValidateBufferSchema, ValidateStorageSchema, ValidateUniformSchema, VariableScope, Vertex, VertexFlag, WgslGenerator, WithBinding, WithCompute, WithFragment, WithVertex, Withable, index_d_exports as common, index_d_exports$1 as d, tgpu as default, tgpu, isAccessor, isBuffer, isBufferShorthand, isComparisonSampler, isLazy, isMutableAccessor, isSampler, isSlot, isTexture, isTgpuComputeFn, isTgpuFn, isTgpuFragmentFn, isTgpuVertexFn, isUsableAsRender, isUsableAsSampled, isUsableAsStorage, isUsableAsUniform, isUsableAsVertex, isVariable, patchArrayBuffer, readFromArrayBuffer, index_d_exports$2 as std, writeToArrayBuffer };
+export { AnyAutoCustoms, AutoFragmentIn, AutoFragmentOut, _AutoVertexIn as AutoVertexIn, AutoVertexOut, BindLayoutEntry, ColorAttachment, Configurable, Eventual, ExtractBindGroupInputFromLayout, INTERNAL_GlobalExt, IndexFlag, InitFromDeviceOptions, InitOptions, LayoutEntryToInput, MissingBindGroupsError, MissingSlotValueError, MissingVertexBuffersError, Namespace, NotUniformError, RawCodeSnippetOrigin, RenderFlag, ResolutionError, SampledFlag, ShaderGenerator, Storage, StorageFlag, TextureProps, TgpuAccessor, TgpuBindGroup, TgpuBindGroupLayout, TgpuBuffer, TgpuBufferMutable, TgpuBufferReadonly, TgpuBufferUniform, TgpuComparisonSampler, TgpuComptime, TgpuComputeFn, TgpuComputeFnShell, TgpuComputePipeline, TgpuConst, TgpuDeclare, TgpuFixedComparisonSampler, TgpuFixedSampler, TgpuFn, TgpuFnShell, TgpuFragmentFn, TgpuFragmentFnShell, TgpuGenericFn, TgpuGuardedComputePipeline, TgpuLayoutComparisonSampler, TgpuLayoutEntry, TgpuLayoutExternalTexture, TgpuLayoutSampler, TgpuLayoutStorage, TgpuLayoutTexture, TgpuLayoutUniform, TgpuLazy, TgpuMutable, TgpuMutableAccessor, TgpuPrimitiveState, TgpuQuerySet, TgpuRawCodeSnippet, TgpuReadonly, TgpuRenderPipeline, TgpuRenderPipelineDescriptor, TgpuRoot, TgpuSampler, TgpuSlot, TgpuTexture, TgpuTextureView, TgpuUniform, TgpuVar, TgpuVertexFn, TgpuVertexFnShell, TgpuVertexLayout, Uniform, UniformFlag, ValidUsagesFor, ValidateBufferSchema, ValidateStorageSchema, ValidateUniformSchema, VariableScope, Vertex, VertexFlag, WgslGenerator, WithBinding, WithCompute, WithFragment, WithVertex, Withable, index_d_exports as common, index_d_exports$1 as d, tgpu as default, tgpu, isAccessor, isBuffer, isBufferShorthand, isComparisonSampler, isLazy, isMutableAccessor, isSampler, isSlot, isTexture, isTgpuComputeFn, isTgpuFn, isTgpuFragmentFn, isTgpuVertexFn, isUsableAsRender, isUsableAsSampled, isUsableAsStorage, isUsableAsUniform, isUsableAsVertex, isVariable, patchArrayBuffer, readFromArrayBuffer, index_d_exports$2 as std, writeToArrayBuffer };

package/index.js

@@ -1,4 +1,4 @@
-import { MissingBindGroupsError, MissingLinksError, MissingSlotValueError, MissingVertexBuffersError, NotUniformError, ResolutionError } from "./errors.js";
+import { MissingBindGroupsError, MissingSlotValueError, MissingVertexBuffersError, NotUniformError, ResolutionError } from "./errors.js";
 import { isAccessor, isLazy, isMutableAccessor, isSlot } from "./core/slot/slotTypes.js";
 import { shaderGenerator_members_exports } from "./tgsl/shaderGenerator_members.js";
 import { isTgpuFn } from "./core/function/tgpuFn.js";
@@ -25,4 +25,4 @@ import { common_exports } from "./common/index.js";
 var src_default = tgpu_exports;
 
 //#endregion
-export { MissingBindGroupsError, MissingLinksError, MissingSlotValueError, MissingVertexBuffersError, NotUniformError, ResolutionError, shaderGenerator_members_exports as ShaderGenerator, WgslGenerator, common_exports as common, data_exports as d, src_default as default, isAccessor, isBuffer, isBufferShorthand, isComparisonSampler, isLazy, isMutableAccessor, isSampler, isSlot, isTexture, isTgpuComputeFn, isTgpuFn, isTgpuFragmentFn, isTgpuVertexFn, isUsableAsRender, isUsableAsSampled, isUsableAsStorage, isUsableAsUniform, isUsableAsVertex, isVariable, patchArrayBuffer, readFromArrayBuffer, std_exports as std, tgpu_exports as tgpu, writeToArrayBuffer };
+export { MissingBindGroupsError, MissingSlotValueError, MissingVertexBuffersError, NotUniformError, ResolutionError, shaderGenerator_members_exports as ShaderGenerator, WgslGenerator, common_exports as common, data_exports as d, src_default as default, isAccessor, isBuffer, isBufferShorthand, isComparisonSampler, isLazy, isMutableAccessor, isSampler, isSlot, isTexture, isTgpuComputeFn, isTgpuFn, isTgpuFragmentFn, isTgpuVertexFn, isUsableAsRender, isUsableAsSampled, isUsableAsStorage, isUsableAsUniform, isUsableAsVertex, isVariable, patchArrayBuffer, readFromArrayBuffer, std_exports as std, tgpu_exports as tgpu, writeToArrayBuffer };

package/indexNamedExports.d.ts

@@ -7,7 +7,7 @@ import { TgpuComputeFn, TgpuComputeFnShell, isTgpuComputeFn } from "./core/funct
 import { TgpuVar, VariableScope, isVariable } from "./core/variable/tgpuVariable.js";
 import { Eventual, TgpuAccessor, TgpuLazy, TgpuMutableAccessor, TgpuSlot, isAccessor, isLazy, isMutableAccessor, isSlot } from "./core/slot/slotTypes.js";
 import { TgpuComputePipeline } from "./core/pipeline/computePipeline.js";
-import { AutoFragmentIn, AutoFragmentOut, AutoVertexOut, _AutoVertexIn } from "./core/function/autoIO.js";
+import { AnyAutoCustoms, AutoFragmentIn, AutoFragmentOut, AutoVertexOut, _AutoVertexIn } from "./core/function/autoIO.js";
 import { TgpuFragmentFn, TgpuFragmentFnShell, isTgpuFragmentFn } from "./core/function/tgpuFragmentFn.js";
 import { TgpuVertexFn, TgpuVertexFnShell, isTgpuVertexFn } from "./core/function/tgpuVertexFn.js";
 import { TextureProps } from "./core/texture/textureProps.js";
@@ -30,7 +30,7 @@ import { RawCodeSnippetOrigin, TgpuRawCodeSnippet } from "./core/rawCodeSnippet/
 import { index_d_exports } from "./data/index.js";
 import { index_d_exports as index_d_exports$1 } from "./std/index.js";
 import { index_d_exports as index_d_exports$2 } from "./common/index.js";
-import { MissingBindGroupsError, MissingLinksError, MissingSlotValueError, MissingVertexBuffersError, NotUniformError, ResolutionError } from "./errors.js";
+import { MissingBindGroupsError, MissingSlotValueError, MissingVertexBuffersError, NotUniformError, ResolutionError } from "./errors.js";
 import { WgslGenerator } from "./tgsl/wgslGenerator.js";
 import { readFromArrayBuffer, writeToArrayBuffer } from "./data/dataIO.js";
 import { patchArrayBuffer } from "./data/partialIO.js";

package/package.js

@@ -1,5 +1,5 @@
 //#region package.json
-var version = "0.11.5";
+var version = "0.11.7";
 
 //#endregion
 export { version };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typegpu",
-  "version": "0.11.5",
+  "version": "0.11.7",
   "description": "A thin layer between JS and WebGPU/WGSL that improves development experience and allows for faster iteration.",
   "keywords": [
     "compute",
@@ -22,6 +22,7 @@
     "url": "git+https://github.com/software-mansion/TypeGPU.git",
     "directory": "packages/typegpu"
   },
+  "bin": "./bin.mjs",
   "type": "module",
   "sideEffects": false,
   "exports": {
@@ -44,9 +45,9 @@
     }
   },
   "dependencies": {
-    "tinyest": "~0.3.1",
-    "tsover-runtime": "^0.0.6",
-    "typed-binary": "^4.3.3"
+    "tsover-runtime": "^0.0.7",
+    "typed-binary": "^4.3.3",
+    "tinyest": "~0.3.2"
   },
   "engines": {
     "node": ">=12.20.0"

package/resolutionCtx.js

@@ -1,14 +1,13 @@
 import { $internal, $providing, $resolve, isMarkedInternal } from "./shared/symbols.js";
-import { getName, hasTinyestMetadata, setName } from "./shared/meta.js";
 import { Void, isPtr, isWgslArray, isWgslStruct } from "./data/wgslTypes.js";
+import { safeStringify } from "./shared/stringify.js";
+import { getName, hasTinyestMetadata, setName } from "./shared/meta.js";
 import { UnknownData, isData } from "./data/dataTypes.js";
 import { snip } from "./data/snippet.js";
 import { MissingSlotValueError, ResolutionError, WgslTypeError, invariant } from "./errors.js";
 import { isLazy, isProviding, isSlot } from "./core/slot/slotTypes.js";
 import { CodegenState, NormalState, isSelfResolvable } from "./types.js";
 import { provideCtx, topLevelState } from "./execMode.js";
-import { stitch } from "./core/resolve/stitch.js";
-import { safeStringify } from "./shared/stringify.js";
 import { getBestConversion } from "./tgsl/conversion.js";
 import { bool } from "./data/numeric.js";
 import { coerceToSnippet, concretize, numericLiteralToSnippet } from "./tgsl/generationHelpers.js";
@@ -338,7 +337,7 @@ var ResolutionCtxImpl = class {
 	get logResources() {
 		return this.#logGenerator.logResources;
 	}
-	fnToWgsl(options) {
+	resolveFunction(options) {
 		try {
 			const scope = this._itemStateStack.pushFunctionScope(options.functionType, {}, options.returnType, options.externalMap);
 			this._itemStateStack.pushBlockScope();
@@ -359,7 +358,7 @@ var ResolutionCtxImpl = class {
 				else if (firstParam?.type === FuncParameterType.identifier) {
 					const proxyEntries = [];
 					for (const a of positionalArgs) {
-						const arg = createArgument(this.makeUniqueIdentifier(`_arg_${a.schemaKey}`, "block"), a.type);
+						const arg = createArgument(this.makeUniqueIdentifier(a.schemaKey, "block"), a.type);
 						args.push(arg);
 						proxyEntries.push({
 							schemaKey: a.schemaKey,
@@ -403,6 +402,8 @@ var ResolutionCtxImpl = class {
 			let returnType;
 			const code = this.gen.functionDefinition({
 				functionType: options.functionType,
+				name: options.name,
+				workgroupSize: options.workgroupSize,
 				args,
 				body: options.body,
 				determineReturnType: () => {
@@ -486,7 +487,7 @@ var ResolutionCtxImpl = class {
 			setName(item, name);
 			return callback();
 		} finally {
-			setName(item, oldName);
+			if (oldName) setName(item, oldName);
 		}
 	}
 	unwrap(eventual) {
@@ -578,24 +579,16 @@ var ResolutionCtxImpl = class {
 		if (typeof item === "number") {
 			const realSchema = schema ?? numericLiteralToSnippet(item).dataType;
 			invariant(realSchema !== UnknownData, "Schema has to be known for resolving numbers");
-			if (realSchema.type === "abstractInt") return snip(`${item}`, realSchema, "constant");
-			if (realSchema.type === "u32") return snip(`${item}u`, realSchema, "constant");
-			if (realSchema.type === "i32") return snip(`${item}i`, realSchema, "constant");
-			const exp = item.toExponential();
-			const decimal = realSchema.type === "abstractFloat" && Number.isInteger(item) ? `${item}.` : `${item}`;
-			const base = exp.length < decimal.length ? exp : decimal;
-			if (realSchema.type === "f32") return snip(`${base}f`, realSchema, "constant");
-			if (realSchema.type === "f16") return snip(`${base}h`, realSchema, "constant");
-			return snip(base, realSchema, "constant");
+			return this.gen.numericLiteral(item, realSchema);
 		}
 		if (typeof item === "boolean") return snip(item ? "true" : "false", bool, "constant");
 		if (typeof item === "string") return snip(item, Void, "runtime");
 		if (schema && isWgslArray(schema)) {
 			if (!Array.isArray(item)) throw new WgslTypeError(`Cannot coerce ${item} into value of type '${schema}'`);
 			if (schema.elementCount !== item.length) throw new WgslTypeError(`Cannot create value of type '${schema}' from an array of length: ${item.length}`);
-			return snip(stitch`array<${this.resolve(schema.elementType)}, ${schema.elementCount}>(${item.map((element) => snip(element, schema.elementType, "runtime"))})`, schema, "runtime");
+			return this.gen.typeInstantiation(schema, item.map((element) => snip(element, schema.elementType, "runtime")));
 		}
-		if (schema && isWgslStruct(schema)) return snip(stitch`${this.resolve(schema)}(${Object.entries(schema.propTypes).map(([key, propType]) => snip(item[key], propType, "runtime"))})`, schema, "runtime");
+		if (schema && isWgslStruct(schema)) return this.gen.typeInstantiation(schema, Object.entries(schema.propTypes).map(([key, propType]) => snip(item[key], propType, "runtime")));
 		throw new WgslTypeError(`Value ${safeStringify(item)} is not resolvable${schema ? ` to type ${safeStringify(schema)}` : ""}`);
 	}
 	resolveSnippet(snippet) {

package/shared/meta.d.ts

@@ -1,16 +1,7 @@
-import { Block, FuncParameter } from "tinyest";
+import { RawMetadata } from "./normalizeMetadata.js";
 
 //#region src/shared/meta.d.ts
-interface MetaData {
-  v?: number;
-  name?: string | undefined;
-  ast?: {
-    params: FuncParameter[];
-    body: Block;
-    externalNames: string[];
-  } | undefined;
-  externals?: Record<string, unknown> | (() => Record<string, unknown>) | undefined;
-}
+
 /**
  * Don't use or you WILL get fired from your job.
  *
@@ -21,11 +12,11 @@ interface MetaData {
  * @internal
  */
 type INTERNAL_GlobalExt = typeof globalThis & {
-  __TYPEGPU_VERSION__: string | undefined;
-  __TYPEGPU_META__: WeakMap<object, MetaData>;
-  __TYPEGPU_AUTONAME__: <T>(exp: T, label: string) => T;
+  __TYPEGPU_VERSION__?: string;
+  __TYPEGPU_META__?: WeakMap<object, RawMetadata>;
+  __TYPEGPU_AUTONAME__?: <T>(exp: T, label: string) => T;
   __TYPEGPU_MEASURE_PERF__?: boolean | undefined;
-  __TYPEGPU_PERF_RECORDS__?: Map<string, unknown[]> | undefined;
+  __TYPEGPU_PERF_RECORDS__?: Map<string, unknown[]>;
 };
 /**
  * Can be assigned a name. Not to be confused with just having a name.

package/shared/meta.js

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

package/shared/normalizeMetadata.d.ts

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

package/shared/normalizeMetadata.js

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

package/std/atomic.js

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