typegpu 0.5.8 → 0.6.0

package/{tgpuComputeFn-S61HxwW-.d.cts → tgpuComputeFn-DOUjhQua.d.ts}

@@ -1,6 +1,30 @@
-import * as tinyest from 'tinyest';
 import { FuncParameter, Block } from 'tinyest';
 
+interface MetaData {
+    name?: string | undefined;
+    ast?: {
+        v: number;
+        params: FuncParameter[];
+        body: Block;
+        externalNames: string[];
+    } | undefined;
+    externals?: Record<string, unknown> | undefined;
+}
+/**
+ * Don't use or you WILL get fired from your job.
+ *
+ * The information that this type describes is additional
+ * properties that we add onto `globalThis`, used by tools
+ * like `unplugin-typegpu` or our test suite.
+ *
+ * @internal
+ */
+type INTERNAL_GlobalExt = typeof globalThis & {
+    __TYPEGPU_META__: WeakMap<object, MetaData>;
+    __TYPEGPU_AUTONAME__: <T>(exp: T, label: string) => T;
+    __TYPEGPU_MEASURE_PERF__?: boolean | undefined;
+    __TYPEGPU_PERF_RECORDS__?: Map<string, unknown[]> | undefined;
+};
 /**
  * Can be assigned a name. Not to be confused with
  * being able to HAVE a name.
@@ -11,7 +35,30 @@ interface TgpuNamable {
     $name(label: string): this;
 }
 
+declare const $internal: unique symbol;
+/**
+ * Marks an object with slot-value bindings
+ */
+declare const $providing: 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 holding schemas that are identical in memory layout.
+ */
+declare const $memIdent: unique symbol;
+
 /**
  * Extracts the inferred representation of a resource.
  * For inferring types as seen by the GPU, see {@link InferGPU}
@@ -34,7 +81,7 @@ type Infer<T> = T extends {
  * type C = InferPartial<WgslArray<F32>> // => { idx: number; value: number | undefined }[] | undefined
  */
 type InferPartial<T> = T extends {
-    readonly '~reprPartial': infer TRepr;
+    readonly [$reprPartial]: infer TRepr;
 } ? TRepr : T extends {
     readonly [$repr]: infer TRepr;
 } ? TRepr | undefined : T;
@@ -47,7 +94,7 @@ type InferPartial<T> = T extends {
  * type C = InferGPU<Atomic<U32>> // => atomicU32
  */
 type InferGPU<T> = T extends {
-    readonly '~gpuRepr': infer TRepr;
+    readonly [$gpuRepr]: infer TRepr;
 } ? TRepr : Infer<T>;
 type InferRecord<T extends Record<string | number | symbol, unknown>> = {
     [Key in keyof T]: Infer<T[Key]>;
@@ -59,14 +106,12 @@ type InferGPURecord<T extends Record<string | number | symbol, unknown>> = {
     [Key in keyof T]: InferGPU<T[Key]>;
 };
 type MemIdentity<T> = T extends {
-    readonly '~memIdent': infer TMemIdent;
+    readonly [$memIdent]: infer TMemIdent;
 } ? TMemIdent : T;
 type MemIdentityRecord<T extends Record<string | number | symbol, unknown>> = {
     [Key in keyof T]: MemIdentity<T[Key]>;
 };
 
-declare const $internal: unique symbol;
-
 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> = {
@@ -78,6 +123,11 @@ type Prettify<T> = {
 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>
  */
@@ -687,6 +737,7 @@ interface Bool {
     readonly [$internal]: true;
     readonly type: 'bool';
     readonly [$repr]: boolean;
+    (v?: number | boolean): boolean;
 }
 /**
  * 32-bit float schema representing a single WGSL f32 value.
@@ -695,7 +746,7 @@ interface F32 {
     readonly [$internal]: true;
     readonly type: 'f32';
     readonly [$repr]: number;
-    (v: number | boolean): number;
+    (v?: number | boolean): number;
 }
 /**
  * 16-bit float schema representing a single WGSL f16 value.
@@ -704,7 +755,7 @@ interface F16 {
     readonly [$internal]: true;
     readonly type: 'f16';
     readonly [$repr]: number;
-    (v: number | boolean): number;
+    (v?: number | boolean): number;
 }
 /**
  * Signed 32-bit integer schema representing a single WGSL i32 value.
@@ -713,8 +764,8 @@ interface I32 {
     readonly [$internal]: true;
     readonly type: 'i32';
     readonly [$repr]: number;
-    readonly '~memIdent': I32 | Atomic<I32> | DecoratedLocation<I32>;
-    (v: number | boolean): number;
+    readonly [$memIdent]: I32 | Atomic<I32> | DecoratedLocation<I32>;
+    (v?: number | boolean): number;
 }
 /**
  * Unsigned 32-bit integer schema representing a single WGSL u32 value.
@@ -723,8 +774,16 @@ interface U32 {
     readonly [$internal]: true;
     readonly type: 'u32';
     readonly [$repr]: number;
-    readonly '~memIdent': U32 | Atomic<U32> | DecoratedLocation<U32>;
-    (v: number | boolean): number;
+    readonly [$memIdent]: U32 | Atomic<U32> | DecoratedLocation<U32>;
+    (v?: number | boolean): number;
+}
+/**
+ * Unsigned 16-bit integer schema used exclusively for index buffer schemas.
+ */
+interface U16 {
+    readonly [$internal]: true;
+    readonly type: 'u16';
+    readonly [$repr]: number;
 }
 /**
  * Type of the `d.vec2f` object/function: vector data type schema/constructor
@@ -959,6 +1018,7 @@ interface Mat2x2f {
     (...elements: [number, number, number, number]): m2x2f;
     (...columns: [v2f, v2f]): m2x2f;
     (): m2x2f;
+    identity(): m2x2f;
 }
 /**
  * Type of the `d.mat3x3f` object/function: matrix data type schema/constructor
@@ -970,6 +1030,7 @@ interface Mat3x3f {
     (...elements: [number, number, number, number, number, number, number, number, number]): m3x3f;
     (...columns: [v3f, v3f, v3f]): m3x3f;
     (): m3x3f;
+    identity(): m3x3f;
 }
 /**
  * Type of the `d.mat4x4f` object/function: matrix data type schema/constructor
@@ -981,6 +1042,12 @@ interface Mat4x4f {
     (...elements: [number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number]): m4x4f;
     (...columns: [v4f, v4f, v4f, v4f]): m4x4f;
     (): m4x4f;
+    identity(): m4x4f;
+    translation(vec: v3f): m4x4f;
+    scaling(vec: v3f): m4x4f;
+    rotationX(angle: number): m4x4f;
+    rotationY(angle: number): m4x4f;
+    rotationZ(angle: number): m4x4f;
 }
 /**
  * Array schema constructed via `d.arrayOf` function.
@@ -995,12 +1062,12 @@ interface WgslArray<TElement extends BaseData = BaseData> {
     readonly elementCount: number;
     readonly elementType: TElement;
     readonly [$repr]: Infer<TElement>[];
-    readonly '~gpuRepr': InferGPU<TElement>[];
-    readonly '~reprPartial': {
+    readonly [$gpuRepr]: InferGPU<TElement>[];
+    readonly [$reprPartial]: {
         idx: number;
         value: InferPartial<TElement>;
     }[] | undefined;
-    readonly '~memIdent': WgslArray<MemIdentity<TElement>>;
+    readonly [$memIdent]: WgslArray<MemIdentity<TElement>>;
 }
 /**
  * Struct schema constructed via `d.struct` function.
@@ -1015,12 +1082,9 @@ interface WgslStruct<TProps extends Record<string, BaseData> = Record<string, Ba
     readonly type: 'struct';
     readonly propTypes: TProps;
     readonly [$repr]: Prettify<InferRecord<TProps>>;
-    /** Type-token, not available at runtime */
-    readonly '~gpuRepr': Prettify<InferGPURecord<TProps>>;
-    /** Type-token, not available at runtime */
-    readonly '~memIdent': WgslStruct<Prettify<MemIdentityRecord<TProps>>>;
-    /** Type-token, not available at runtime */
-    readonly '~reprPartial': Prettify<Partial<InferPartialRecord<TProps>>> | undefined;
+    readonly [$gpuRepr]: Prettify<InferGPURecord<TProps>>;
+    readonly [$memIdent]: WgslStruct<Prettify<MemIdentityRecord<TProps>>>;
+    readonly [$reprPartial]: Prettify<Partial<InferPartialRecord<TProps>>> | undefined;
 }
 type AnyWgslStruct = WgslStruct<any>;
 type AddressSpace = 'uniform' | 'storage' | 'workgroup' | 'private' | 'function' | 'handle';
@@ -1042,8 +1106,8 @@ interface Atomic<TInner extends U32 | I32 = U32 | I32> {
     readonly type: 'atomic';
     readonly inner: TInner;
     readonly [$repr]: Infer<TInner>;
-    readonly '~gpuRepr': TInner extends U32 ? atomicU32 : atomicI32;
-    readonly '~memIdent': MemIdentity<TInner>;
+    readonly [$gpuRepr]: TInner extends U32 ? atomicU32 : atomicI32;
+    readonly [$memIdent]: MemIdentity<TInner>;
 }
 interface atomicU32 {
     readonly [$internal]: true;
@@ -1087,17 +1151,17 @@ interface Decorated<TInner extends BaseData = BaseData, TAttribs extends unknown
     readonly inner: TInner;
     readonly attribs: TAttribs;
     readonly [$repr]: Infer<TInner>;
-    readonly '~gpuRepr': InferGPU<TInner>;
-    readonly '~reprPartial': InferPartial<TInner>;
-    readonly '~memIdent': TAttribs extends Location[] ? MemIdentity<TInner> | Decorated<MemIdentity<TInner>, TAttribs> : Decorated<MemIdentity<TInner>, TAttribs>;
+    readonly [$gpuRepr]: InferGPU<TInner>;
+    readonly [$reprPartial]: InferPartial<TInner>;
+    readonly [$memIdent]: TAttribs extends Location[] ? MemIdentity<TInner> | Decorated<MemIdentity<TInner>, TAttribs> : Decorated<MemIdentity<TInner>, TAttribs>;
 }
-declare const wgslTypeLiterals: readonly ["bool", "f32", "f16", "i32", "u32", "vec2f", "vec2h", "vec2i", "vec2u", "vec2<bool>", "vec3f", "vec3h", "vec3i", "vec3u", "vec3<bool>", "vec4f", "vec4h", "vec4i", "vec4u", "vec4<bool>", "mat2x2f", "mat3x3f", "mat4x4f", "struct", "array", "ptr", "atomic", "decorated", "abstractInt", "abstractFloat", "void"];
+declare const wgslTypeLiterals: readonly ["bool", "f32", "f16", "i32", "u32", "u16", "vec2f", "vec2h", "vec2i", "vec2u", "vec2<bool>", "vec3f", "vec3h", "vec3i", "vec3u", "vec3<bool>", "vec4f", "vec4h", "vec4i", "vec4u", "vec4<bool>", "mat2x2f", "mat3x3f", "mat4x4f", "struct", "array", "ptr", "atomic", "decorated", "abstractInt", "abstractFloat", "void"];
 type WgslTypeLiteral = (typeof wgslTypeLiterals)[number];
 type PerspectiveOrLinearInterpolatableBaseType = F32 | F16 | Vec2f | Vec2h | Vec3f | Vec3h | Vec4f | Vec4h;
 type PerspectiveOrLinearInterpolatableData = PerspectiveOrLinearInterpolatableBaseType | Decorated<PerspectiveOrLinearInterpolatableBaseType>;
 type FlatInterpolatableAdditionalBaseType = I32 | U32 | Vec2i | Vec2u | Vec3i | Vec3u | Vec4i | Vec4u;
 type FlatInterpolatableData = PerspectiveOrLinearInterpolatableData | FlatInterpolatableAdditionalBaseType | Decorated<FlatInterpolatableAdditionalBaseType>;
-type AnyWgslData = Bool | F32 | F16 | I32 | U32 | Vec2f | Vec2h | Vec2i | Vec2u | Vec2b | Vec3f | Vec3h | Vec3i | Vec3u | Vec3b | Vec4f | Vec4h | Vec4i | Vec4u | Vec4b | Mat2x2f | Mat3x3f | Mat4x4f | AnyWgslStruct | WgslArray | Ptr | Atomic | Decorated | AbstractInt | AbstractFloat | Void;
+type AnyWgslData = Bool | F32 | F16 | I32 | U32 | U16 | Vec2f | Vec2h | Vec2i | Vec2u | Vec2b | Vec3f | Vec3h | Vec3i | Vec3u | Vec3b | Vec4f | Vec4h | Vec4i | Vec4u | Vec4b | Mat2x2f | Mat3x3f | Mat4x4f | AnyWgslStruct | WgslArray | Ptr | Atomic<U32> | Atomic<I32> | Decorated | AbstractInt | AbstractFloat | Void;
 declare function isWgslData(value: unknown): value is AnyWgslData;
 /**
  * Checks whether passed in value is an array schema,
@@ -1150,6 +1214,7 @@ declare function isDecorated<T extends Decorated>(value: unknown | T): value is
 
 interface TgpuConst<TDataType extends AnyWgslData = AnyWgslData> extends TgpuNamable {
     readonly value: InferGPU<TDataType>;
+    readonly $: InferGPU<TDataType>;
     readonly [$internal]: {
         readonly dataType: TDataType;
     };
@@ -1181,7 +1246,7 @@ type BuiltinPosition = Decorated<Vec4f, [Builtin<'position'>]>;
 type BuiltinClipDistances = Decorated<WgslArray<U32>, [
     Builtin<'clip_distances'>
 ]>;
-type BuiltinFrontFacing = Decorated<F32, [Builtin<'front_facing'>]>;
+type BuiltinFrontFacing = Decorated<Bool, [Builtin<'front_facing'>]>;
 type BuiltinFragDepth = Decorated<F32, [Builtin<'frag_depth'>]>;
 type BuiltinSampleIndex = Decorated<U32, [Builtin<'sample_index'>]>;
 type BuiltinSampleMask = Decorated<U32, [Builtin<'sample_mask'>]>;
@@ -1238,11 +1303,20 @@ interface StorageFlag {
 type Storage = StorageFlag;
 declare function isUsableAsStorage<T>(value: T): value is T & StorageFlag;
 
-/**
- * Used to transpile JS resources into tinyest on demand.
- */
-interface JitTranspiler {
-    transpileFn(rawJs: string): TranspilationResult;
+interface TgpuQuerySet<T extends GPUQueryType> extends TgpuNamable {
+    readonly resourceType: 'query-set';
+    readonly type: T;
+    readonly count: number;
+    readonly querySet: GPUQuerySet;
+    readonly destroyed: boolean;
+    readonly available: boolean;
+    readonly [$internal]: {
+        readonly readBuffer: GPUBuffer;
+        readonly resolveBuffer: GPUBuffer;
+    };
+    resolve(): void;
+    read(): Promise<bigint[]>;
+    destroy(): void;
 }
 
 interface NameRegistry {
@@ -1272,7 +1346,7 @@ declare class StrictNameRegistry implements NameRegistry {
 type TgpuFnShellHeader<Args extends AnyData[], Return extends AnyData> = {
     readonly [$internal]: true;
     readonly argTypes: Args;
-    readonly returnType: Return | undefined;
+    readonly returnType: Return;
     readonly isEntry: false;
 };
 /**
@@ -1280,33 +1354,29 @@ type TgpuFnShellHeader<Args extends AnyData[], Return extends AnyData> = {
  * Allows creating tgpu functions by calling this shell
  * and passing the implementation (as WGSL string or JS function) as the argument.
  */
-type TgpuFnShell<Args extends AnyData[], Return extends AnyData> = TgpuFnShellHeader<Args, Return> & ((implementation: (...args: InferArgs<Args>) => InferReturn<Return>) => TgpuFn<Args, Return>) & ((implementation: string) => TgpuFn<Args, Return>) & ((strings: TemplateStringsArray, ...values: unknown[]) => TgpuFn<Args, Return>) & {
-    /**
-     * @deprecated Invoke the shell as a function instead.
-     */
-    does: ((implementation: (...args: InferArgs<Args>) => InferReturn<Return>) => TgpuFn<Args, Return>) & ((implementation: string) => TgpuFn<Args, Return>);
-};
-interface TgpuFnBase<Args extends AnyData[], Return extends AnyData> extends TgpuNamable {
+type TgpuFnShell<Args extends AnyData[], Return extends AnyData> = TgpuFnShellHeader<Args, Return> & (<T extends (...args: InferArgs<Args>) => Infer<Return>>(implementation: T) => TgpuFn<Prettify<InheritArgNames<(...args: Args) => Return, T>>['result']>) & ((implementation: string) => TgpuFn<(...args: Args) => Return>) & ((strings: TemplateStringsArray, ...values: unknown[]) => TgpuFn<(...args: Args) => Return>);
+interface TgpuFnBase<ImplSchema extends AnyFn> extends TgpuNamable {
     readonly [$internal]: {
-        implementation: Implementation<Args, Return>;
+        implementation: Implementation<ImplSchema>;
         argTypes: FnArgsConversionHint;
     };
     readonly resourceType: 'function';
-    readonly shell: TgpuFnShellHeader<Args, Return>;
-    readonly '~providing'?: Providing | undefined;
+    readonly shell: TgpuFnShellHeader<Parameters<ImplSchema>, Extract<ReturnType<ImplSchema>, AnyData>>;
+    readonly [$providing]?: Providing | undefined;
     $uses(dependencyMap: Record<string, unknown>): this;
-    with<T>(slot: TgpuSlot<T>, value: Eventual<T>): TgpuFn<Args, Return>;
-    with<T extends AnyData>(accessor: TgpuAccessor<T>, value: TgpuFn<[], T> | TgpuBufferUsage<T> | Infer<T>): TgpuFn<Args, Return>;
+    with<T>(slot: TgpuSlot<T>, value: Eventual<T>): TgpuFn<ImplSchema>;
+    with<T extends AnyData>(accessor: TgpuAccessor<T>, value: TgpuFn<() => T> | TgpuBufferUsage<T> | Infer<T>): TgpuFn<ImplSchema>;
 }
-type TgpuFn<Args extends AnyData[] = AnyData[], Return extends AnyData = AnyData> = TgpuFnBase<Args, Return> & ((...args: InferArgs<Args>) => InferReturn<Return>);
+type TgpuFn<ImplSchema extends AnyFn = (...args: any[]) => any> = TgpuFnBase<ImplSchema> & InferImplSchema<ImplSchema>;
 declare function fn<Args extends AnyData[] | []>(argTypes: Args, returnType?: undefined): TgpuFnShell<Args, Void>;
 declare function fn<Args extends AnyData[] | [], Return extends AnyData>(argTypes: Args, returnType: Return): TgpuFnShell<Args, Return>;
-declare function isTgpuFn<Args extends AnyData[], Return extends AnyData>(value: unknown | TgpuFn<Args, Return>): value is TgpuFn<Args, Return>;
+declare function isTgpuFn<Args extends AnyData[] | [], Return extends AnyData>(value: unknown | TgpuFn<(...args: Args) => Return>): value is TgpuFn<(...args: Args) => Return>;
 
 interface TgpuSlot<T> extends TgpuNamable {
+    readonly [$internal]: true;
     readonly resourceType: 'slot';
     readonly [$repr]: Infer<T>;
-    readonly '~gpuRepr': InferGPU<T>;
+    readonly [$gpuRepr]: InferGPU<T>;
     readonly defaultValue: T | undefined;
     /**
      * Used to determine if code generated using either value `a` or `b` in place
@@ -1314,13 +1384,15 @@ interface TgpuSlot<T> extends TgpuNamable {
      */
     areEqual(a: T, b: T): boolean;
     readonly value: InferGPU<T>;
+    readonly $: InferGPU<T>;
 }
 interface TgpuDerived<T> {
     readonly resourceType: 'derived';
     readonly value: InferGPU<T>;
-    [$repr]: Infer<T>;
-    '~gpuRepr': InferGPU<T>;
-    readonly '~providing'?: Providing | undefined;
+    readonly $: InferGPU<T>;
+    readonly [$repr]: Infer<T>;
+    readonly [$gpuRepr]: InferGPU<T>;
+    readonly [$providing]?: Providing | undefined;
     with<TValue>(slot: TgpuSlot<TValue>, value: Eventual<TValue>): TgpuDerived<T>;
     /**
      * @internal
@@ -1328,13 +1400,15 @@ interface TgpuDerived<T> {
     '~compute'(): T;
 }
 interface TgpuAccessor<T extends AnyData = AnyData> extends TgpuNamable {
+    readonly [$internal]: true;
     readonly resourceType: 'accessor';
     readonly [$repr]: Infer<T>;
-    readonly '~gpuRepr': InferGPU<T>;
+    readonly [$gpuRepr]: InferGPU<T>;
     readonly schema: T;
-    readonly defaultValue: TgpuFn<[], T> | TgpuBufferUsage<T> | Infer<T> | undefined;
-    readonly slot: TgpuSlot<TgpuFn<[], T> | TgpuBufferUsage<T> | Infer<T>>;
+    readonly defaultValue: TgpuFn<() => T> | TgpuBufferUsage<T> | Infer<T> | undefined;
+    readonly slot: TgpuSlot<TgpuFn<() => T> | TgpuBufferUsage<T> | Infer<T>>;
     readonly value: InferGPU<T>;
+    readonly $: InferGPU<T>;
 }
 /**
  * Represents a value that is available at resolution time.
@@ -1348,15 +1422,37 @@ type Providing = {
 declare function isSlot<T>(value: unknown | TgpuSlot<T>): value is TgpuSlot<T>;
 declare function isDerived<T extends TgpuDerived<unknown>>(value: T | unknown): value is T;
 
+interface Timeable {
+    withPerformanceCallback(callback: (start: bigint, end: bigint) => void | Promise<void>): this;
+    withTimestampWrites(options: {
+        querySet: TgpuQuerySet<'timestamp'> | GPUQuerySet;
+        beginningOfPassWriteIndex?: number;
+        endOfPassWriteIndex?: number;
+    }): this;
+}
+type TimestampWritesPriors = {
+    readonly timestampWrites?: {
+        querySet: TgpuQuerySet<'timestamp'> | GPUQuerySet;
+        beginningOfPassWriteIndex?: number;
+        endOfPassWriteIndex?: number;
+    };
+    readonly performanceCallback?: (start: bigint, end: bigint) => void | Promise<void>;
+    readonly hasAutoQuerySet?: boolean;
+};
+
 interface ComputePipelineInternals {
     readonly rawPipeline: GPUComputePipeline;
+    readonly priors: TgpuComputePipelinePriors & TimestampWritesPriors;
 }
-interface TgpuComputePipeline extends TgpuNamable {
+interface TgpuComputePipeline extends TgpuNamable, SelfResolvable, Timeable {
     readonly [$internal]: ComputePipelineInternals;
     readonly resourceType: 'compute-pipeline';
     with(bindGroupLayout: TgpuBindGroupLayout, bindGroup: TgpuBindGroup): TgpuComputePipeline;
     dispatchWorkgroups(x: number, y?: number | undefined, z?: number | undefined): void;
 }
+type TgpuComputePipelinePriors = {
+    readonly bindGroupLayoutMap?: Map<TgpuBindGroupLayout, TgpuBindGroup>;
+} & TimestampWritesPriors;
 
 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];
@@ -1439,8 +1535,8 @@ type FragmentOutConstrained = IOLayout<Vec4f | Decorated<Vec4f, (Location | Inte
  * Describes a fragment entry function signature (its arguments, return type and targets)
  */
 type TgpuFragmentFnShellHeader<FragmentIn extends FragmentInConstrained, FragmentOut extends FragmentOutConstrained> = {
-    readonly argTypes: [IOLayoutToSchema<FragmentIn>] | [];
-    readonly targets: FragmentOut;
+    readonly in: FragmentIn | undefined;
+    readonly out: FragmentOut;
     readonly returnType: IOLayoutToSchema<FragmentOut>;
     readonly isEntry: true;
 };
@@ -1468,6 +1564,7 @@ type TgpuFragmentFnShell<FragmentIn extends FragmentInConstrained, FragmentOut e
      */ ((implementation: string) => TgpuFragmentFn<OmitBuiltins<FragmentIn>, OmitBuiltins<FragmentOut>>);
 };
 interface TgpuFragmentFn<Varying extends FragmentInConstrained = FragmentInConstrained, Output extends FragmentOutConstrained = FragmentOutConstrained> extends TgpuNamable {
+    readonly [$internal]: true;
     readonly shell: TgpuFragmentFnShellHeader<Varying, Output>;
     readonly outputType: IOLayoutToSchema<Output>;
     $uses(dependencyMap: Record<string, unknown>): this;
@@ -1480,15 +1577,15 @@ declare function fragmentFn<FragmentIn extends FragmentInConstrained, FragmentOu
     out: FragmentOut;
 }): TgpuFragmentFnShell<FragmentIn, FragmentOut>;
 
-type VertexInConstrained = IORecord<BaseIOData | AnyVertexInputBuiltin>;
+type VertexInConstrained = IORecord<BaseIOData | Decorated<BaseIOData, Location[]> | AnyVertexInputBuiltin>;
 type VertexOutConstrained = IORecord<BaseIOData | Decorated<BaseIOData, (Location | Interpolate)[]> | AnyVertexOutputBuiltin>;
 /**
  * Describes a vertex entry function signature (its arguments, return type and attributes)
  */
 type TgpuVertexFnShellHeader<VertexIn extends VertexInConstrained, VertexOut extends VertexOutConstrained> = {
+    readonly in: VertexIn | undefined;
+    readonly out: VertexOut;
     readonly argTypes: [IOLayoutToSchema<VertexIn>] | [];
-    readonly returnType: IOLayoutToSchema<VertexOut> | undefined;
-    readonly attributes: [VertexIn];
     readonly isEntry: true;
 };
 /**
@@ -1502,10 +1599,9 @@ type TgpuVertexFnShell<VertexIn extends VertexInConstrained, VertexOut extends V
      */
     does: ((implementation: (input: InferIO<VertexIn>) => InferIO<VertexOut>) => TgpuVertexFn<OmitBuiltins<VertexIn>, OmitBuiltins<VertexOut>>) & ((implementation: string) => TgpuVertexFn<OmitBuiltins<VertexIn>, OmitBuiltins<VertexOut>>);
 };
-interface TgpuVertexFn<VertexIn extends VertexInConstrained = any, VertexOut extends VertexOutConstrained = any> extends TgpuNamable {
+interface TgpuVertexFn<VertexIn extends VertexInConstrained = VertexInConstrained, VertexOut extends VertexOutConstrained = VertexOutConstrained> extends TgpuNamable {
+    readonly [$internal]: true;
     readonly shell: TgpuVertexFnShellHeader<VertexIn, VertexOut>;
-    readonly outputType: IOLayoutToSchema<VertexOut>;
-    readonly inputType: IOLayoutToSchema<VertexIn>;
     $uses(dependencyMap: Record<string, unknown>): this;
 }
 declare function vertexFn<VertexOut extends VertexOutConstrained>(options: {
@@ -1621,6 +1717,12 @@ declare const texelFormatToChannelType: {
     'astc-12x10-unorm-srgb': F32;
     'astc-12x12-unorm': F32;
     'astc-12x12-unorm-srgb': F32;
+    r16snorm: F32;
+    r16unorm: F32;
+    rg16unorm: F32;
+    rg16snorm: F32;
+    rgba16unorm: F32;
+    rgba16snorm: F32;
 };
 type TexelFormatToChannelType = typeof texelFormatToChannelType;
 type TexelFormatToStringChannels = {
@@ -1813,6 +1915,7 @@ type LayoutToAllowedAttribs<T> = T extends {
 } : never;
 
 interface TgpuVertexLayout<TData extends WgslArray | Disarray = WgslArray | Disarray> extends TgpuNamable {
+    readonly [$internal]: true;
     readonly resourceType: 'vertex-layout';
     readonly stride: number;
     readonly stepMode: 'vertex' | 'instance';
@@ -1824,15 +1927,22 @@ declare function vertexLayout<TData extends WgslArray | Disarray>(schemaForCount
 
 interface RenderPipelineInternals {
     readonly core: RenderPipelineCore;
-    readonly priors: TgpuRenderPipelinePriors;
+    readonly priors: TgpuRenderPipelinePriors & TimestampWritesPriors;
+}
+interface HasIndexBuffer {
+    readonly hasIndexBuffer: true;
+    drawIndexed(indexCount: number, instanceCount?: number, firstIndex?: number, baseVertex?: number, firstInstance?: number): void;
 }
-interface TgpuRenderPipeline<Output extends IOLayout = IOLayout> extends TgpuNamable {
+interface TgpuRenderPipeline<Output extends IOLayout = IOLayout> extends TgpuNamable, SelfResolvable, Timeable {
     readonly [$internal]: RenderPipelineInternals;
     readonly resourceType: 'render-pipeline';
-    with<TData extends WgslArray | Disarray>(vertexLayout: TgpuVertexLayout<TData>, buffer: TgpuBuffer<TData> & VertexFlag): TgpuRenderPipeline<IOLayout>;
-    with<Entries extends Record<string, TgpuLayoutEntry | null>>(bindGroupLayout: TgpuBindGroupLayout<Entries>, bindGroup: TgpuBindGroup<Entries>): TgpuRenderPipeline<IOLayout>;
-    withColorAttachment(attachment: FragmentOutToColorAttachment<Output>): TgpuRenderPipeline<IOLayout>;
-    withDepthStencilAttachment(attachment: DepthStencilAttachment): TgpuRenderPipeline<IOLayout>;
+    readonly hasIndexBuffer: boolean;
+    with<TData extends WgslArray | Disarray>(vertexLayout: TgpuVertexLayout<TData>, buffer: TgpuBuffer<TData> & VertexFlag): this;
+    with<Entries extends Record<string, TgpuLayoutEntry | null>>(bindGroupLayout: TgpuBindGroupLayout<Entries>, bindGroup: TgpuBindGroup<Entries>): this;
+    withColorAttachment(attachment: FragmentOutToColorAttachment<Output>): this;
+    withDepthStencilAttachment(attachment: DepthStencilAttachment): this;
+    withIndexBuffer(buffer: TgpuBuffer<AnyWgslData> & IndexFlag, offsetElements?: number, sizeElements?: number): this & HasIndexBuffer;
+    withIndexBuffer(buffer: GPUBuffer, indexFormat: GPUIndexFormat, offsetBytes?: number, sizeBytes?: number): this & HasIndexBuffer;
     draw(vertexCount: number, instanceCount?: number, firstVertex?: number, firstInstance?: number): void;
 }
 type FragmentOutToTargets<T extends IOLayout> = T extends IOData ? GPUColorTargetState : T extends Record<string, unknown> ? {
@@ -1942,7 +2052,9 @@ type RenderPipelineCoreOptions = {
     vertexAttribs: AnyVertexAttribs;
     vertexFn: TgpuVertexFn;
     fragmentFn: TgpuFragmentFn;
-    primitiveState: GPUPrimitiveState | undefined;
+    primitiveState: GPUPrimitiveState | Omit<GPUPrimitiveState, 'stripIndexFormat'> & {
+        stripIndexFormat?: U32 | U16;
+    } | undefined;
     depthStencilState: GPUDepthStencilState | undefined;
     targets: AnyFragmentTargets;
     multisampleState: GPUMultisampleState | undefined;
@@ -1952,19 +2064,27 @@ type TgpuRenderPipelinePriors = {
     readonly bindGroupLayoutMap?: Map<TgpuBindGroupLayout, TgpuBindGroup> | undefined;
     readonly colorAttachment?: AnyFragmentColorAttachment | undefined;
     readonly depthStencilAttachment?: DepthStencilAttachment | undefined;
-};
+    readonly indexBuffer?: {
+        buffer: TgpuBuffer<AnyWgslData> & IndexFlag | GPUBuffer;
+        indexFormat: GPUIndexFormat;
+        offsetBytes?: number | undefined;
+        sizeBytes?: number | undefined;
+    } | undefined;
+} & TimestampWritesPriors;
 type Memo = {
     pipeline: GPURenderPipeline;
-    bindGroupLayouts: TgpuBindGroupLayout[];
-    catchall: [number, TgpuBindGroup] | null;
+    usedBindGroupLayouts: TgpuBindGroupLayout[];
+    catchall: [number, TgpuBindGroup] | undefined;
 };
-declare class RenderPipelineCore {
+declare class RenderPipelineCore implements SelfResolvable {
     readonly options: RenderPipelineCoreOptions;
     readonly usedVertexLayouts: TgpuVertexLayout[];
     private _memo;
     private readonly _vertexBufferLayouts;
     private readonly _targets;
     constructor(options: RenderPipelineCoreOptions);
+    '~resolve'(ctx: ResolutionCtx): string;
+    toString(): string;
     unwrap(): Memo;
 }
 
@@ -2062,8 +2182,12 @@ interface TgpuComparisonSampler {
     readonly [$internal]: SamplerInternals;
     readonly resourceType: 'sampler-comparison';
 }
-declare function sampler(props: SamplerProps): TgpuSampler;
-declare function comparisonSampler(props: ComparisonSamplerProps): TgpuComparisonSampler;
+interface TgpuFixedSampler extends TgpuSampler, TgpuNamable {
+}
+interface TgpuFixedComparisonSampler extends TgpuComparisonSampler, TgpuNamable {
+}
+declare function sampler(props: SamplerProps): TgpuFixedSampler;
+declare function comparisonSampler(props: ComparisonSamplerProps): TgpuFixedComparisonSampler;
 declare function isSampler(resource: unknown): resource is TgpuSampler;
 declare function isComparisonSampler(resource: unknown): resource is TgpuComparisonSampler;
 
@@ -2079,12 +2203,40 @@ interface Unwrapper {
     unwrap(resource: TgpuVertexLayout): GPUVertexBufferLayout;
     unwrap(resource: TgpuSampler): GPUSampler;
     unwrap(resource: TgpuComparisonSampler): GPUSampler;
+    unwrap(resource: TgpuQuerySet<GPUQueryType>): GPUQuerySet;
 }
 
+interface TgpuBufferShorthandBase<TData extends BaseData> extends TgpuNamable {
+    readonly [$internal]: true;
+    write(data: Infer<TData>): void;
+    writePartial(data: InferPartial<TData>): void;
+    read(): Promise<Infer<TData>>;
+}
+interface TgpuMutable<TData extends BaseData> extends TgpuBufferShorthandBase<TData> {
+    readonly resourceType: 'mutable';
+    readonly buffer: TgpuBuffer<TData> & StorageFlag;
+    value: InferGPU<TData>;
+    $: InferGPU<TData>;
+}
+interface TgpuReadonly<TData extends BaseData> extends TgpuBufferShorthandBase<TData> {
+    readonly resourceType: 'readonly';
+    readonly buffer: TgpuBuffer<TData> & StorageFlag;
+    readonly value: InferGPU<TData>;
+    readonly $: InferGPU<TData>;
+}
+interface TgpuUniform<TData extends BaseData> extends TgpuBufferShorthandBase<TData> {
+    readonly resourceType: 'uniform';
+    readonly buffer: TgpuBuffer<TData> & UniformFlag;
+    readonly value: InferGPU<TData>;
+    readonly $: InferGPU<TData>;
+}
+type TgpuBufferShorthand<TData extends BaseData> = TgpuMutable<TData> | TgpuReadonly<TData> | TgpuUniform<TData>;
+declare function isBufferShorthand<TData extends BaseData>(value: unknown | TgpuBufferShorthand<TData>): value is TgpuBufferShorthand<TData>;
+
 interface WithCompute {
     createPipeline(): TgpuComputePipeline;
 }
-type ValidateFragmentIn<VertexOut extends IORecord, FragmentIn extends FragmentInConstrained, FragmentOut extends FragmentOutConstrained> = FragmentIn extends Partial<VertexOut> ? VertexOut extends FragmentIn ? [
+type ValidateFragmentIn<VertexOut extends VertexOutConstrained, FragmentIn extends FragmentInConstrained, FragmentOut extends FragmentOutConstrained> = UndecorateRecord<FragmentIn> extends Partial<UndecorateRecord<VertexOut>> ? UndecorateRecord<VertexOut> extends UndecorateRecord<FragmentIn> ? [
     entryFn: TgpuFragmentFn<FragmentIn, FragmentOut>,
     targets: FragmentOutToTargets<FragmentOut>
 ] : [
@@ -2100,20 +2252,29 @@ type ValidateFragmentIn<VertexOut extends IORecord, FragmentIn extends FragmentI
         [Key in keyof FragmentIn & keyof VertexOut as FragmentIn[Key] extends VertexOut[Key] ? never : Key]: [got: VertexOut[Key], expecting: FragmentIn[Key]];
     }
 ];
-interface WithVertex<VertexOut extends IORecord = IORecord> {
+interface WithVertex<VertexOut extends VertexOutConstrained = VertexOutConstrained> {
     withFragment<FragmentIn extends FragmentInConstrained, FragmentOut extends FragmentOutConstrained>(...args: ValidateFragmentIn<VertexOut, FragmentIn, FragmentOut>): WithFragment<FragmentOut>;
 }
 interface WithFragment<Output extends FragmentOutConstrained = FragmentOutConstrained> {
-    withPrimitive(primitiveState: GPUPrimitiveState | undefined): WithFragment<Output>;
+    withPrimitive(primitiveState: GPUPrimitiveState | Omit<GPUPrimitiveState, 'stripIndexFormat'> & {
+        stripIndexFormat?: U32 | U16;
+    } | undefined): WithFragment<Output>;
     withDepthStencil(depthStencilState: GPUDepthStencilState | undefined): WithFragment<Output>;
     withMultisample(multisampleState: GPUMultisampleState | undefined): WithFragment<Output>;
     createPipeline(): TgpuRenderPipeline<Output>;
 }
+interface Configurable {
+    readonly bindings: [slot: TgpuSlot<unknown>, value: unknown][];
+    with<T>(slot: TgpuSlot<T>, value: Eventual<T>): Configurable;
+    with<T extends AnyWgslData>(accessor: TgpuAccessor<T>, value: TgpuFn<() => T> | TgpuBufferUsage<T> | TgpuBufferShorthand<T> | Infer<T>): Configurable;
+    pipe(transform: (cfg: Configurable) => Configurable): Configurable;
+}
 interface WithBinding {
-    with<T>(slot: TgpuSlot<T>, value: Eventual<T>): WithBinding;
-    with<T extends AnyWgslData>(accessor: TgpuAccessor<T>, value: TgpuFn<[], T> | TgpuBufferUsage<T> | Infer<T>): WithBinding;
     withCompute<ComputeIn extends IORecord<AnyComputeBuiltin>>(entryFn: TgpuComputeFn<ComputeIn>): WithCompute;
     withVertex<VertexIn extends VertexInConstrained, VertexOut extends VertexOutConstrained>(entryFn: TgpuVertexFn<VertexIn, VertexOut>, attribs: LayoutToAllowedAttribs<OmitBuiltins<VertexIn>>): WithVertex<VertexOut>;
+    with<T>(slot: TgpuSlot<T>, value: Eventual<T>): WithBinding;
+    with<T extends AnyWgslData>(accessor: TgpuAccessor<T>, value: TgpuFn<() => T> | TgpuBufferUsage<T> | TgpuBufferShorthand<T> | Infer<T>): WithBinding;
+    pipe(transform: (cfg: Configurable) => Configurable): WithBinding;
 }
 type CreateTextureOptions<TSize, TFormat extends GPUTextureFormat, TMipLevelCount extends number, TSampleCount extends number, TViewFormat extends GPUTextureFormat, TDimension extends GPUTextureDimension> = {
     /**
@@ -2252,6 +2413,14 @@ interface RenderPass {
      */
     drawIndexedIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): undefined;
 }
+type ValidateSchema<TData extends AnyData> = HasNestedType<[
+    TData
+], 'bool'> extends true ? 'Error: Bool is not host-shareable, use U32 or I32 instead' : HasNestedType<[TData], 'u16'> extends true ? TData extends {
+    type: 'array';
+    elementType: {
+        type: 'u16';
+    };
+} ? TData : 'Error: U16 is only usable inside arrays for index buffers' : TData;
 interface TgpuRoot extends Unwrapper {
     /**
      * The GPU device associated with this root.
@@ -2266,7 +2435,7 @@ interface TgpuRoot extends Unwrapper {
      * @param typeSchema The type of data that this buffer will hold.
      * @param initial The initial value of the buffer. (optional)
      */
-    createBuffer<TData extends AnyData>(typeSchema: TData, initial?: Infer<TData> | undefined): TgpuBuffer<TData>;
+    createBuffer<TData extends AnyData>(typeSchema: ValidateSchema<TData>, initial?: Infer<TData> | undefined): TgpuBuffer<TData>;
     /**
      * Allocates memory on the GPU, allows passing data between host and shader.
      *
@@ -2276,7 +2445,72 @@ interface TgpuRoot extends Unwrapper {
      * @param typeSchema The type of data that this buffer will hold.
      * @param gpuBuffer A vanilla WebGPU buffer.
      */
-    createBuffer<TData extends AnyData>(typeSchema: TData, gpuBuffer: GPUBuffer): TgpuBuffer<TData>;
+    createBuffer<TData extends AnyData>(typeSchema: ValidateSchema<TData>, gpuBuffer: GPUBuffer): TgpuBuffer<TData>;
+    /**
+     * Allocates memory on the GPU, allows passing data between host and shader.
+     * Read-only on the GPU, optimized for small data. For a general-purpose buffer,
+     * use {@link TgpuRoot.createBuffer}.
+     *
+     * @param typeSchema The type of data that this buffer will hold.
+     * @param initial The initial value of the buffer. (optional)
+     */
+    createUniform<TData extends AnyWgslData>(typeSchema: TData, initial?: Infer<TData>): TgpuUniform<TData>;
+    /**
+     * Allocates memory on the GPU, allows passing data between host and shader.
+     * Read-only on the GPU, optimized for small data. For a general-purpose buffer,
+     * use {@link TgpuRoot.createBuffer}.
+     *
+     * @param typeSchema The type of data that this buffer will hold.
+     * @param gpuBuffer A vanilla WebGPU buffer.
+     */
+    createUniform<TData extends AnyWgslData>(typeSchema: TData, gpuBuffer: GPUBuffer): TgpuUniform<TData>;
+    /**
+     * Allocates memory on the GPU, allows passing data between host and shader.
+     * Can be mutated in-place on the GPU. For a general-purpose buffer,
+     * use {@link TgpuRoot.createBuffer}.
+     *
+     * @param typeSchema The type of data that this buffer will hold.
+     * @param initial The initial value of the buffer. (optional)
+     */
+    createMutable<TData extends AnyWgslData>(typeSchema: TData, initial?: Infer<TData>): TgpuMutable<TData>;
+    /**
+     * Allocates memory on the GPU, allows passing data between host and shader.
+     * Can be mutated in-place on the GPU. For a general-purpose buffer,
+     * use {@link TgpuRoot.createBuffer}.
+     *
+     * @param typeSchema The type of data that this buffer will hold.
+     * @param gpuBuffer A vanilla WebGPU buffer.
+     */
+    createMutable<TData extends AnyWgslData>(typeSchema: TData, gpuBuffer: GPUBuffer): TgpuMutable<TData>;
+    /**
+     * Allocates memory on the GPU, allows passing data between host and shader.
+     * Read-only on the GPU, optimized for large data. For a general-purpose buffer,
+     * use {@link TgpuRoot.createBuffer}.
+     *
+     * @param typeSchema The type of data that this buffer will hold.
+     * @param initial The initial value of the buffer. (optional)
+     */
+    createReadonly<TData extends AnyWgslData>(typeSchema: TData, initial?: Infer<TData>): TgpuReadonly<TData>;
+    /**
+     * Allocates memory on the GPU, allows passing data between host and shader.
+     * Read-only on the GPU, optimized for large data. For a general-purpose buffer,
+     * use {@link TgpuRoot.createBuffer}.
+     *
+     * @param typeSchema The type of data that this buffer will hold.
+     * @param gpuBuffer A vanilla WebGPU buffer.
+     */
+    createReadonly<TData extends AnyWgslData>(typeSchema: TData, gpuBuffer: GPUBuffer): TgpuReadonly<TData>;
+    /**
+     * Creates a query set for collecting timestamps or occlusion queries.
+     *
+     * @remarks
+     * Typed wrapper around a GPUQuerySet.
+     *
+     * @param type The type of queries to collect ('occlusion' or 'timestamp').
+     * @param count The number of queries in the set.
+     * @param rawQuerySet An optional pre-existing GPUQuerySet to use instead of creating a new one.
+     */
+    createQuerySet<T extends GPUQueryType>(type: T, count: number, rawQuerySet?: GPUQuerySet | undefined): TgpuQuerySet<T>;
     /**
      * Creates a group of resources that can be bound to a shader based on a specified layout.
      *
@@ -2301,9 +2535,12 @@ interface TgpuRoot extends Unwrapper {
      * @param entries A record with values being the resources populating the bind group
      * and keys being their associated names, matching the layout keys.
      */
-    createBindGroup<Entries extends Record<string, TgpuLayoutEntry | null> = Record<string, TgpuLayoutEntry | null>>(layout: TgpuBindGroupLayout<Entries>, entries: {
-        [K in keyof OmitProps<Entries, null>]: LayoutEntryToInput<Entries[K]>;
-    }): TgpuBindGroup<Entries>;
+    createBindGroup<Entries extends Record<string, TgpuLayoutEntry | null> = Record<string, TgpuLayoutEntry | null>>(layout: TgpuBindGroupLayout<Entries>, entries: ExtractBindGroupInputFromLayout<Entries>): TgpuBindGroup<Entries>;
+    /**
+     * Retrieves a read-only list of all enabled features of the GPU device.
+     * @returns A set of strings representing the enabled features.
+     */
+    get enabledFeatures(): ReadonlySet<GPUFeatureName>;
     /**
      * Destroys all underlying resources (i.e. buffers...) created through this root object.
      * If the object is created via `tgpu.init` instead of `tgpu.initFromDevice`,
@@ -2313,16 +2550,12 @@ interface TgpuRoot extends Unwrapper {
     '~unstable': Omit<ExperimentalTgpuRoot, keyof TgpuRoot>;
 }
 interface ExperimentalTgpuRoot extends TgpuRoot, WithBinding {
-    readonly jitTranspiler?: JitTranspiler | undefined;
     readonly nameRegistry: NameRegistry;
     /**
      * The current command encoder. This property will
      * hold the same value until `flush()` is called.
      */
     readonly commandEncoder: GPUCommandEncoder;
-    createUniform<TData extends AnyWgslData>(typeSchema: TData, initialOrBuffer?: Infer<TData> | GPUBuffer): TgpuBufferUniform<TData> & TgpuFixedBufferUsage<TData>;
-    createMutable<TData extends AnyWgslData>(typeSchema: TData, initialOrBuffer?: Infer<TData> | GPUBuffer): TgpuBufferMutable<TData> & TgpuFixedBufferUsage<TData>;
-    createReadonly<TData extends AnyWgslData>(typeSchema: TData, initialOrBuffer?: Infer<TData> | GPUBuffer): TgpuBufferReadonly<TData> & TgpuFixedBufferUsage<TData>;
     createTexture<TWidth extends number, THeight extends number, TDepth extends number, TSize extends readonly [TWidth] | readonly [TWidth, THeight] | readonly [TWidth, THeight, TDepth], TFormat extends GPUTextureFormat, TMipLevelCount extends number, TSampleCount extends number, TViewFormat extends GPUTextureFormat, TDimension extends GPUTextureDimension>(props: CreateTextureOptions<TSize, TFormat, TMipLevelCount, TSampleCount, TViewFormat, TDimension>): TgpuTexture<CreateTextureResult<TSize, TFormat, TMipLevelCount, TSampleCount, TViewFormat, TDimension>>;
     beginRenderPass(descriptor: GPURenderPassDescriptor, callback: (pass: RenderPass) => void): void;
     /**
@@ -2342,18 +2575,28 @@ type Uniform = UniformFlag;
 interface VertexFlag {
     usableAsVertex: true;
 }
+interface IndexFlag {
+    usableAsIndex: true;
+}
 /**
  * @deprecated Use VertexFlag instead.
  */
 type Vertex = VertexFlag;
-type LiteralToUsageType<T extends 'uniform' | 'storage' | 'vertex'> = T extends 'uniform' ? UniformFlag : T extends 'storage' ? StorageFlag : T extends 'vertex' ? VertexFlag : never;
+type LiteralToUsageType<T extends 'uniform' | 'storage' | 'vertex' | 'index'> = T extends 'uniform' ? UniformFlag : T extends 'storage' ? StorageFlag : T extends 'vertex' ? VertexFlag : T extends 'index' ? IndexFlag : never;
 type ViewUsages<TBuffer extends TgpuBuffer<BaseData>> = (boolean extends TBuffer['usableAsUniform'] ? never : 'uniform') | (boolean extends TBuffer['usableAsStorage'] ? never : 'readonly' | 'mutable');
 type UsageTypeToBufferUsage<TData extends BaseData> = {
     uniform: TgpuBufferUniform<TData> & TgpuFixedBufferUsage<TData>;
     mutable: TgpuBufferMutable<TData> & TgpuFixedBufferUsage<TData>;
     readonly: TgpuBufferReadonly<TData> & TgpuFixedBufferUsage<TData>;
 };
+type IsIndexCompatible<TData extends BaseData> = UnwrapDecorated<TData> extends {
+    readonly type: 'array';
+    readonly elementType: infer TElement;
+} ? TElement extends BaseData ? UnwrapDecorated<TElement> extends {
+    readonly type: 'u32' | 'u16';
+} ? true : false : false : false;
 interface TgpuBuffer<TData extends BaseData> extends TgpuNamable {
+    readonly [$internal]: true;
     readonly resourceType: 'buffer';
     readonly dataType: TData;
     readonly initial?: Infer<TData> | undefined;
@@ -2362,7 +2605,8 @@ interface TgpuBuffer<TData extends BaseData> extends TgpuNamable {
     usableAsUniform: boolean;
     usableAsStorage: boolean;
     usableAsVertex: boolean;
-    $usage<T extends RestrictVertexUsages<TData>>(...usages: T): this & UnionToIntersection<LiteralToUsageType<T[number]>>;
+    usableAsIndex: boolean;
+    $usage<T extends RestrictUsages<TData>>(...usages: T): this & UnionToIntersection<LiteralToUsageType<T[number]>>;
     $addFlags(flags: GPUBufferUsageFlags): this;
     as<T extends ViewUsages<this>>(usage: T): UsageTypeToBufferUsage<TData>[T];
     compileWriter(): void;
@@ -2374,9 +2618,16 @@ interface TgpuBuffer<TData extends BaseData> extends TgpuNamable {
 }
 declare function isBuffer<T extends TgpuBuffer<AnyData>>(value: T | unknown): value is T;
 declare function isUsableAsVertex<T extends TgpuBuffer<AnyData>>(buffer: T): buffer is T & VertexFlag;
-type RestrictVertexUsages<TData extends BaseData> = TData extends {
+type IsArrayOfU32<TData extends BaseData> = UnwrapDecorated<TData> extends {
+    readonly type: 'array';
+    readonly elementType: infer TElement;
+} ? TElement extends BaseData ? UnwrapDecorated<TElement> extends {
+    readonly type: 'u32';
+} ? true : false : false : false;
+type IsWgslLiteral<TData extends BaseData> = TData extends {
     readonly type: WgslTypeLiteral;
-} ? ('uniform' | 'storage' | 'vertex')[] : 'vertex'[];
+} ? true : false;
+type RestrictUsages<TData extends BaseData> = string extends TData['type'] ? ('uniform' | 'storage' | 'vertex' | 'index')[] : IsIndexCompatible<TData> extends true ? IsArrayOfU32<TData> extends true ? ('uniform' | 'storage' | 'vertex' | 'index')[] : ['index'] : IsWgslLiteral<TData> extends true ? ('uniform' | 'storage' | 'vertex')[] : ['vertex'];
 
 type TgpuLayoutEntryBase = {
     /**
@@ -2436,6 +2687,7 @@ type TgpuLayoutEntry = TgpuLayoutUniform | TgpuLayoutStorage | TgpuLayoutSampler
 type UnwrapRuntimeConstructorInner<T extends BaseData | ((_: number) => BaseData)> = T extends (_: number) => BaseData ? ReturnType<T> : T;
 type UnwrapRuntimeConstructor<T extends AnyData | ((_: number) => AnyData)> = T extends unknown ? UnwrapRuntimeConstructorInner<T> : never;
 interface TgpuBindGroupLayout<Entries extends Record<string, TgpuLayoutEntry | null> = Record<string, TgpuLayoutEntry | null>> extends TgpuNamable {
+    readonly [$internal]: true;
     readonly resourceType: 'bind-group-layout';
     readonly entries: Entries;
     readonly bound: {
@@ -2491,12 +2743,12 @@ type GetStorageTextureRestriction<T extends TgpuLayoutStorageTexture> = Default<
     format: T['storageTexture'];
     dimension: Dimension;
 } : never;
-type LayoutEntryToInput<T extends TgpuLayoutEntry | null> = T extends TgpuLayoutUniform ? (TgpuBuffer<UnwrapRuntimeConstructor<T['uniform']>> & UniformFlag) | GPUBuffer : T extends TgpuLayoutStorage ? (TgpuBuffer<UnwrapRuntimeConstructor<T['storage']>> & StorageFlag) | GPUBuffer : T extends TgpuLayoutSampler ? TgpuSampler | GPUSampler : T extends TgpuLayoutComparisonSampler ? TgpuComparisonSampler | GPUSampler : T extends TgpuLayoutTexture ? GPUTextureView | (Sampled & TgpuTexture<Prettify<TextureProps & GetTextureRestriction<T>>>) | TgpuSampledTexture<Default<T['viewDimension'], '2d'>, ChannelFormatToSchema[T['texture']]> : T extends TgpuLayoutStorageTexture ? GPUTextureView | (StorageFlag & TgpuTexture<Prettify<TextureProps & GetStorageTextureRestriction<T>>>) | StorageTextureUsageForEntry<T> : T extends TgpuLayoutExternalTexture ? GPUExternalTexture : never;
+type LayoutEntryToInput<T extends TgpuLayoutEntry | null> = TgpuLayoutEntry | null extends T ? TgpuBuffer<AnyWgslData> | GPUBuffer | TgpuSampler | GPUSampler | TgpuComparisonSampler | GPUSampler | TgpuTexture | TgpuSampledTexture | TgpuMutableTexture | TgpuReadonlyTexture | TgpuWriteonlyTexture | GPUTextureView | GPUExternalTexture : T extends TgpuLayoutUniform ? (TgpuBuffer<MemIdentity<UnwrapRuntimeConstructor<T['uniform']>>> & UniformFlag) | GPUBuffer : T extends TgpuLayoutStorage ? (TgpuBuffer<MemIdentity<UnwrapRuntimeConstructor<T['storage']>>> & StorageFlag) | GPUBuffer : T extends TgpuLayoutSampler ? TgpuSampler | GPUSampler : T extends TgpuLayoutComparisonSampler ? TgpuComparisonSampler | GPUSampler : T extends TgpuLayoutTexture ? GPUTextureView | (Sampled & TgpuTexture<Prettify<TextureProps & GetTextureRestriction<T>>>) | TgpuSampledTexture<Default<T['viewDimension'], '2d'>, ChannelFormatToSchema[T['texture']]> : T extends TgpuLayoutStorageTexture ? GPUTextureView | (StorageFlag & TgpuTexture<Prettify<TextureProps & GetStorageTextureRestriction<T>>>) | StorageTextureUsageForEntry<T> : T extends TgpuLayoutExternalTexture ? GPUExternalTexture : never;
 type BindLayoutEntry<T extends TgpuLayoutEntry | null> = T extends TgpuLayoutUniform ? TgpuBufferUniform<T['uniform']> : T extends TgpuLayoutStorage ? StorageUsageForEntry<T> : T extends TgpuLayoutSampler ? TgpuSampler : T extends TgpuLayoutComparisonSampler ? TgpuComparisonSampler : T extends TgpuLayoutTexture ? TgpuSampledTexture<Default<T['viewDimension'], '2d'>, ChannelFormatToSchema[T['texture']]> : T extends TgpuLayoutStorageTexture ? StorageTextureUsageForEntry<T> : never;
 type InferLayoutEntry<T extends TgpuLayoutEntry | null> = T extends TgpuLayoutUniform ? Infer<T['uniform']> : T extends TgpuLayoutStorage ? Infer<UnwrapRuntimeConstructor<T['storage']>> : T extends TgpuLayoutSampler ? TgpuSampler : T extends TgpuLayoutComparisonSampler ? TgpuComparisonSampler : T extends TgpuLayoutTexture ? TgpuSampledTexture<Default<T['viewDimension'], '2d'>, ChannelFormatToSchema[T['texture']]> : T extends TgpuLayoutStorageTexture ? StorageTextureUsageForEntry<T> : never;
-type ExtractBindGroupInputFromLayout<T extends Record<string, TgpuLayoutEntry | null>> = {
+type ExtractBindGroupInputFromLayout<T extends Record<string, TgpuLayoutEntry | null>> = NullableToOptional<{
     [K in keyof T]: LayoutEntryToInput<T[K]>;
-};
+}>;
 type TgpuBindGroup<Entries extends Record<string, TgpuLayoutEntry | null> = Record<string, TgpuLayoutEntry | null>> = {
     readonly resourceType: 'bind-group';
     readonly layout: TgpuBindGroupLayout<Entries>;
@@ -2509,19 +2761,21 @@ interface TgpuBufferUsage<TData extends BaseData = BaseData, TUsage extends Bind
     readonly usage: TUsage;
     readonly [$repr]: Infer<TData>;
     value: InferGPU<TData>;
+    $: InferGPU<TData>;
     readonly [$internal]: {
         readonly dataType: TData;
     };
 }
 interface TgpuBufferUniform<TData extends BaseData> extends TgpuBufferUsage<TData, 'uniform'> {
     readonly value: InferGPU<TData>;
+    readonly $: InferGPU<TData>;
 }
 interface TgpuBufferReadonly<TData extends BaseData> extends TgpuBufferUsage<TData, 'readonly'> {
     readonly value: InferGPU<TData>;
+    readonly $: InferGPU<TData>;
 }
 interface TgpuFixedBufferUsage<TData extends BaseData> extends TgpuNamable {
     readonly buffer: TgpuBuffer<TData>;
-    write(data: Infer<TData>): void;
 }
 interface TgpuBufferMutable<TData extends BaseData> extends TgpuBufferUsage<TData, 'mutable'> {
 }
@@ -2565,7 +2819,7 @@ declare function privateVar<TDataType extends AnyData>(dataType: TDataType, init
  */
 declare function workgroupVar<TDataType extends AnyData>(dataType: TDataType): TgpuVar<'workgroup', TDataType>;
 
-type ResolvableObject = SelfResolvable | TgpuBufferUsage | TgpuConst | TgpuDeclare | TgpuFn | TgpuComputeFn | TgpuFragmentFn | TgpuComputePipeline | TgpuRenderPipeline | TgpuVertexFn | TgpuSampler | TgpuAccessor | TgpuExternalTexture | TgpuTexture | TgpuAnyTextureView | TgpuVar | AnyVecInstance | AnyMatInstance | AnyData | TgpuFn<any, any>;
+type ResolvableObject = SelfResolvable | TgpuBufferUsage | TgpuConst | TgpuDeclare | TgpuFn | TgpuComputeFn | TgpuFragmentFn | TgpuComputePipeline | TgpuRenderPipeline | TgpuVertexFn | TgpuSampler | TgpuAccessor | TgpuExternalTexture | TgpuTexture | TgpuAnyTextureView | TgpuVar | AnyVecInstance | AnyMatInstance | AnyData | TgpuFn;
 type Wgsl = Eventual<string | number | boolean | ResolvableObject>;
 type TgpuShaderStage = 'compute' | 'vertex' | 'fragment';
 interface FnToWgslOptions {
@@ -2624,15 +2878,12 @@ interface ResolutionCtx {
     unwrap<T>(eventual: Eventual<T>): T;
     resolve(item: unknown): string;
     resolveValue<T extends BaseData>(value: Infer<T> | InferGPU<T>, schema: T): string;
-    transpileFn(fn: string): {
-        params: FuncParameter[];
-        body: Block;
-        externalNames: string[];
-    };
     fnToWgsl(options: FnToWgslOptions): {
         head: Wgsl;
         body: Wgsl;
     };
+    withVaryingLocations<T>(locations: Record<string, number>, callback: () => T): T;
+    get varyingLocations(): Record<string, number> | undefined;
     [$internal]: {
         itemStateStack: ItemStateStack;
     };
@@ -2804,7 +3055,7 @@ interface Disarray<TElement extends BaseData = BaseData> {
     readonly elementCount: number;
     readonly elementType: TElement;
     readonly [$repr]: Infer<TElement>[];
-    readonly '~reprPartial': {
+    readonly [$reprPartial]: {
         idx: number;
         value: InferPartial<TElement>;
     }[] | undefined;
@@ -2823,9 +3074,9 @@ interface Unstruct<TProps extends Record<string, BaseData> = Record<string, Base
     readonly type: 'unstruct';
     readonly propTypes: TProps;
     readonly [$repr]: Prettify<InferRecord<TProps>>;
-    readonly '~gpuRepr': Prettify<InferGPURecord<TProps>>;
-    readonly '~memIdent': Unstruct<Prettify<MemIdentityRecord<TProps>>>;
-    readonly '~reprPartial': Prettify<Partial<InferPartialRecord<TProps>>> | undefined;
+    readonly [$gpuRepr]: Prettify<InferGPURecord<TProps>>;
+    readonly [$memIdent]: Unstruct<Prettify<MemIdentityRecord<TProps>>>;
+    readonly [$reprPartial]: Prettify<Partial<InferPartialRecord<TProps>>> | undefined;
 }
 type AnyUnstruct = Unstruct<any>;
 interface LooseDecorated<TInner extends BaseData = BaseData, TAttribs extends unknown[] = unknown[]> {
@@ -2878,6 +3129,25 @@ interface Snippet {
     readonly value: unknown;
     readonly dataType: AnyData | UnknownData;
 }
+type UnwrapDecorated<TData extends BaseData> = TData extends {
+    readonly type: 'decorated';
+    readonly inner: infer TInner;
+} ? TInner extends BaseData ? UnwrapDecorated<TInner> : TData : TData;
+type HasNestedType<TData extends [BaseData], TType extends string> = UnwrapDecorated<TData[0]> extends {
+    readonly type: TType;
+} ? true : UnwrapDecorated<TData[0]> extends {
+    readonly type: 'array';
+    readonly elementType: infer TElement;
+} ? TElement extends BaseData ? UnwrapDecorated<TElement> extends {
+    readonly type: TType;
+} ? true : HasNestedType<[TElement], TType> : false : UnwrapDecorated<TData[0]> extends {
+    readonly type: 'struct';
+    readonly propTypes: infer TProps;
+} ? TProps extends Record<string, BaseData> ? true extends {
+    [K in keyof TProps]: UnwrapDecorated<TProps[K]> extends {
+        readonly type: TType;
+    } ? true : HasNestedType<[TProps[K]], TType>;
+}[keyof TProps] ? true : false : false : false;
 
 declare const builtinNames: readonly ["vertex_index", "instance_index", "position", "clip_distances", "front_facing", "frag_depth", "sample_index", "sample_mask", "fragment", "local_invocation_id", "local_invocation_index", "global_invocation_id", "workgroup_id", "num_workgroups", "subgroup_invocation_id", "subgroup_size"];
 type BuiltinName = (typeof builtinNames)[number];
@@ -2888,6 +3158,9 @@ type ExtractAttributes<T> = T extends {
 type Undecorate<T> = T extends {
     readonly inner: infer TInner;
 } ? TInner : T;
+type UndecorateRecord<T extends Record<string, unknown>> = {
+    [Key in keyof T]: Undecorate<T[Key]>;
+};
 /**
  * Decorates a data-type `TData` with an attribute `TAttrib`.
  *
@@ -2983,25 +3256,26 @@ declare function interpolate<TInterpolation extends PerspectiveOrLinearInterpola
 declare function interpolate<TInterpolation extends FlatInterpolationType, TData extends FlatInterpolatableData>(interpolationType: TInterpolation, data: TData): Decorate<TData, Interpolate<TInterpolation>>;
 declare function isBuiltin<T extends Decorated<AnyWgslData, AnyAttribute[]> | LooseDecorated<AnyLooseData, AnyAttribute[]>>(value: T | unknown): value is T;
 
-/**
- * Information extracted from transpiling a JS function.
- */
-type TranspilationResult = {
-    params: tinyest.FuncParameter[];
-    body: tinyest.Block;
-    /**
-     * All identifiers found in the function code that are not declared in the
-     * function itself, or in the block that is accessing that identifier.
-     */
-    externalNames: string[];
-};
+type AnyFn = (...args: never[]) => unknown;
 type InferArgs<T extends unknown[]> = {
     [Idx in keyof T]: Infer<T[Idx]>;
 };
-type InferReturn<T> = T extends undefined ? void : Infer<T>;
-type JsImplementation<Args extends unknown[] | Record<string, unknown> = unknown[] | Record<string, unknown>, Return = unknown> = (...args: Args extends unknown[] ? InferArgs<Args> : Args extends Record<string, never> ? [] : [InferIO<Args>]) => InferReturn<Return>;
-type Implementation<Args extends unknown[] | Record<string, unknown> = unknown[] | Record<string, unknown>, Return = unknown> = string | JsImplementation<Args, Return>;
-type BaseIOData = F32 | F16 | I32 | U32 | Vec2f | Vec3f | Vec4f | Vec2h | Vec3h | Vec4h | Vec2i | Vec3i | Vec4i | Vec2u | Vec3u | Vec4u;
+type InheritTupleValues<T, From> = {
+    [K in keyof T]: K extends keyof From ? From[K] : never;
+};
+/**
+ * Returns a type that has arg and return types of `T`, but argument
+ * names of `From`
+ *
+ * Wrapped in an object type with `result` prop just so that it's easier
+ * to remove InheritArgNames<...> from Intellisense with Prettify<T>['result']
+ */
+type InheritArgNames<T extends AnyFn, From extends AnyFn> = {
+    result: (...args: Parameters<((...args: InheritTupleValues<Parameters<From>, Parameters<T>>) => ReturnType<T>) & T>) => ReturnType<T>;
+};
+type InferImplSchema<ImplSchema extends AnyFn> = (...args: InferArgs<Parameters<ImplSchema>>) => Infer<ReturnType<ImplSchema>>;
+type Implementation<ImplSchema extends AnyFn = AnyFn> = string | InferImplSchema<ImplSchema>;
+type BaseIOData = Bool | F32 | F16 | I32 | U32 | Vec2f | Vec3f | Vec4f | Vec2h | Vec3h | Vec4h | Vec2i | Vec3i | Vec4i | Vec2u | Vec3u | Vec4u;
 type IOData = BaseIOData | Decorated<BaseIOData, AnyAttribute[]> | BuiltinClipDistances;
 type IORecord<TElementType extends IOData = IOData> = Record<string, TElementType>;
 /**
@@ -3049,6 +3323,7 @@ type TgpuComputeFnShell<ComputeIn extends IORecord<AnyComputeBuiltin>> = TgpuCom
      */ ((implementation: string) => TgpuComputeFn<ComputeIn>);
 };
 interface TgpuComputeFn<ComputeIn extends IORecord<AnyComputeBuiltin> = any> extends TgpuNamable {
+    readonly [$internal]: true;
     readonly shell: TgpuComputeFnShellHeader<ComputeIn>;
     $uses(dependencyMap: Record<string, unknown>): this;
 }
@@ -3060,4 +3335,4 @@ declare function computeFn<ComputeIn extends IORecord<AnyComputeBuiltin>>(option
     workgroupSize: number[];
 }): TgpuComputeFnShell<ComputeIn>;
 
-export { type TgpuRenderPipeline as $, type AnyWgslData as A, isComparisonSampler as B, isSampler as C, type Disarray as D, isSampledTextureView as E, isStorageTextureView as F, isTexture as G, isUsableAsRender as H, type Infer as I, type JitTranspiler as J, isUsableAsSampled as K, isUsableAsStorage as L, asMutable as M, asReadonly as N, asUniform as O, isUsableAsUniform as P, isTgpuFn as Q, RandomNameRegistry as R, StrictNameRegistry as S, type TgpuRoot as T, type WithBinding as U, type WithCompute as V, type Wgsl as W, type WithFragment as X, type WithVertex as Y, type Storage as Z, type StorageFlag as _, type TgpuFn as a, type Vec4u as a$, type TgpuComputePipeline as a0, type Uniform as a1, type UniformFlag as a2, type Vertex as a3, type VertexFlag as a4, type TgpuBufferMutable as a5, type TgpuBufferReadonly as a6, type TgpuBufferUniform as a7, type Eventual as a8, type TgpuAnyTextureView as a9, type TgpuVertexFnShell as aA, type TgpuFragmentFn as aB, type TgpuFragmentFnShell as aC, type TgpuComputeFn as aD, type TgpuComputeFnShell as aE, type TgpuDeclare as aF, type Bool as aG, type F16 as aH, type F32 as aI, type I32 as aJ, type U32 as aK, type WgslStruct as aL, type Ptr as aM, type Vec2b as aN, type Vec2f as aO, type Vec2h as aP, type Vec2i as aQ, type Vec2u as aR, type Vec3b as aS, type Vec3f as aT, type Vec3h as aU, type Vec3i as aV, type Vec3u as aW, type Vec4b as aX, type Vec4f as aY, type Vec4h as aZ, type Vec4i as a_, type TgpuMutableTexture as aa, type TgpuReadonlyTexture as ab, type TgpuSampledTexture as ac, type TgpuTexture as ad, type TgpuWriteonlyTexture as ae, type TextureProps as af, type Render as ag, type Sampled as ah, type TgpuConst as ai, type TgpuVar as aj, type VariableScope as ak, type TgpuSampler as al, type BindLayoutEntry as am, type ExtractBindGroupInputFromLayout as an, type LayoutEntryToInput as ao, type TgpuBindGroup as ap, type TgpuLayoutComparisonSampler as aq, type TgpuLayoutEntry as ar, type TgpuLayoutExternalTexture as as, type TgpuLayoutSampler as at, type TgpuLayoutStorage as au, type TgpuLayoutStorageTexture as av, type TgpuLayoutTexture as aw, type TgpuLayoutUniform as ax, type TgpuFnShell as ay, type TgpuVertexFn as az, type TgpuBufferUsage as b, type BuiltinLocalInvocationId as b$, type BaseData as b0, type Unstruct as b1, type Mat2x2f as b2, type Mat3x3f as b3, type Mat4x4f as b4, type m2x2f as b5, type m3x3f as b6, type m4x4f as b7, type Atomic as b8, isAlignAttrib as b9, type v3u as bA, type v4b as bB, type v4f as bC, type v4i as bD, type v4u as bE, type AnyLooseData as bF, type LooseDecorated as bG, align as bH, type AnyAttribute as bI, type HasCustomLocation as bJ, interpolate as bK, type IsBuiltin as bL, isBuiltin as bM, location as bN, size as bO, isData as bP, isDisarray as bQ, isLooseData as bR, isLooseDecorated as bS, isUnstruct as bT, builtin as bU, type AnyBuiltin as bV, type BuiltinClipDistances as bW, type BuiltinFragDepth as bX, type BuiltinFrontFacing as bY, type BuiltinGlobalInvocationId as bZ, type BuiltinInstanceIndex as b_, isAtomic as ba, isBuiltinAttrib as bb, isDecorated as bc, isInterpolateAttrib as bd, isLocationAttrib as be, isPtr as bf, isSizeAttrib as bg, isWgslArray as bh, isWgslData as bi, isWgslStruct as bj, Void as bk, type Align as bl, type AnyVecInstance as bm, type AnyWgslStruct as bn, type Builtin as bo, type Decorated as bp, type Interpolate as bq, type Location as br, type Size as bs, type v2b as bt, type v2f as bu, type v2i as bv, type v2u as bw, type v3b as bx, type v3f as by, type v3i as bz, type TgpuAccessor as c, type v4h as c$, type BuiltinLocalInvocationIndex as c0, type BuiltinNumWorkgroups as c1, type BuiltinPosition as c2, type BuiltinSampleIndex as c3, type BuiltinSampleMask as c4, type BuiltinVertexIndex as c5, type BuiltinWorkgroupId as c6, type InferGPU as c7, type InferPartial as c8, type FormatToWGSLType as c9, snorm16x4 as cA, float16 as cB, float16x2 as cC, float16x4 as cD, float32 as cE, float32x2 as cF, float32x3 as cG, float32x4 as cH, uint32 as cI, uint32x2 as cJ, uint32x3 as cK, uint32x4 as cL, sint32 as cM, sint32x2 as cN, sint32x3 as cO, sint32x4 as cP, unorm10_10_10_2 as cQ, unorm8x4_bgra as cR, type PackedData as cS, type TgpuDualFn as cT, type AnyNumericVecInstance as cU, type AnyMatInstance as cV, type vBaseForMat as cW, type mBaseForVec as cX, type AnyFloatVecInstance as cY, type v3h as cZ, type v2h as c_, type TgpuVertexFormatData as ca, formatToWGSLType as cb, packedFormats as cc, uint8 as cd, uint8x2 as ce, uint8x4 as cf, sint8 as cg, sint8x2 as ch, sint8x4 as ci, unorm8 as cj, unorm8x2 as ck, unorm8x4 as cl, snorm8 as cm, snorm8x2 as cn, snorm8x4 as co, uint16 as cp, uint16x2 as cq, uint16x4 as cr, sint16 as cs, sint16x2 as ct, sint16x4 as cu, unorm16 as cv, unorm16x2 as cw, unorm16x4 as cx, snorm16 as cy, snorm16x2 as cz, type TgpuDerived as d, type AnyVec2Instance as d0, type AnyVec3Instance as d1, type AnyBooleanVecInstance as d2, type atomicI32 as d3, type atomicU32 as d4, type TgpuStorageTexture as d5, type TexelData as d6, type ChannelData as d7, type TgpuSlot as e, type TgpuBindGroupLayout as f, type TgpuVertexLayout as g, type WgslArray as h, type TgpuBuffer as i, type AnyData as j, bindGroupLayout as k, fn as l, fragmentFn as m, vertexFn as n, computeFn as o, privateVar as p, constant as q, declare as r, sampler as s, comparisonSampler as t, isBuffer as u, vertexLayout as v, workgroupVar as w, isUsableAsVertex as x, isDerived as y, isSlot as z };
+export { type Storage as $, type AnyWgslData as A, isSlot as B, isComparisonSampler as C, type Disarray as D, isSampler as E, isSampledTextureView as F, isStorageTextureView as G, isTexture as H, type Infer as I, isUsableAsRender as J, isUsableAsSampled as K, isUsableAsStorage as L, asMutable as M, asReadonly as N, asUniform as O, isUsableAsUniform as P, isBufferShorthand as Q, RandomNameRegistry as R, StrictNameRegistry as S, type TgpuBindGroupLayout as T, isTgpuFn as U, type Configurable as V, type Wgsl as W, type WithBinding as X, type WithCompute as Y, type WithFragment as Z, type WithVertex as _, type TgpuBindGroup as a, type Vec3h as a$, type StorageFlag as a0, type TgpuRenderPipeline as a1, type TgpuComputePipeline as a2, type IndexFlag as a3, type Uniform as a4, type UniformFlag as a5, type Vertex as a6, type VertexFlag as a7, type TgpuBufferMutable as a8, type TgpuBufferReadonly as a9, type TgpuLayoutStorageTexture as aA, type TgpuLayoutTexture as aB, type TgpuLayoutUniform as aC, type TgpuFnShell as aD, type TgpuVertexFn as aE, type TgpuVertexFnShell as aF, type TgpuFragmentFn as aG, type TgpuFragmentFnShell as aH, type TgpuComputeFn as aI, type TgpuComputeFnShell as aJ, type TgpuDeclare as aK, type INTERNAL_GlobalExt as aL, type Bool as aM, type F16 as aN, type F32 as aO, type I32 as aP, type U16 as aQ, type U32 as aR, type WgslStruct as aS, type Ptr as aT, type Vec2b as aU, type Vec2f as aV, type Vec2h as aW, type Vec2i as aX, type Vec2u as aY, type Vec3b as aZ, type Vec3f as a_, type TgpuBufferUniform as aa, type TgpuMutable as ab, type TgpuReadonly as ac, type TgpuUniform as ad, type Eventual as ae, type TgpuAnyTextureView as af, type TgpuMutableTexture as ag, type TgpuReadonlyTexture as ah, type TgpuSampledTexture as ai, type TgpuTexture as aj, type TgpuWriteonlyTexture as ak, type TextureProps as al, type Render as am, type Sampled as an, type TgpuConst as ao, type TgpuVar as ap, type VariableScope as aq, type TgpuSampler as ar, type BindLayoutEntry as as, type ExtractBindGroupInputFromLayout as at, type LayoutEntryToInput as au, type TgpuLayoutComparisonSampler as av, type TgpuLayoutEntry as aw, type TgpuLayoutExternalTexture as ax, type TgpuLayoutSampler as ay, type TgpuLayoutStorage as az, type TgpuRoot as b, builtin as b$, type Vec3i as b0, type Vec3u as b1, type Vec4b as b2, type Vec4f as b3, type Vec4h as b4, type Vec4i as b5, type Vec4u as b6, type BaseData as b7, type Unstruct as b8, type Atomic as b9, type v2b as bA, type v2f as bB, type v2i as bC, type v2u as bD, type v3b as bE, type v3f as bF, type v3i as bG, type v3u as bH, type v4b as bI, type v4f as bJ, type v4i as bK, type v4u as bL, type AnyLooseData as bM, type LooseDecorated as bN, align as bO, type AnyAttribute as bP, type HasCustomLocation as bQ, interpolate as bR, type IsBuiltin as bS, isBuiltin as bT, location as bU, size as bV, isData as bW, isDisarray as bX, isLooseData as bY, isLooseDecorated as bZ, isUnstruct as b_, isAlignAttrib as ba, isAtomic as bb, isBuiltinAttrib as bc, isDecorated as bd, isInterpolateAttrib as be, isLocationAttrib as bf, isPtr as bg, isSizeAttrib as bh, isWgslArray as bi, isWgslData as bj, isWgslStruct as bk, Void as bl, type Align as bm, type AnyVecInstance as bn, type AnyWgslStruct as bo, type Builtin as bp, type Decorated as bq, type Interpolate as br, type Location as bs, type m2x2f as bt, type m3x3f as bu, type m4x4f as bv, type Mat2x2f as bw, type Mat3x3f as bx, type Mat4x4f as by, type Size as bz, type TgpuFn as c, type AnyNumericVecInstance as c$, type AnyBuiltin as c0, type BuiltinClipDistances as c1, type BuiltinFragDepth as c2, type BuiltinFrontFacing as c3, type BuiltinGlobalInvocationId as c4, type BuiltinInstanceIndex as c5, type BuiltinLocalInvocationId as c6, type BuiltinLocalInvocationIndex as c7, type BuiltinNumWorkgroups as c8, type BuiltinPosition as c9, sint16x2 as cA, sint16x4 as cB, unorm16 as cC, unorm16x2 as cD, unorm16x4 as cE, snorm16 as cF, snorm16x2 as cG, snorm16x4 as cH, float16 as cI, float16x2 as cJ, float16x4 as cK, float32 as cL, float32x2 as cM, float32x3 as cN, float32x4 as cO, uint32 as cP, uint32x2 as cQ, uint32x3 as cR, uint32x4 as cS, sint32 as cT, sint32x2 as cU, sint32x3 as cV, sint32x4 as cW, unorm10_10_10_2 as cX, unorm8x4_bgra as cY, type PackedData as cZ, type TgpuDualFn as c_, type BuiltinSampleIndex as ca, type BuiltinSampleMask as cb, type BuiltinVertexIndex as cc, type BuiltinWorkgroupId as cd, type InferGPU as ce, type InferPartial as cf, type FormatToWGSLType as cg, type TgpuVertexFormatData as ch, formatToWGSLType as ci, packedFormats as cj, uint8 as ck, uint8x2 as cl, uint8x4 as cm, sint8 as cn, sint8x2 as co, sint8x4 as cp, unorm8 as cq, unorm8x2 as cr, unorm8x4 as cs, snorm8 as ct, snorm8x2 as cu, snorm8x4 as cv, uint16 as cw, uint16x2 as cx, uint16x4 as cy, sint16 as cz, type TgpuBufferUsage as d, type AnyMatInstance as d0, type vBaseForMat as d1, type mBaseForVec as d2, type AnyFloatVecInstance as d3, type v3h as d4, type v2h as d5, type v4h as d6, type AnyVec2Instance as d7, type AnyVec3Instance as d8, type AnyBooleanVecInstance as d9, type atomicI32 as da, type atomicU32 as db, type TgpuStorageTexture as dc, type TexelData as dd, type ChannelData as de, type TgpuAccessor as e, type TgpuDerived as f, type TgpuSlot as g, type TgpuVertexLayout as h, type WgslArray as i, type TgpuBuffer as j, type AnyData as k, fn as l, bindGroupLayout as m, fragmentFn as n, vertexFn as o, computeFn as p, privateVar as q, constant as r, declare as s, sampler as t, comparisonSampler as u, vertexLayout as v, workgroupVar as w, isBuffer as x, isUsableAsVertex as y, isDerived as z };