typegpu 0.3.3 → 0.4.0

package/{vector-CDD2FV2v.d.ts → wgslTypes-BNsjCP--.d.ts}

@@ -1,21 +1,370 @@
+/**
+ * Can be assigned a name. Not to be confused with
+ * being able to HAVE a name.
+ */
+interface TgpuNamable {
+    $name(label?: string | undefined): this;
+}
+
+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;
+}
+/**
+ * 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;
+};
+
+type FormatToWGSLType<T extends VertexFormat> = (typeof formatToWGSLType)[T];
+interface TgpuVertexFormatData<T extends VertexFormat> {
+    readonly '~repr': Infer<FormatToWGSLType<T>>;
+    readonly type: T;
+}
+declare const formatToWGSLType: {
+    readonly uint8: U32;
+    readonly uint8x2: Vec2u;
+    readonly uint8x4: Vec4u;
+    readonly sint8: I32;
+    readonly sint8x2: Vec2i;
+    readonly sint8x4: Vec4i;
+    readonly unorm8: F32;
+    readonly unorm8x2: Vec2f;
+    readonly unorm8x4: Vec4f;
+    readonly snorm8: F32;
+    readonly snorm8x2: Vec2f;
+    readonly snorm8x4: Vec4f;
+    readonly uint16: U32;
+    readonly uint16x2: Vec2u;
+    readonly uint16x4: Vec4u;
+    readonly sint16: I32;
+    readonly sint16x2: Vec2i;
+    readonly sint16x4: Vec4i;
+    readonly unorm16: F32;
+    readonly unorm16x2: Vec2f;
+    readonly unorm16x4: Vec4f;
+    readonly snorm16: F32;
+    readonly snorm16x2: Vec2f;
+    readonly snorm16x4: Vec4f;
+    readonly float16: F32;
+    readonly float16x2: Vec2f;
+    readonly float16x4: Vec4f;
+    readonly float32: F32;
+    readonly float32x2: Vec2f;
+    readonly float32x3: Vec3f;
+    readonly float32x4: Vec4f;
+    readonly uint32: U32;
+    readonly uint32x2: Vec2u;
+    readonly uint32x3: Vec3u;
+    readonly uint32x4: Vec4u;
+    readonly sint32: I32;
+    readonly sint32x2: Vec2i;
+    readonly sint32x3: Vec3i;
+    readonly sint32x4: Vec4i;
+    readonly 'unorm10-10-10-2': Vec4f;
+    readonly 'unorm8x4-bgra': Vec4f;
+};
+declare const packedFormats: string[];
+type uint8 = TgpuVertexFormatData<'uint8'>;
+declare const uint8: uint8;
+type uint8x2 = TgpuVertexFormatData<'uint8x2'>;
+declare const uint8x2: uint8x2;
+type uint8x4 = TgpuVertexFormatData<'uint8x4'>;
+declare const uint8x4: uint8x4;
+type sint8 = TgpuVertexFormatData<'sint8'>;
+declare const sint8: sint8;
+type sint8x2 = TgpuVertexFormatData<'sint8x2'>;
+declare const sint8x2: sint8x2;
+type sint8x4 = TgpuVertexFormatData<'sint8x4'>;
+declare const sint8x4: sint8x4;
+type unorm8 = TgpuVertexFormatData<'unorm8'>;
+declare const unorm8: unorm8;
+type unorm8x2 = TgpuVertexFormatData<'unorm8x2'>;
+declare const unorm8x2: unorm8x2;
+type unorm8x4 = TgpuVertexFormatData<'unorm8x4'>;
+declare const unorm8x4: unorm8x4;
+type snorm8 = TgpuVertexFormatData<'snorm8'>;
+declare const snorm8: snorm8;
+type snorm8x2 = TgpuVertexFormatData<'snorm8x2'>;
+declare const snorm8x2: snorm8x2;
+type snorm8x4 = TgpuVertexFormatData<'snorm8x4'>;
+declare const snorm8x4: snorm8x4;
+type uint16 = TgpuVertexFormatData<'uint16'>;
+declare const uint16: uint16;
+type uint16x2 = TgpuVertexFormatData<'uint16x2'>;
+declare const uint16x2: uint16x2;
+type uint16x4 = TgpuVertexFormatData<'uint16x4'>;
+declare const uint16x4: uint16x4;
+type sint16 = TgpuVertexFormatData<'sint16'>;
+declare const sint16: sint16;
+type sint16x2 = TgpuVertexFormatData<'sint16x2'>;
+declare const sint16x2: sint16x2;
+type sint16x4 = TgpuVertexFormatData<'sint16x4'>;
+declare const sint16x4: sint16x4;
+type unorm16 = TgpuVertexFormatData<'unorm16'>;
+declare const unorm16: unorm16;
+type unorm16x2 = TgpuVertexFormatData<'unorm16x2'>;
+declare const unorm16x2: unorm16x2;
+type unorm16x4 = TgpuVertexFormatData<'unorm16x4'>;
+declare const unorm16x4: unorm16x4;
+type snorm16 = TgpuVertexFormatData<'snorm16'>;
+declare const snorm16: snorm16;
+type snorm16x2 = TgpuVertexFormatData<'snorm16x2'>;
+declare const snorm16x2: snorm16x2;
+type snorm16x4 = TgpuVertexFormatData<'snorm16x4'>;
+declare const snorm16x4: snorm16x4;
+type float16 = TgpuVertexFormatData<'float16'>;
+declare const float16: float16;
+type float16x2 = TgpuVertexFormatData<'float16x2'>;
+declare const float16x2: float16x2;
+type float16x4 = TgpuVertexFormatData<'float16x4'>;
+declare const float16x4: float16x4;
+type float32 = TgpuVertexFormatData<'float32'>;
+declare const float32: float32;
+type float32x2 = TgpuVertexFormatData<'float32x2'>;
+declare const float32x2: float32x2;
+type float32x3 = TgpuVertexFormatData<'float32x3'>;
+declare const float32x3: float32x3;
+type float32x4 = TgpuVertexFormatData<'float32x4'>;
+declare const float32x4: float32x4;
+type uint32 = TgpuVertexFormatData<'uint32'>;
+declare const uint32: uint32;
+type uint32x2 = TgpuVertexFormatData<'uint32x2'>;
+declare const uint32x2: uint32x2;
+type uint32x3 = TgpuVertexFormatData<'uint32x3'>;
+declare const uint32x3: uint32x3;
+type uint32x4 = TgpuVertexFormatData<'uint32x4'>;
+declare const uint32x4: uint32x4;
+type sint32 = TgpuVertexFormatData<'sint32'>;
+declare const sint32: sint32;
+type sint32x2 = TgpuVertexFormatData<'sint32x2'>;
+declare const sint32x2: sint32x2;
+type sint32x3 = TgpuVertexFormatData<'sint32x3'>;
+declare const sint32x3: sint32x3;
+type sint32x4 = TgpuVertexFormatData<'sint32x4'>;
+declare const sint32x4: sint32x4;
+type unorm10_10_10_2 = TgpuVertexFormatData<'unorm10-10-10-2'>;
+declare const unorm10_10_10_2: unorm10_10_10_2;
+type unorm8x4_bgra = TgpuVertexFormatData<'unorm8x4-bgra'>;
+declare const unorm8x4_bgra: unorm8x4_bgra;
+type PackedData = 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;
+
+/**
+ * Array schema constructed via `d.disarrayOf` function.
+ *
+ * Useful for defining vertex buffers.
+ * Elements in the schema are not aligned in respect to their `byteAlignment`,
+ * unless they are explicitly decorated with the custom align attribute
+ * via `d.align` function.
+ */
+interface Disarray<TElement extends BaseData = BaseData> {
+    readonly type: 'disarray';
+    readonly elementCount: number;
+    readonly elementType: TElement;
+    readonly '~repr': Infer<TElement>[];
+    readonly '~reprPartial': {
+        idx: number;
+        value: InferPartial<TElement>;
+    }[];
+}
+/**
+ * Struct schema constructed via `d.unstruct` function.
+ *
+ * Useful for defining vertex buffers, as the standard layout restrictions do not apply.
+ * Members are not aligned in respect to their `byteAlignment`,
+ * unless they are explicitly decorated with the custom align attribute
+ * via `d.align` function.
+ */
+interface Unstruct<TProps extends Record<string, BaseData> = Record<string, BaseData>> extends TgpuNamable {
+    readonly label?: string | undefined;
+    readonly type: 'unstruct';
+    readonly propTypes: TProps;
+    readonly '~repr': InferRecord<TProps>;
+    readonly '~reprPartial': Partial<InferPartialRecord<TProps>>;
+}
+interface LooseDecorated<TInner extends BaseData = BaseData, TAttribs extends unknown[] = unknown[]> {
+    readonly type: 'loose-decorated';
+    readonly inner: TInner;
+    readonly attribs: TAttribs;
+    readonly '~repr': Infer<TInner>;
+}
+declare const looseTypeLiterals: readonly ["unstruct", "disarray", "loose-decorated", "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 LooseTypeLiteral = (typeof looseTypeLiterals)[number];
+type AnyLooseData = Disarray | Unstruct | LooseDecorated | PackedData;
+declare function isLooseData(data: unknown): data is AnyLooseData;
+/**
+ * Checks whether the passed in value is a disarray schema,
+ * as opposed to, e.g., a regular array schema.
+ *
+ * Array schemas can be used to describe uniform and storage buffers,
+ * whereas disarray schemas cannot. Disarrays are useful for
+ * defining vertex buffers instead.
+ *
+ * @example
+ * isDisarray(d.arrayOf(d.u32, 4)) // false
+ * isDisarray(d.disarrayOf(d.u32, 4)) // true
+ * isDisarray(d.vec3f) // false
+ */
+declare function isDisarray<T extends Disarray>(schema: T | unknown): schema is T;
+/**
+ * Checks whether passed in value is a unstruct schema,
+ * as opposed to, e.g., a struct schema.
+ *
+ * Struct schemas can be used to describe uniform and storage buffers,
+ * whereas unstruct schemas cannot. Unstructs are useful for
+ * defining vertex buffers instead.
+ *
+ * @example
+ * isUnstruct(d.struct({ a: d.u32 })) // false
+ * isUnstruct(d.unstruct({ a: d.u32 })) // true
+ * isUnstruct(d.vec3f) // false
+ */
+declare function isUnstruct<T extends Unstruct>(schema: T | unknown): schema is T;
+declare function isLooseDecorated<T extends LooseDecorated>(value: T | unknown): value is T;
+declare function isData(value: unknown): value is AnyData;
+type AnyData = AnyWgslData | AnyLooseData;
+
 /**
  * Extracts the inferred representation of a resource.
  * @example
  * type A = Infer<F32> // => number
- * type B = Infer<TgpuArray<F32>> // => number[]
+ * type B = Infer<WgslArray<F32>> // => number[]
  */
 type Infer<T> = T extends {
     readonly '~repr': infer TRepr;
 } ? TRepr : T;
+type InferPartial<T> = T extends {
+    readonly '~reprPartial': infer TRepr;
+} ? TRepr : T extends {
+    readonly '~repr': infer TRepr;
+} ? TRepr | undefined : T extends Record<string | number | symbol, unknown> ? InferPartialRecord<T> : T;
 type InferRecord<T extends Record<string | number | symbol, unknown>> = {
     [Key in keyof T]: Infer<T[Key]>;
 };
+type InferPartialRecord<T extends Record<string | number | symbol, unknown>> = {
+    [Key in keyof T]: InferPartial<T[Key]>;
+};
+type MemIdentity<T> = T extends {
+    readonly '~memIdent': infer TMemIdent extends AnyData;
+} ? TMemIdent : T;
+type MemIdentityRecord<T extends Record<string | number | symbol, unknown>> = {
+    [Key in keyof T]: MemIdentity<T[Key]>;
+};
+
+type Default<T, TDefault> = unknown extends T ? TDefault : T extends undefined ? TDefault : 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];
+} & {};
+/**
+ * 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]>;
+/**
+ * The opposite of Readonly<T>
+ */
+type Mutable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
 
+/**
+ * Struct schema constructed via `d.struct` function.
+ *
+ * Responsible for handling reading and writing struct values
+ * between binary and JS representation. Takes into account
+ * the `byteAlignment` requirement of its members.
+ */
+interface WgslStruct<TProps extends Record<string, BaseData> = Record<string, BaseData>> extends TgpuNamable {
+    (props: InferRecord<TProps>): InferRecord<TProps>;
+    readonly type: 'struct';
+    readonly label?: string | undefined;
+    readonly propTypes: TProps;
+    /** Type-token, not available at runtime */
+    readonly '~repr': InferRecord<TProps>;
+    /** Type-token, not available at runtime */
+    readonly '~memIdent': WgslStruct<MemIdentityRecord<TProps>>;
+    /** Type-token, not available at runtime */
+    readonly '~reprPartial': Partial<InferPartialRecord<TProps>>;
+}
+type AnyWgslStruct = WgslStruct<any>;
+/**
+ * Creates a struct schema that can be used to construct GPU buffers.
+ * Ensures proper alignment and padding of properties (as opposed to a `d.unstruct` schema).
+ * The order of members matches the passed in properties object.
+ *
+ * @example
+ * const CircleStruct = d.struct({ radius: d.f32, pos: d.vec3f });
+ *
+ * @param props Record with `string` keys and `TgpuData` values,
+ * each entry describing one struct member.
+ */
+declare function struct<TProps extends Record<string, AnyWgslData>>(props: TProps): WgslStruct<Prettify<TProps>>;
+
+type DecoratedLocation<T extends BaseData> = Decorated<T, Location<number>[]>;
 interface NumberArrayView {
     readonly length: number;
     [n: number]: number;
 }
-interface BaseWgslData {
+interface BaseData {
     type: string;
     /** Type-token, not available at runtime */
     readonly '~repr': unknown;
@@ -518,118 +867,229 @@ interface Bool {
     readonly type: 'bool';
     readonly '~repr': boolean;
 }
+/**
+ * 32-bit float schema representing a single WGSL f32 value.
+ */
 interface F32 {
     readonly type: 'f32';
     /** Type-token, not available at runtime */
     readonly '~repr': number;
+    (v: number | boolean): number;
 }
+/**
+ * 16-bit float schema representing a single WGSL f16 value.
+ */
 interface F16 {
     readonly type: 'f16';
     /** Type-token, not available at runtime */
     readonly '~repr': number;
+    (v: number | boolean): number;
 }
+/**
+ * Signed 32-bit integer schema representing a single WGSL i32 value.
+ */
 interface I32 {
     readonly type: 'i32';
     /** Type-token, not available at runtime */
     readonly '~repr': number;
+    readonly '~memIdent': I32 | Atomic<I32> | DecoratedLocation<I32>;
+    (v: number | boolean): number;
 }
+/**
+ * Unsigned 32-bit integer schema representing a single WGSL u32 value.
+ */
 interface U32 {
     readonly type: 'u32';
     /** Type-token, not available at runtime */
     readonly '~repr': number;
+    readonly '~memIdent': U32 | Atomic<U32> | DecoratedLocation<U32>;
+    (v: number | boolean): number;
 }
+/**
+ * Type of the `d.vec2f` object/function: vector data type schema/constructor
+ */
 interface Vec2f {
     readonly type: 'vec2f';
     /** Type-token, not available at runtime */
     readonly '~repr': v2f;
+    (x: number, y: number): v2f;
+    (xy: number): v2f;
+    (): v2f;
 }
+/**
+ * Type of the `d.vec2h` object/function: vector data type schema/constructor
+ */
 interface Vec2h {
     readonly type: 'vec2h';
     /** Type-token, not available at runtime */
     readonly '~repr': v2h;
+    (x: number, y: number): v2h;
+    (xy: number): v2h;
+    (): v2h;
 }
+/**
+ * Type of the `d.vec2i` object/function: vector data type schema/constructor
+ */
 interface Vec2i {
     readonly type: 'vec2i';
     /** Type-token, not available at runtime */
     readonly '~repr': v2i;
+    (x: number, y: number): v2i;
+    (xy: number): v2i;
+    (): v2i;
 }
+/**
+ * Type of the `d.vec2u` object/function: vector data type schema/constructor
+ */
 interface Vec2u {
     readonly type: 'vec2u';
     /** Type-token, not available at runtime */
     readonly '~repr': v2u;
+    (x: number, y: number): v2u;
+    (xy: number): v2u;
+    (): v2u;
 }
+/**
+ * Type of the `d.vec3f` object/function: vector data type schema/constructor
+ */
 interface Vec3f {
     readonly type: 'vec3f';
     /** Type-token, not available at runtime */
     readonly '~repr': v3f;
+    (x: number, y: number, z: number): v3f;
+    (xyz: number): v3f;
+    (): v3f;
 }
+/**
+ * Type of the `d.vec3h` object/function: vector data type schema/constructor
+ */
 interface Vec3h {
     readonly type: 'vec3h';
     /** Type-token, not available at runtime */
     readonly '~repr': v3h;
+    (x: number, y: number, z: number): v3h;
+    (xyz: number): v3h;
+    (): v3h;
 }
+/**
+ * Type of the `d.vec3i` object/function: vector data type schema/constructor
+ */
 interface Vec3i {
     readonly type: 'vec3i';
     /** Type-token, not available at runtime */
     readonly '~repr': v3i;
+    (x: number, y: number, z: number): v3i;
+    (xyz: number): v3i;
+    (): v3i;
 }
+/**
+ * Type of the `d.vec3u` object/function: vector data type schema/constructor
+ */
 interface Vec3u {
     readonly type: 'vec3u';
     /** Type-token, not available at runtime */
     readonly '~repr': v3u;
+    (x: number, y: number, z: number): v3u;
+    (xyz: number): v3u;
+    (): v3u;
 }
+/**
+ * Type of the `d.vec4f` object/function: vector data type schema/constructor
+ */
 interface Vec4f {
     readonly type: 'vec4f';
     /** Type-token, not available at runtime */
     readonly '~repr': v4f;
+    (x: number, y: number, z: number, w: number): v4f;
+    (xyzw: number): v4f;
+    (): v4f;
 }
+/**
+ * Type of the `d.vec4h` object/function: vector data type schema/constructor
+ */
 interface Vec4h {
     readonly type: 'vec4h';
     /** Type-token, not available at runtime */
     readonly '~repr': v4h;
+    (x: number, y: number, z: number, w: number): v4h;
+    (xyzw: number): v4h;
+    (): v4h;
 }
+/**
+ * Type of the `d.vec4i` object/function: vector data type schema/constructor
+ */
 interface Vec4i {
     readonly type: 'vec4i';
     /** Type-token, not available at runtime */
     readonly '~repr': v4i;
+    (x: number, y: number, z: number, w: number): v4i;
+    (xyzw: number): v4i;
+    (): v4i;
 }
+/**
+ * Type of the `d.vec4u` object/function: vector data type schema/constructor
+ */
 interface Vec4u {
     readonly type: 'vec4u';
     /** Type-token, not available at runtime */
     readonly '~repr': v4u;
+    (x: number, y: number, z: number, w: number): v4u;
+    (xyzw: number): v4u;
+    (): v4u;
 }
+/**
+ * Type of the `d.mat2x2f` object/function: matrix data type schema/constructor
+ */
 interface Mat2x2f {
     readonly type: 'mat2x2f';
     /** Type-token, not available at runtime */
     readonly '~repr': m2x2f;
+    (...elements: number[]): m2x2f;
+    (...columns: v2f[]): m2x2f;
+    (): m2x2f;
 }
+/**
+ * Type of the `d.mat3x3f` object/function: matrix data type schema/constructor
+ */
 interface Mat3x3f {
     readonly type: 'mat3x3f';
     /** Type-token, not available at runtime */
     readonly '~repr': m3x3f;
+    (...elements: number[]): m3x3f;
+    (...columns: v3f[]): m3x3f;
+    (): m3x3f;
 }
+/**
+ * Type of the `d.mat4x4f` object/function: matrix data type schema/constructor
+ */
 interface Mat4x4f {
     readonly type: 'mat4x4f';
     /** Type-token, not available at runtime */
     readonly '~repr': m4x4f;
+    (...elements: number[]): m4x4f;
+    (...columns: v4f[]): m4x4f;
+    (): m4x4f;
 }
-interface WgslStruct<TProps extends Record<string, BaseWgslData> = Record<string, BaseWgslData>> {
-    (props: InferRecord<TProps>): InferRecord<TProps>;
-    readonly type: 'struct';
-    readonly label?: string | undefined;
-    readonly propTypes: TProps;
-    /** Type-token, not available at runtime */
-    readonly '~repr': InferRecord<TProps>;
-}
-type AnyWgslStruct = WgslStruct<any>;
-interface WgslArray<TElement = BaseWgslData> {
+/**
+ * Array schema constructed via `d.arrayOf` function.
+ *
+ * Responsible for handling reading and writing array values
+ * between binary and JS representation. Takes into account
+ * the `byteAlignment` requirement of its elementType.
+ */
+interface WgslArray<TElement extends BaseData = BaseData> {
     readonly type: 'array';
     readonly elementCount: number;
     readonly elementType: TElement;
     /** Type-token, not available at runtime */
     readonly '~repr': Infer<TElement>[];
+    readonly '~reprPartial': {
+        idx: number;
+        value: InferPartial<TElement>;
+    }[];
+    readonly '~memIdent': WgslArray<MemIdentity<TElement>>;
 }
-interface PtrFn<TInner = BaseWgslData> {
+interface PtrFn<TInner = BaseData> {
     readonly type: 'ptrFn';
     readonly inner: TInner;
     /** Type-token, not available at runtime */
@@ -643,6 +1103,7 @@ interface Atomic<TInner extends U32 | I32 = U32 | I32> {
     readonly inner: TInner;
     /** Type-token, not available at runtime */
     readonly '~repr': Infer<TInner>;
+    readonly '~memIdent': MemIdentity<TInner>;
 }
 interface Align<T extends number> {
     readonly type: '@align';
@@ -667,12 +1128,13 @@ interface Builtin<T extends string> {
     readonly type: '@builtin';
     readonly value: T;
 }
-interface Decorated<TInner extends BaseWgslData = BaseWgslData, TAttribs extends unknown[] = unknown[]> {
+interface Decorated<TInner extends BaseData = BaseData, TAttribs extends unknown[] = unknown[]> {
     readonly type: 'decorated';
     readonly inner: TInner;
     readonly attribs: TAttribs;
     /** Type-token, not available at runtime */
     readonly '~repr': Infer<TInner>;
+    readonly '~memIdent': TAttribs extends Location<number>[] ? MemIdentity<TInner> | Decorated<MemIdentity<TInner>, TAttribs> : Decorated<MemIdentity<TInner>, TAttribs>;
 }
 declare const wgslTypeLiterals: readonly ["bool", "f32", "f16", "i32", "u32", "vec2f", "vec2h", "vec2i", "vec2u", "vec3f", "vec3h", "vec3i", "vec3u", "vec4f", "vec4h", "vec4i", "vec4u", "mat2x2f", "mat3x3f", "mat4x4f", "struct", "array", "ptrFn", "atomic", "decorated"];
 type WgslTypeLiteral = (typeof wgslTypeLiterals)[number];
@@ -729,249 +1191,4 @@ declare function isInterpolateAttrib<T extends Interpolate<InterpolationType>>(v
 declare function isBuiltinAttrib<T extends Builtin<string>>(value: unknown | T): value is T;
 declare function isDecorated<T extends Decorated>(value: unknown | T): value is T;
 
-/**
- * Type encompassing all available kinds of vector.
- */
-type VecKind = 'vec2f' | 'vec2i' | 'vec2u' | 'vec2h' | 'vec3f' | 'vec3i' | 'vec3u' | 'vec3h' | 'vec4f' | 'vec4i' | 'vec4u' | 'vec4h';
-/**
- * Type of the `d.vec2f` object/function: vector data type schema/constructor
- */
-type NativeVec2f = Vec2f & {
-    '~exotic': Vec2f;
-} & ((x: number, y: number) => v2f) & ((xy: number) => v2f) & (() => v2f);
-/**
- *
- * Schema representing vec2f - a vector with 2 elements of type f32.
- * Also a constructor function for this vector value.
- *
- * @example
- * const vector = d.vec2f(); // (0.0, 0.0)
- * const vector = d.vec2f(1); // (1.0, 1.0)
- * const vector = d.vec2f(0.5, 0.1); // (0.5, 0.1)
- *
- * @example
- * const buffer = root.createBuffer(d.vec2f, d.vec2f(0, 1)); // buffer holding a d.vec2f value, with an initial value of vec2f(0, 1);
- */
-declare const vec2f: NativeVec2f;
-/**
- * Type of the `d.vec2h` object/function: vector data type schema/constructor
- */
-type NativeVec2h = Vec2h & {
-    '~exotic': Vec2h;
-} & ((x: number, y: number) => v2h) & ((xy: number) => v2h) & (() => v2h);
-/**
- *
- * Schema representing vec2h - a vector with 2 elements of type f16.
- * Also a constructor function for this vector value.
- *
- * @example
- * const vector = d.vec2h(); // (0.0, 0.0)
- * const vector = d.vec2h(1); // (1.0, 1.0)
- * const vector = d.vec2h(0.5, 0.1); // (0.5, 0.1)
- *
- * @example
- * const buffer = root.createBuffer(d.vec2h, d.vec2h(0, 1)); // buffer holding a d.vec2h value, with an initial value of vec2h(0, 1);
- */
-declare const vec2h: NativeVec2h;
-/**
- * Type of the `d.vec2i` object/function: vector data type schema/constructor
- */
-type NativeVec2i = Vec2i & {
-    '~exotic': Vec2i;
-} & ((x: number, y: number) => v2i) & ((xy: number) => v2i) & (() => v2i);
-/**
- *
- * Schema representing vec2i - a vector with 2 elements of type i32.
- * Also a constructor function for this vector value.
- *
- * @example
- * const vector = d.vec2i(); // (0, 0)
- * const vector = d.vec2i(1); // (1, 1)
- * const vector = d.vec2i(-1, 1); // (-1, 1)
- *
- * @example
- * const buffer = root.createBuffer(d.vec2i, d.vec2i(0, 1)); // buffer holding a d.vec2i value, with an initial value of vec2i(0, 1);
- */
-declare const vec2i: NativeVec2i;
-/**
- * Type of the `d.vec2u` object/function: vector data type schema/constructor
- */
-type NativeVec2u = Vec2u & {
-    '~exotic': Vec2u;
-} & ((x: number, y: number) => v2u) & ((xy: number) => v2u) & (() => v2u);
-/**
- *
- * Schema representing vec2u - a vector with 2 elements of type u32.
- * Also a constructor function for this vector value.
- *
- * @example
- * const vector = d.vec2u(); // (0, 0)
- * const vector = d.vec2u(1); // (1, 1)
- * const vector = d.vec2u(1, 2); // (1, 2)
- *
- * @example
- * const buffer = root.createBuffer(d.vec2u, d.vec2u(0, 1)); // buffer holding a d.vec2u value, with an initial value of vec2u(0, 1);
- */
-declare const vec2u: NativeVec2u;
-/**
- * Type of the `d.vec3f` object/function: vector data type schema/constructor
- */
-type NativeVec3f = Vec3f & {
-    '~exotic': Vec3f;
-} & ((x: number, y: number, z: number) => v3f) & ((xyz: number) => v3f) & (() => v3f);
-/**
- *
- * Schema representing vec3f - a vector with 3 elements of type f32.
- * Also a constructor function for this vector value.
- *
- * @example
- * const vector = d.vec3f(); // (0.0, 0.0, 0.0)
- * const vector = d.vec3f(1); // (1.0, 1.0, 1.0)
- * const vector = d.vec3f(1, 2, 3.5); // (1.0, 2.0, 3.5)
- *
- * @example
- * const buffer = root.createBuffer(d.vec3f, d.vec3f(0, 1, 2)); // buffer holding a d.vec3f value, with an initial value of vec3f(0, 1, 2);
- */
-declare const vec3f: NativeVec3f;
-/**
- * Type of the `d.vec3h` object/function: vector data type schema/constructor
- */
-type NativeVec3h = Vec3h & {
-    '~exotic': Vec3h;
-} & ((x: number, y: number, z: number) => v3h) & ((xyz: number) => v3h) & (() => v3h);
-/**
- *
- * Schema representing vec3h - a vector with 3 elements of type f16.
- * Also a constructor function for this vector value.
- *
- * @example
- * const vector = d.vec3h(); // (0.0, 0.0, 0.0)
- * const vector = d.vec3h(1); // (1.0, 1.0, 1.0)
- * const vector = d.vec3h(1, 2, 3.5); // (1.0, 2.0, 3.5)
- *
- * @example
- * const buffer = root.createBuffer(d.vec3h, d.vec3h(0, 1, 2)); // buffer holding a d.vec3h value, with an initial value of vec3h(0, 1, 2);
- */
-declare const vec3h: NativeVec3h;
-/**
- * Type of the `d.vec3i` object/function: vector data type schema/constructor
- */
-type NativeVec3i = Vec3i & {
-    '~exotic': Vec3i;
-} & ((x: number, y: number, z: number) => v3i) & ((xyz: number) => v3i) & (() => v3i);
-/**
- *
- * Schema representing vec3i - a vector with 3 elements of type i32.
- * Also a constructor function for this vector value.
- *
- * @example
- * const vector = d.vec3i(); // (0, 0, 0)
- * const vector = d.vec3i(1); // (1, 1, 1)
- * const vector = d.vec3i(1, 2, -3); // (1, 2, -3)
- *
- * @example
- * const buffer = root.createBuffer(d.vec3i, d.vec3i(0, 1, 2)); // buffer holding a d.vec3i value, with an initial value of vec3i(0, 1, 2);
- */
-declare const vec3i: NativeVec3i;
-/**
- * Type of the `d.vec3u` object/function: vector data type schema/constructor
- */
-type NativeVec3u = Vec3u & {
-    '~exotic': Vec3u;
-} & ((x: number, y: number, z: number) => v3u) & ((xyz: number) => v3u) & (() => v3u);
-/**
- *
- * Schema representing vec3u - a vector with 3 elements of type u32.
- * Also a constructor function for this vector value.
- *
- * @example
- * const vector = d.vec3u(); // (0, 0, 0)
- * const vector = d.vec3u(1); // (1, 1, 1)
- * const vector = d.vec3u(1, 2, 3); // (1, 2, 3)
- *
- * @example
- * const buffer = root.createBuffer(d.vec3u, d.vec3u(0, 1, 2)); // buffer holding a d.vec3u value, with an initial value of vec3u(0, 1, 2);
- */
-declare const vec3u: NativeVec3u;
-/**
- * Type of the `d.vec4f` object/function: vector data type schema/constructor
- */
-type NativeVec4f = Vec4f & {
-    '~exotic': Vec4f;
-} & ((x: number, y: number, z: number, w: number) => v4f) & ((xyzw: number) => v4f) & (() => v4f);
-/**
- *
- * Schema representing vec4f - a vector with 4 elements of type f32.
- * Also a constructor function for this vector value.
- *
- * @example
- * const vector = d.vec4f(); // (0.0, 0.0, 0.0, 0.0)
- * const vector = d.vec4f(1); // (1.0, 1.0, 1.0, 1.0)
- * const vector = d.vec4f(1, 2, 3, 4.5); // (1.0, 2.0, 3.0, 4.5)
- *
- * @example
- * const buffer = root.createBuffer(d.vec4f, d.vec4f(0, 1, 2, 3)); // buffer holding a d.vec4f value, with an initial value of vec4f(0, 1, 2, 3);
- */
-declare const vec4f: NativeVec4f;
-/**
- * Type of the `d.vec4h` object/function: vector data type schema/constructor
- */
-type NativeVec4h = Vec4h & {
-    '~exotic': Vec4h;
-} & ((x: number, y: number, z: number, w: number) => v4h) & ((xyzw: number) => v4h) & (() => v4h);
-/**
- *
- * Schema representing vec4h - a vector with 4 elements of type f16.
- * Also a constructor function for this vector value.
- *
- * @example
- * const vector = d.vec4h(); // (0.0, 0.0, 0.0, 0.0)
- * const vector = d.vec4h(1); // (1.0, 1.0, 1.0, 1.0)
- * const vector = d.vec4h(1, 2, 3, 4.5); // (1.0, 2.0, 3.0, 4.5)
- *
- * @example
- * const buffer = root.createBuffer(d.vec4h, d.vec4h(0, 1, 2, 3)); // buffer holding a d.vec4h value, with an initial value of vec4h(0, 1, 2, 3);
- */
-declare const vec4h: NativeVec4h;
-/**
- * Type of the `d.vec4i` object/function: vector data type schema/constructor
- */
-type NativeVec4i = Vec4i & {
-    '~exotic': Vec4i;
-} & ((x: number, y: number, z: number, w: number) => v4i) & ((xyzw: number) => v4i) & (() => v4i);
-/**
- *
- * Schema representing vec4i - a vector with 4 elements of type i32.
- * Also a constructor function for this vector value.
- *
- * @example
- * const vector = d.vec4i(); // (0, 0, 0, 0)
- * const vector = d.vec4i(1); // (1, 1, 1, 1)
- * const vector = d.vec4i(1, 2, 3, -4); // (1, 2, 3, -4)
- *
- * @example
- * const buffer = root.createBuffer(d.vec4i, d.vec4i(0, 1, 2, 3)); // buffer holding a d.vec4i value, with an initial value of vec4i(0, 1, 2, 3);
- */
-declare const vec4i: NativeVec4i;
-/**
- * Type of the `d.vec4u` object/function: vector data type schema/constructor
- */
-type NativeVec4u = Vec4u & {
-    '~exotic': Vec4u;
-} & ((x: number, y: number, z: number, w: number) => v4u) & ((xyzw: number) => v4u) & (() => v4u);
-/**
- *
- * Schema representing vec4u - a vector with 4 elements of type u32.
- * Also a constructor function for this vector value.
- *
- * @example
- * const vector = d.vec4u(); // (0, 0, 0, 0)
- * const vector = d.vec4u(1); // (1, 1, 1, 1)
- * const vector = d.vec4u(1, 2, 3, 4); // (1, 2, 3, 4)
- *
- * @example
- * const buffer = root.createBuffer(d.vec4u, d.vec4u(0, 1, 2, 3)); // buffer holding a d.vec4u value, with an initial value of vec4u(0, 1, 2, 3);
- */
-declare const vec4u: NativeVec4u;
-
-export { type InterpolationType as $, type AnyWgslData as A, type BaseWgslData as B, type NativeVec3u as C, type Decorated as D, type NativeVec3i as E, type F32 as F, type InferRecord as G, type m2x2f as H, type Infer as I, type m3x3f as J, type m4x4f as K, type Location as L, type Mat2x2f as M, type NativeVec2u as N, type v2f as O, type PtrFn as P, type Mat3x3f as Q, type v3f as R, type Mat4x4f as S, type v4f as T, type U32 as U, type Vec2f as V, type WgslArray as W, type Atomic as X, type Align as Y, type Size as Z, type Interpolate as _, type F16 as a, type PerspectiveOrLinearInterpolationType as a0, type PerspectiveOrLinearInterpolatableData as a1, type FlatInterpolationType as a2, type FlatInterpolatableData as a3, isWgslData as a4, isWgslArray as a5, isWgslStruct as a6, isPtrFn as a7, isAtomic as a8, isDecorated as a9, isAlignAttrib as aa, isBuiltinAttrib as ab, isLocationAttrib as ac, isInterpolateAttrib as ad, isSizeAttrib as ae, type v2i as af, type v2u as ag, type v3i as ah, type v3u as ai, type v4i as aj, type v4u as ak, vec2f as al, vec2h as am, vec2i as an, vec2u as ao, vec3f as ap, vec3h as aq, vec3i as ar, vec3u as as, vec4f as at, vec4h as au, vec4i as av, vec4u as aw, type VecKind as ax, type I32 as b, type Vec3f as c, type Vec4f as d, type Vec2h as e, type Vec3h as f, type Vec4h as g, type Vec2i as h, type Vec3i as i, type Vec4i as j, type Vec2u as k, type Vec3u as l, type Vec4u as m, type AnyWgslStruct as n, type WgslTypeLiteral as o, type AnyVecInstance as p, type AnyMatInstance as q, type Builtin as r, type Bool as s, type WgslStruct as t, type NativeVec4u as u, type NativeVec2i as v, type NativeVec4i as w, type NativeVec2f as x, type NativeVec4f as y, type NativeVec3f as z };
+export { isWgslStruct as $, type AnyWgslData as A, type BaseData as B, type AnyVecInstance as C, type Decorated as D, type AnyMatInstance as E, type F32 as F, type Bool as G, type PtrFn as H, type Infer as I, type Mat2x2f as J, type KindToAcceptedAttribMap as K, type Location as L, type Mutable as M, type Mat3x3f as N, type OmitProps as O, type Prettify as P, type Mat4x4f as Q, type m2x2f as R, type m3x3f as S, type TgpuNamable as T, type U32 as U, type Vec2f as V, type WgslArray as W, type m4x4f as X, type Atomic as Y, isWgslData as Z, isWgslArray as _, type F16 as a, float32x4 as a$, isPtrFn as a0, isAtomic as a1, isDecorated as a2, isAlignAttrib as a3, isBuiltinAttrib as a4, isLocationAttrib as a5, isInterpolateAttrib as a6, isSizeAttrib as a7, type Size as a8, type Align as a9, sint8 as aA, sint8x2 as aB, sint8x4 as aC, unorm8 as aD, unorm8x2 as aE, unorm8x4 as aF, snorm8 as aG, snorm8x2 as aH, snorm8x4 as aI, uint16 as aJ, uint16x2 as aK, uint16x4 as aL, sint16 as aM, sint16x2 as aN, sint16x4 as aO, unorm16 as aP, unorm16x2 as aQ, unorm16x4 as aR, snorm16 as aS, snorm16x2 as aT, snorm16x4 as aU, float16 as aV, float16x2 as aW, float16x4 as aX, float32 as aY, float32x2 as aZ, float32x3 as a_, type Builtin as aa, type Interpolate as ab, type v2f as ac, type v2i as ad, type v2u as ae, type v3f as af, type v3i as ag, type v3u as ah, type v4f as ai, type v4i as aj, type v4u as ak, struct as al, type LooseDecorated as am, type AnyLooseData as an, isDisarray as ao, isUnstruct as ap, isLooseDecorated as aq, isData as ar, isLooseData as as, type FormatToWGSLType as at, type TgpuVertexFormatData as au, formatToWGSLType as av, packedFormats as aw, uint8 as ax, uint8x2 as ay, uint8x4 as az, type I32 as b, uint32 as b0, uint32x2 as b1, uint32x3 as b2, uint32x4 as b3, sint32 as b4, sint32x2 as b5, sint32x3 as b6, sint32x4 as b7, unorm10_10_10_2 as b8, unorm8x4_bgra as b9, type PackedData as ba, type InterpolationType as bb, type PerspectiveOrLinearInterpolationType as bc, type PerspectiveOrLinearInterpolatableData as bd, type FlatInterpolationType as be, type FlatInterpolatableData as bf, type LooseTypeLiteral as bg, type v2h as bh, type v3h as bi, type v4h as bj, type Vec3f as c, type Vec4f as d, type Vec2h as e, type Vec3h as f, type Vec4h as g, type Vec2i as h, type Vec3i as i, type Vec4i as j, type Vec2u as k, type Vec3u as l, type Vec4u as m, type AnyWgslStruct as n, type Default as o, type UnionToIntersection as p, type Disarray as q, type Unstruct as r, type VertexFormat as s, type TgpuVertexAttrib as t, type KindToDefaultFormatMap as u, type AnyData as v, type WgslStruct as w, type InferPartial as x, type MemIdentity as y, type WgslTypeLiteral as z };