typegpu 0.10.1 → 0.11.0-rc.1

package/shared/meta.js

@@ -0,0 +1,61 @@
+import { version } from "../package.js";
+import { DEV, TEST } from "./env.js";
+import { $getNameForward, isMarkedInternal } from "./symbols.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;
+function isForwarded(value) {
+	return !!value?.[$getNameForward];
+}
+function getName(definition) {
+	if (isForwarded(definition)) return getName(definition[$getNameForward]);
+	return getMetaData(definition)?.name;
+}
+function setName(definition, name) {
+	if (isForwarded(definition)) {
+		setName(definition[$getNameForward], name);
+		return;
+	}
+	setMetaData(definition, { name });
+}
+function isNamable(value) {
+	return !!value?.$name;
+}
+/**
+* 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
+	});
+}
+//#endregion
+export { PERF, getMetaData, getName, hasTinyestMetadata, isNamable, setName };

package/shared/repr.d.ts

@@ -0,0 +1,138 @@
+import { $gpuRepr, $gpuValueOf, $inRepr, $invalidSchemaReason, $memIdent, $repr, $reprPartial, $reprPatch, $validStorageSchema, $validUniformSchema, $validVertexSchema } from "./symbols.js";
+import { Default } from "./utilityTypes.js";
+import { U16, U32, WgslArray } from "../data/wgslTypes.js";
+import { ViewDimensionToDimension } from "../core/texture/textureFormats.js";
+import { WgslStorageTexture, WgslTexture } from "../data/texture.js";
+import { TgpuTexture } from "../core/texture/texture.js";
+import { Disarray, Undecorate } from "../data/dataTypes.js";
+
+//#region src/shared/repr.d.ts
+/**
+ * Extracts the inferred representation of a resource.
+ * For inferring types as seen by the GPU, see {@link InferGPU}
+ *
+ * @example
+ * type A = Infer<F32> // => number
+ * type B = Infer<WgslArray<F32>> // => number[]
+ * type C = Infer<Atomic<U32>> // => number
+ */
+type Infer<T> = T extends {
+  readonly [$repr]: infer TRepr;
+} ? TRepr : T;
+/**
+ * Extracts the inferred input (write-side) representation of a resource.
+ *
+ * @example
+ * type A = InferInput<Vec3f> // => v3f | [number, number, number] | Float32Array
+ * type B = InferInput<WgslArray<Vec3f>> // => (v3f | [number, number, number] | Float32Array)[] | Float32Array
+ * type C = InferInput<F32> // => number (same as Infer<F32>)
+ * const arrayOfStructs = d.arrayOf(d.struct({ pos: d.vec3f, id: d.f32 }), 4);
+ * type D = d.InferInput<typeof arrayOfStructs>; // { pos: d.v3f | Float32Array<ArrayBufferLike> | [number, number, number]; id: number; }[]
+ */
+type InferInput<T> = Infer<T> | (T extends {
+  readonly [$inRepr]: infer TRepr;
+} ? TRepr : never);
+/**
+ * Extracts a sparse/partial inferred representation of a resource.
+ * Used by the `buffer.writePartial` API.
+ *
+ * @deprecated
+ *
+ * @example
+ * type A = InferPartial<F32> // => number | undefined
+ * type B = InferPartial<WgslStruct<{ a: F32 }>> // => { a?: number | undefined }
+ * type C = InferPartial<WgslArray<F32>> // => { idx: number; value: number | undefined }[] | undefined
+ */
+type InferPartial<T> = T extends {
+  readonly [$reprPartial]: infer TRepr;
+} ? TRepr : T extends {
+  readonly [$repr]: infer TRepr;
+} ? TRepr | undefined : T;
+/**
+ * Extracts the inferred representation of a resource (as seen by the GPU).
+ *
+ * @example
+ * type A = InferGPU<F32> // => number
+ * type B = InferGPU<WgslArray<F32>> // => number[]
+ * type C = InferGPU<Atomic<U32>> // => atomicU32
+ */
+type InferGPU<T> = T extends {
+  readonly [$gpuRepr]: infer TRepr;
+} ? TRepr : Infer<T>;
+type InferRecord<T extends Record<string | number | symbol, unknown>> = { [Key in keyof T]: Infer<T[Key]> };
+type InferInputRecord<T extends Record<string | number | symbol, unknown>> = { [Key in keyof T]: InferInput<T[Key]> };
+/** @deprecated */
+type InferPartialRecord<T extends Record<string | number | symbol, unknown>> = { [Key in keyof T]?: InferPartial<T[Key]> };
+/**
+ * Extracts the patch representation of a resource.
+ * Used by the `buffer.patch` API.
+ *
+ * @example
+ * type A = InferPatch<F32> // => number | undefined
+ * type B = InferPatch<WgslStruct<{ a: F32 }>> // => { a?: number | undefined }
+ * type C = InferPatch<WgslArray<F32>> // => Record<number, number | undefined> | number[] | undefined
+ */
+type InferPatch<T> = T extends {
+  readonly [$reprPatch]: infer TRepr;
+} ? TRepr : InferInput<T> | undefined;
+type InferPatchRecord<T extends Record<string | number | symbol, unknown>> = { [Key in keyof T]?: InferPatch<T[Key]> };
+type InferGPURecord<T extends Record<string | number | symbol, unknown>> = { [Key in keyof T]: InferGPU<T[Key]> };
+type GPUValueOf<T> = T extends {
+  readonly [$gpuValueOf]: infer TValue;
+} ? TValue : T;
+type MemIdentity<T> = T extends {
+  readonly [$memIdent]: infer TMemIdent;
+} ? TMemIdent : T;
+type MemIdentityRecord<T extends Record<string | number | symbol, unknown>> = { [Key in keyof T]: MemIdentity<T[Key]> };
+type IsValidStorageSchema<T> = (T extends {
+  readonly [$validStorageSchema]: true;
+} ? true : false) extends false ? false : true;
+type IsValidUniformSchema<T> = (T extends {
+  readonly [$validUniformSchema]: true;
+} ? true : false) extends false ? false : true;
+type IsValidVertexSchema<T> = (T extends {
+  readonly [$validVertexSchema]: true;
+} ? true : false) extends false ? false : true;
+/**
+ * Accepts only arrays (or disarrays) of u32 or u16.
+ */
+type IsValidIndexSchema<T> = Undecorate<T> extends WgslArray | Disarray ? Undecorate<Undecorate<T>['elementType']> extends U32 | U16 ? true : false : false;
+/**
+ * Checks if a schema can be used in a buffer at all
+ */
+type IsValidBufferSchema<T> = IsValidStorageSchema<T> | IsValidUniformSchema<T> | IsValidVertexSchema<T> | IsValidIndexSchema<T> extends false ? false : true;
+/**
+ * Validates if a texture can be used as sampled texture
+ */
+type IsValidSampledTextureUsage<TTexture extends TgpuTexture> = TTexture['usableAsSampled'] extends true ? true : {
+  readonly invalidSampled: "Texture not usable as sampled, call $usage('sampled') first";
+};
+/**
+ * Validates if a texture can be used as storage texture
+ */
+type IsValidStorageTextureUsage<TTexture extends TgpuTexture> = TTexture['usableAsStorage'] extends true ? true : {
+  readonly invalidStorage: "Texture not usable as storage, call $usage('storage') first";
+};
+/**
+ * Validates if a texture view dimension is compatible with the texture dimension
+ */
+type IsValidSubdimension<TTexture extends TgpuTexture, TSchema extends WgslTexture | WgslStorageTexture> = ViewDimensionToDimension[TSchema['dimension']] extends infer TVDim ? TVDim extends Default<TTexture['props']['dimension'], '2d'> ? true : {
+  readonly invalidViewDim: `Texture dimension '${Default<TTexture['props']['dimension'], '2d'>}' incompatible with view dimension '${TSchema['dimension']}'`;
+} : never;
+type IsValidStorageFormat<TTexture extends TgpuTexture, TSchema extends WgslStorageTexture> = TSchema['format'] extends TTexture['props']['format'] ? true : TTexture['props']['viewFormats'] extends readonly unknown[] ? TSchema['format'] extends TTexture['props']['viewFormats'][number] ? true : FormatError<TSchema, TTexture> : FormatError<TSchema, TTexture>;
+type FormatError<TSchema extends WgslStorageTexture, TTexture extends TgpuTexture> = {
+  readonly invalidFormat: `Storage texture format '${TSchema['format']}' incompatible with texture format '${TTexture['props']['format']}'`;
+};
+type IsExactly<T, U> = [T] extends [U] ? ([U] extends [T] ? true : false) : false;
+type SelfOrErrors<TSelf, T> = IsExactly<T, true> extends true ? TSelf : `(Error) ${T[Extract<keyof T, `invalid${string}`>] & string}`;
+type ValidStorageUsage<TTexture extends TgpuTexture, TSchema extends WgslStorageTexture> = IsValidStorageTextureUsage<TTexture> & IsValidSubdimension<TTexture, TSchema> & IsValidStorageFormat<TTexture, TSchema>;
+type ValidSampledUsage<TTexture extends TgpuTexture, TSchema extends WgslTexture> = IsValidSampledTextureUsage<TTexture> & IsValidSubdimension<TTexture, TSchema>;
+/**
+ * Validates texture view schema against texture usage
+ */
+type ValidateTextureViewSchema<TTexture extends TgpuTexture, TSchema extends WgslTexture | WgslStorageTexture> = TSchema extends WgslStorageTexture ? SelfOrErrors<TSchema, ValidStorageUsage<TTexture, TSchema>> : TSchema extends WgslTexture ? SelfOrErrors<TSchema, ValidSampledUsage<TTexture, TSchema>> : never;
+type ExtractInvalidSchemaError<T, TPrefix extends string = ''> = [T] extends [{
+  readonly [$invalidSchemaReason]: string;
+}] ? `${TPrefix}${T[typeof $invalidSchemaReason]}` : never;
+//#endregion
+export { ExtractInvalidSchemaError, GPUValueOf, Infer, InferGPU, InferGPURecord, InferInput, InferInputRecord, InferPartial, InferPartialRecord, InferPatch, InferPatchRecord, InferRecord, IsValidBufferSchema, IsValidIndexSchema, IsValidStorageSchema, IsValidUniformSchema, IsValidVertexSchema, MemIdentity, MemIdentityRecord, ValidateTextureViewSchema };

package/shared/stringify.js

@@ -0,0 +1,20 @@
+import { isMatInstance, isVecInstance } from "../data/wgslTypes.js";
+//#region src/shared/stringify.ts
+function safeStringify(item) {
+	const asString = String(item);
+	if (asString !== "[object Object]") return asString;
+	try {
+		return JSON.stringify(item);
+	} catch (error) {
+		console.error("Error parsing JSON:", error);
+		return "<invalid json>";
+	}
+}
+function niceStringify(item) {
+	if (isVecInstance(item) || isMatInstance(item)) return item.toString();
+	if (Array.isArray(item)) return `[${item.map(niceStringify).join(", ")}]`;
+	if (item && typeof item === "object") return `{ ${Object.entries(item).map(([key, value]) => `${key}: ${niceStringify(value)}`).join(", ")} }`;
+	return String(item);
+}
+//#endregion
+export { niceStringify, safeStringify };

package/shared/symbols.d.ts

@@ -0,0 +1,70 @@
+//#region src/shared/symbols.d.ts
+declare const $internal: unique symbol;
+/**
+ * The getter to the value of this resource, accessible on the GPU
+ */
+declare const $gpuValueOf: unique symbol;
+/**
+ * If this symbol is present, this means that getName and setName
+ * will refer to object behind this property instead.
+ */
+declare const $getNameForward: unique symbol;
+/**
+ * Marks an object with slot-value bindings
+ */
+declare const $providing: unique symbol;
+declare const $resolve: unique symbol;
+/**
+ * A way for a schema to provide casting behavior, without the need to be explicitly
+ * callable by the end-user (e.g. vertex formats)
+ */
+declare const $cast: unique symbol;
+/**
+ * Can be called on the GPU
+ */
+declare const $gpuCallable: unique symbol;
+/**
+ * Type token for the inferred (CPU & GPU) representation of a resource
+ */
+declare const $repr: unique symbol;
+/**
+ * Type token for the inferred (GPU-side) representation of a resource
+ * If present, it shadows the value of `$repr` for GPU-side inference.
+ */
+declare const $gpuRepr: unique symbol;
+/**
+ * Type token for the inferred partial representation of a resource.
+ * If present, it shadows the value of `$repr` for use in partial IO.
+ */
+declare const $reprPartial: unique symbol;
+/**
+ * Type token for the inferred patch representation of a resource.
+ * Used by the `buffer.patch` API with `Record<number, T>` sparse arrays.
+ */
+declare const $reprPatch: unique symbol;
+/**
+ * Type token for the write-side (input) representation of a resource.
+ */
+declare const $inRepr: unique symbol;
+/**
+ * Type token holding schemas that are identical in memory layout.
+ */
+declare const $memIdent: unique symbol;
+/**
+ * Type token, signaling that a schema can be used in a storage buffer.
+ */
+declare const $validStorageSchema: unique symbol;
+/**
+ * Type token, signaling that a schema can be used in a uniform buffer.
+ */
+declare const $validUniformSchema: unique symbol;
+/**
+ * Type token, signaling that a schema can be used in a vertex buffer.
+ */
+declare const $validVertexSchema: unique symbol;
+/**
+ * Type token, containing a reason for why the schema is invalid (if it is).
+ */
+declare const $invalidSchemaReason: unique symbol;
+//#endregion
+export { $cast, $getNameForward, $gpuCallable, $gpuRepr, $gpuValueOf, $inRepr, $internal, $invalidSchemaReason, $memIdent, $providing, $repr, $reprPartial, $reprPatch, $resolve, $validStorageSchema, $validUniformSchema, $validVertexSchema };

package/shared/symbols.js

@@ -0,0 +1,48 @@
+import { version } from "../package.js";
+//#region src/shared/symbols.ts
+const $internal = Symbol(`typegpu:${version}:$internal`);
+/**
+* The getter to the value of this resource, accessible on the GPU
+*/
+const $gpuValueOf = Symbol(`typegpu:${version}:$gpuValueOf`);
+/**
+* If this symbol is present, this means that getName and setName
+* will refer to object behind this property instead.
+*/
+const $getNameForward = Symbol(`typegpu:${version}:$getNameForward`);
+/**
+* Marks an object with slot-value bindings
+*/
+const $providing = Symbol(`typegpu:${version}:$providing`);
+/**
+* Objects can provide the snippet that represents them.
+*/
+const $ownSnippet = Symbol(`typegpu:${version}:$ownSnippet`);
+const $resolve = Symbol(`typegpu:${version}:$resolve`);
+/**
+* A way for a schema to provide casting behavior, without the need to be explicitly
+* callable by the end-user (e.g. vertex formats)
+*/
+const $cast = Symbol(`typegpu:${version}:$cast`);
+/**
+* Can be called on the GPU
+*/
+const $gpuCallable = Symbol(`typegpu:${version}:$gpuCallable`);
+/**
+* Type token for the inferred (CPU & GPU) representation of a resource
+*/
+const $repr = Symbol(`typegpu:${version}:$repr`);
+Symbol(`typegpu:${version}:$gpuRepr`);
+Symbol(`typegpu:${version}:$reprPartial`);
+Symbol(`typegpu:${version}:$reprPatch`);
+Symbol(`typegpu:${version}:$inRepr`);
+Symbol(`typegpu:${version}:$memIdent`);
+Symbol(`typegpu:${version}:$invalidStorageSchema`);
+Symbol(`typegpu:${version}:$validUniformSchema`);
+Symbol(`typegpu:${version}:$validVertexSchema`);
+Symbol(`typegpu:${version}:$invalidSchemaReason`);
+function isMarkedInternal(value) {
+	return !!value?.[$internal];
+}
+//#endregion
+export { $cast, $getNameForward, $gpuCallable, $gpuValueOf, $internal, $ownSnippet, $providing, $repr, $resolve, isMarkedInternal };

package/shared/utilityTypes.d.ts

@@ -0,0 +1,33 @@
+//#region src/shared/utilityTypes.d.ts
+type Default<T, TDefault> = unknown extends T ? TDefault : T extends undefined ? TDefault : T;
+type SwapNever<T, Replacement> = [T] extends [never] ? Replacement : T;
+type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends ((x: infer I) => void) ? I : never;
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+/**
+ * Utility type that merges a partial type with defaults, where defaults are used
+ * for properties not present in the partial type.
+ */
+type WithDefaults<TPartial, TDefaults> = Omit<TDefaults, keyof TPartial> & TPartial;
+/**
+ * Removes properties from record type that extend `Prop`
+ */
+type OmitProps<T extends Record<string, unknown>, Prop> = Pick<T, { [Key in keyof T]: T[Key] extends Prop ? never : Key }[keyof T]>;
+type NullableToOptional<T> = { [K in keyof T as T[K] extends null ? K : never]?: T[K] } & { [K in keyof T as T[K] extends null ? never : K]: T[K] };
+/**
+ * The opposite of Readonly<T>
+ */
+type Mutable<T> = { -readonly [P in keyof T]: T[P] };
+/**
+ * Source: https://code.lol/post/programming/higher-kinded-types
+ */
+type Assume<T, U> = T extends U ? T : U;
+/**
+ * Any typed array
+ */
+type TypedArray = Uint8Array | Uint16Array | Uint32Array | Int32Array | Float32Array | Float64Array;
+/**
+ * Source: https://futurestud.io/tutorials/typescript-how-to-remove-index-signature-from-a-type
+ */
+type RemoveIndexSignature<T> = { [K in keyof T as string extends K ? never : number extends K ? never : symbol extends K ? never : K]: T[K] };
+//#endregion
+export { Assume, Default, Mutable, NullableToOptional, OmitProps, Prettify, RemoveIndexSignature, SwapNever, TypedArray, UnionToIntersection, WithDefaults };

package/shared/utilityTypes.js

@@ -0,0 +1,6 @@
+//#region src/shared/utilityTypes.ts
+function assertExhaustive(x, location) {
+	throw new Error(`Failed to handle ${x} at ${location}`);
+}
+//#endregion
+export { assertExhaustive };

package/shared/vertexFormat.d.ts

@@ -0,0 +1,70 @@
+//#region src/shared/vertexFormat.d.ts
+declare const vertexFormats: readonly ["uint8", "uint8x2", "uint8x4", "sint8", "sint8x2", "sint8x4", "unorm8", "unorm8x2", "unorm8x4", "snorm8", "snorm8x2", "snorm8x4", "uint16", "uint16x2", "uint16x4", "sint16", "sint16x2", "sint16x4", "unorm16", "unorm16x2", "unorm16x4", "snorm16", "snorm16x2", "snorm16x4", "float16", "float16x2", "float16x4", "float32", "float32x2", "float32x3", "float32x4", "uint32", "uint32x2", "uint32x3", "uint32x4", "sint32", "sint32x2", "sint32x3", "sint32x4", "unorm10-10-10-2", "unorm8x4-bgra"];
+type VertexFormat = (typeof vertexFormats)[number];
+declare const kindToDefaultFormatMap: {
+  readonly f32: "float32";
+  readonly vec2f: "float32x2";
+  readonly vec3f: "float32x3";
+  readonly vec4f: "float32x4";
+  readonly f16: "float16";
+  readonly vec2h: "float16x2";
+  readonly vec4h: "float16x4";
+  readonly u32: "uint32";
+  readonly vec2u: "uint32x2";
+  readonly vec3u: "uint32x3";
+  readonly vec4u: "uint32x4";
+  readonly i32: "sint32";
+  readonly vec2i: "sint32x2";
+  readonly vec3i: "sint32x3";
+  readonly vec4i: "sint32x4";
+};
+type KindToDefaultFormatMap = typeof kindToDefaultFormatMap;
+interface TgpuVertexAttrib<TFormat extends VertexFormat = VertexFormat> {
+  readonly format: TFormat;
+  readonly offset: number;
+}
+type AnyVertexAttribs = Record<string, TgpuVertexAttrib> | TgpuVertexAttrib;
+/**
+ * All vertex attribute formats that can be interpreted as
+ * an single or multi component u32 in a shader.
+ * https://www.w3.org/TR/webgpu/#vertex-formats
+ */
+type U32CompatibleFormats = TgpuVertexAttrib<'uint8'> | TgpuVertexAttrib<'uint8x2'> | TgpuVertexAttrib<'uint8x4'> | TgpuVertexAttrib<'uint16'> | TgpuVertexAttrib<'uint16x2'> | TgpuVertexAttrib<'uint16x4'> | TgpuVertexAttrib<'uint32'> | TgpuVertexAttrib<'uint32x2'> | TgpuVertexAttrib<'uint32x3'> | TgpuVertexAttrib<'uint32x4'>;
+/**
+ * All vertex attribute formats that can be interpreted as
+ * an single or multi component i32 in a shader.
+ * https://www.w3.org/TR/webgpu/#vertex-formats
+ */
+type I32CompatibleFormats = TgpuVertexAttrib<'sint8'> | TgpuVertexAttrib<'sint8x2'> | TgpuVertexAttrib<'sint8x4'> | TgpuVertexAttrib<'sint16'> | TgpuVertexAttrib<'sint16x2'> | TgpuVertexAttrib<'sint16x4'> | TgpuVertexAttrib<'sint32'> | TgpuVertexAttrib<'sint32x2'> | TgpuVertexAttrib<'sint32x3'> | TgpuVertexAttrib<'sint32x4'>;
+/**
+ * All vertex attribute formats that can be interpreted as
+ * an single or multi component f32 in a shader.
+ * https://www.w3.org/TR/webgpu/#vertex-formats
+ */
+type F32CompatibleFormats = TgpuVertexAttrib<'unorm8'> | TgpuVertexAttrib<'unorm8x2'> | TgpuVertexAttrib<'unorm8x4'> | TgpuVertexAttrib<'snorm8'> | TgpuVertexAttrib<'snorm8x2'> | TgpuVertexAttrib<'snorm8x4'> | TgpuVertexAttrib<'unorm16'> | TgpuVertexAttrib<'unorm16x2'> | TgpuVertexAttrib<'unorm16x4'> | TgpuVertexAttrib<'snorm16'> | TgpuVertexAttrib<'snorm16x2'> | TgpuVertexAttrib<'snorm16x4'> | TgpuVertexAttrib<'float16'> | TgpuVertexAttrib<'float16x2'> | TgpuVertexAttrib<'float16x4'> | TgpuVertexAttrib<'float32'> | TgpuVertexAttrib<'float32x2'> | TgpuVertexAttrib<'float32x3'> | TgpuVertexAttrib<'float32x4'> | TgpuVertexAttrib<'unorm10-10-10-2'> | TgpuVertexAttrib<'unorm8x4-bgra'>;
+/**
+ * All vertex attribute formats that can be interpreted as
+ * a single or multi component f16 in a shader. (same as f32 on the shader side)
+ * https://www.w3.org/TR/webgpu/#vertex-formats
+ */
+type F16CompatibleFormats = F32CompatibleFormats;
+type KindToAcceptedAttribMap = {
+  u32: U32CompatibleFormats;
+  vec2u: U32CompatibleFormats;
+  vec3u: U32CompatibleFormats;
+  vec4u: U32CompatibleFormats;
+  i32: I32CompatibleFormats;
+  vec2i: I32CompatibleFormats;
+  vec3i: I32CompatibleFormats;
+  vec4i: I32CompatibleFormats;
+  f16: F16CompatibleFormats;
+  vec2h: F16CompatibleFormats;
+  vec3h: F16CompatibleFormats;
+  vec4h: F16CompatibleFormats;
+  f32: F32CompatibleFormats;
+  vec2f: F32CompatibleFormats;
+  vec3f: F32CompatibleFormats;
+  vec4f: F32CompatibleFormats;
+};
+//#endregion
+export { AnyVertexAttribs, KindToAcceptedAttribMap, KindToDefaultFormatMap, TgpuVertexAttrib, VertexFormat };

package/shared/vertexFormat.js

@@ -0,0 +1,63 @@
+//#region src/shared/vertexFormat.ts
+const vertexFormats = [
+	"uint8",
+	"uint8x2",
+	"uint8x4",
+	"sint8",
+	"sint8x2",
+	"sint8x4",
+	"unorm8",
+	"unorm8x2",
+	"unorm8x4",
+	"snorm8",
+	"snorm8x2",
+	"snorm8x4",
+	"uint16",
+	"uint16x2",
+	"uint16x4",
+	"sint16",
+	"sint16x2",
+	"sint16x4",
+	"unorm16",
+	"unorm16x2",
+	"unorm16x4",
+	"snorm16",
+	"snorm16x2",
+	"snorm16x4",
+	"float16",
+	"float16x2",
+	"float16x4",
+	"float32",
+	"float32x2",
+	"float32x3",
+	"float32x4",
+	"uint32",
+	"uint32x2",
+	"uint32x3",
+	"uint32x4",
+	"sint32",
+	"sint32x2",
+	"sint32x3",
+	"sint32x4",
+	"unorm10-10-10-2",
+	"unorm8x4-bgra"
+];
+const kindToDefaultFormatMap = {
+	f32: "float32",
+	vec2f: "float32x2",
+	vec3f: "float32x3",
+	vec4f: "float32x4",
+	f16: "float16",
+	vec2h: "float16x2",
+	vec4h: "float16x4",
+	u32: "uint32",
+	vec2u: "uint32x2",
+	vec3u: "uint32x3",
+	vec4u: "uint32x4",
+	i32: "sint32",
+	vec2i: "sint32x2",
+	vec3i: "sint32x3",
+	vec4i: "sint32x4"
+};
+//#endregion
+export { kindToDefaultFormatMap, vertexFormats };

package/std/array.d.ts

@@ -0,0 +1,7 @@
+import { DualFn } from "../types.js";
+import { _ref } from "../data/ref.js";
+
+//#region src/std/array.d.ts
+declare const arrayLength: DualFn;
+//#endregion
+export { arrayLength };

package/std/array.js

@@ -0,0 +1,25 @@
+import { isPtr, isWgslArray } from "../data/wgslTypes.js";
+import { stitch } from "../core/resolve/stitch.js";
+import { ptrFn } from "../data/ptr.js";
+import { isRef } from "../data/ref.js";
+import { abstractInt, u32 } from "../data/numeric.js";
+import { dualImpl } from "../core/function/dualImpl.js";
+//#region src/std/array.ts
+const sizeOfPointedToArray = (dataType) => isPtr(dataType) && isWgslArray(dataType.inner) ? dataType.inner.elementCount : 0;
+const arrayLength = dualImpl({
+	name: "arrayLength",
+	signature: (arg) => {
+		const ptrArg = isPtr(arg) ? arg : ptrFn(arg);
+		return {
+			argTypes: [ptrArg],
+			returnType: sizeOfPointedToArray(ptrArg) > 0 ? abstractInt : u32
+		};
+	},
+	normalImpl: (a) => isRef(a) ? a.$.length : a.length,
+	codegenImpl(_ctx, [a]) {
+		const length = sizeOfPointedToArray(a.dataType);
+		return length > 0 ? `${length}` : stitch`arrayLength(${a})`;
+	}
+});
+//#endregion
+export { arrayLength };

package/std/atomic.d.ts

@@ -0,0 +1,19 @@
+import { DualFn } from "../types.js";
+import { atomicI32, atomicU32 } from "../data/wgslTypes.js";
+
+//#region src/std/atomic.d.ts
+type AnyAtomic = atomicI32 | atomicU32;
+declare const workgroupBarrier: DualFn;
+declare const storageBarrier: DualFn;
+declare const textureBarrier: DualFn;
+declare const atomicLoad: DualFn;
+declare const atomicStore: DualFn;
+declare const atomicAdd: DualFn;
+declare const atomicSub: DualFn;
+declare const atomicMax: DualFn;
+declare const atomicMin: DualFn;
+declare const atomicAnd: DualFn;
+declare const atomicOr: DualFn;
+declare const atomicXor: DualFn;
+//#endregion
+export { atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, storageBarrier, textureBarrier, workgroupBarrier };