typegpu 0.3.0-alpha.7 → 0.3.1

package/index.d.ts

@@ -1,6 +1,73 @@
-import { U as Unwrapper, A as AnyData, I as Infer, E as Exotic, T as TgpuBuffer$1, a as TgpuLayoutEntry, b as TgpuBindGroupLayout, O as OmitProps, L as LayoutEntryToInput, c as TgpuBindGroup, d as TgpuResolvable, e as AnyWgslData, f as TgpuBufferMutable$1, g as TgpuBufferReadonly$1, h as TgpuBufferUniform$1, i as bindGroupLayout } from './wgslTypes-BsqIvRBG.js';
-export { H as BindLayoutEntry, S as Storage, x as TgpuAnyTextureView, F as TgpuLayoutExternalTexture, z as TgpuLayoutSampler, C as TgpuLayoutStorage, D as TgpuLayoutStorageTexture, B as TgpuLayoutTexture, G as TgpuLayoutUniform, v as TgpuMutableTexture, t as TgpuReadonlyTexture, w as TgpuSampledTexture, y as TgpuSampler, s as TgpuTexture, u as TgpuWriteonlyTexture, r as Uniform, V as Vertex, j as isBuffer, n as isComparisonSampler, o as isSampledTextureView, m as isSampler, p as isStorageTextureView, q as isUsableAsStorage, k as isUsableAsUniform, l as isUsableAsVertex } from './wgslTypes-BsqIvRBG.js';
+import { A as AnyWgslData, I as Infer, D as Decorated, F as F32, a as F16, b as I32, U as U32, V as Vec2f, c as Vec3f, d as Vec4f, e as Vec2h, f as Vec3h, g as Vec4h, h as Vec2i, i as Vec3i, j as Vec4i, k as Vec2u, l as Vec3u, m as Vec4u, B as BaseWgslData, L as Location, W as WgslArray, n as WgslStruct, o as WgslTypeLiteral, p as AnyVecInstance, q as AnyMatInstance } from './vector-BSez01sn.js';
+import { T as TgpuNamable, E as Exotic, A as AnyBuiltin, a as AnyAttribute, D as Default, U as UnionToIntersection, b as AnyData, c as Decorate, d as TgpuStruct, I as IsBuiltin, H as HasCustomLocation, O as OmitBuiltins, e as Disarray, K as KindToAcceptedAttribMap, f as Unstruct, V as VertexFormat, g as TgpuVertexAttrib, h as KindToDefaultFormatMap, i as OmitProps, P as Prettify, M as Mutable, j as Infer$1, k as ExoticArray } from './index-BM7ZTN7E.js';
 import * as smol from 'tinyest';
+import { Block } from 'tinyest';
+
+interface TgpuConst<TDataType extends AnyWgslData = AnyWgslData> extends TgpuNamable {
+    readonly dataType: TDataType;
+    readonly value: Infer<TDataType>;
+}
+/**
+ * Creates a module constant with specified value.
+ */
+declare function constant<TDataType extends AnyWgslData>(dataType: Exotic<TDataType>, value: Infer<Exotic<TDataType>>): TgpuConst<Exotic<TDataType>>;
+
+/**
+ * Extra declaration that shall be included in final WGSL code,
+ * when resolving objects that use it.
+ */
+interface TgpuDeclare {
+    $uses(dependencyMap: Record<string, unknown>): this;
+}
+/**
+ * Allows defining extra declarations that shall be included in the final WGSL code,
+ * when resolving objects that use them.
+ *
+ * Using this API is generally discouraged, as it shouldn't be necessary in any common scenario.
+ * It was developed to ensure full compatibility of TypeGPU programs with current and future versions of WGSL.
+ */
+declare function declare(declaration: string): TgpuDeclare;
+
+/**
+ * Describes a compute entry function signature (its arguments and return type)
+ */
+interface TgpuComputeFnShell {
+    readonly argTypes: [];
+    readonly returnType: undefined;
+    readonly workgroupSize: [number, number, number];
+    /**
+     * Creates a type-safe implementation of this signature
+     */
+    does(implementation: () => undefined): TgpuComputeFn;
+    /**
+     * @param implementation
+     *   Raw WGSL function implementation with header and body
+     *   without `fn` keyword and function name
+     *   e.g. `"(x: f32) -> f32 { return x; }"`;
+     */
+    does(implementation: string): TgpuComputeFn;
+}
+interface TgpuComputeFn extends TgpuNamable {
+    readonly shell: TgpuComputeFnShell;
+    $uses(dependencyMap: Record<string, unknown>): this;
+}
+interface ComputeFnOptions {
+    workgroupSize: number[];
+}
+/**
+ * Creates a shell of a typed entry function for the compute shader stage. Any function
+ * that implements this shell can perform general-purpose computation.
+ *
+ * @param workgroupSize
+ *   Size of blocks that the thread grid will be divided into (up to 3 dimensions).
+ */
+declare function computeFn(argTypes: AnyBuiltin[], options: ComputeFnOptions): TgpuComputeFnShell;
+
+interface Storage {
+    usableAsStorage: true;
+}
+declare const Storage: Storage;
+declare function isUsableAsStorage<T>(value: T): value is T & Storage;
 
 /**
  * Information extracted from transpiling a JS function.
@@ -14,6 +81,27 @@ type TranspilationResult = {
      */
     externalNames: string[];
 };
+type InferArgs<T extends unknown[]> = {
+    [Idx in keyof T]: Infer<T[Idx]>;
+};
+type InferReturn<T> = T extends undefined ? void : Infer<T>;
+type BaseIOData = F32 | F16 | I32 | U32 | Vec2f | Vec3f | Vec4f | Vec2h | Vec3h | Vec4h | Vec2i | Vec3i | Vec4i | Vec2u | Vec3u | Vec4u;
+type IOData = BaseIOData | Decorated<BaseIOData, AnyAttribute[]>;
+type IORecord<TElementType extends IOData = IOData> = Record<string, TElementType>;
+/**
+ * Used for I/O definitions of entry functions.
+ */
+type IOLayout<TElementType extends IOData = IOData> = TElementType | IORecord<TElementType>;
+type InferIO<T> = T extends {
+    type: string;
+} ? Infer<T> : T extends Record<string, unknown> ? {
+    [K in keyof T]: Infer<T[K]>;
+} : T;
+type ExoticIO<T> = T extends {
+    type: string;
+} ? Exotic<T> : T extends Record<string, unknown> ? {
+    [K in keyof T]: Exotic<T[K]>;
+} : T;
 
 /**
  * Used to transpile JS resources into SMoL on demand.
@@ -22,32 +110,1052 @@ interface JitTranspiler {
     transpileFn(rawJs: string): TranspilationResult;
 }
 
+interface NameRegistry {
+    /**
+     * Creates a valid WGSL identifier, each guaranteed to be unique
+     * in the lifetime of a single resolution process.
+     * @param primer Used in the generation process, makes the identifier more recognizable.
+     */
+    makeUnique(primer?: string): string;
+}
+declare class RandomNameRegistry implements NameRegistry {
+    private lastUniqueId;
+    makeUnique(primer?: string | undefined): string;
+}
+declare class StrictNameRegistry implements NameRegistry {
+    /**
+     * Allows to provide a good fallback for instances of the
+     * same function that are bound to different slot values.
+     */
+    private readonly _usedNames;
+    makeUnique(primer?: string | undefined): string;
+}
+
+interface TgpuSlot<T> extends TgpuNamable, Labelled {
+    readonly resourceType: 'slot';
+    readonly defaultValue: T | undefined;
+    /**
+     * Used to determine if code generated using either value `a` or `b` in place
+     * of the slot will be equivalent. Defaults to `Object.is`.
+     */
+    areEqual(a: T, b: T): boolean;
+    readonly value: Infer<T>;
+}
+interface TgpuDerived<T> {
+    readonly resourceType: 'derived';
+    readonly value: Infer<T>;
+    with<TValue>(slot: TgpuSlot<TValue>, value: Eventual<TValue>): TgpuDerived<T>;
+    /**
+     * @internal
+     */
+    '~compute'(): T;
+}
+interface TgpuAccessor<T extends AnyWgslData = AnyWgslData> extends TgpuNamable, Labelled {
+    readonly resourceType: 'accessor';
+    readonly schema: T;
+    readonly defaultValue: TgpuFn<[], T> | TgpuBufferUsage<T> | Infer<T> | undefined;
+    readonly slot: TgpuSlot<TgpuFn<[], T> | TgpuBufferUsage<T> | Infer<T>>;
+    readonly value: Infer<T>;
+}
+/**
+ * Represents a value that is available at resolution time.
+ */
+type Eventual<T> = T | TgpuSlot<T> | TgpuDerived<T>;
+type SlotValuePair<T = unknown> = [TgpuSlot<T>, T];
+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 TgpuComputePipeline extends TgpuNamable {
+    readonly resourceType: 'compute-pipeline';
+    readonly label: string | undefined;
+    with(bindGroupLayout: TgpuBindGroupLayout, bindGroup: TgpuBindGroup): TgpuComputePipeline;
+    dispatchWorkgroups(x: number, y?: number | undefined, z?: number | undefined): void;
+}
+
+type TextureProps = {
+    size: readonly number[];
+    format: GPUTextureFormat;
+    viewFormats?: GPUTextureFormat[] | undefined;
+    dimension?: GPUTextureDimension | undefined;
+    mipLevelCount?: number | undefined;
+    sampleCount?: number | undefined;
+};
+
+declare const texelFormatToChannelType: {
+    r8unorm: F32;
+    r8snorm: F32;
+    r8uint: U32;
+    r8sint: I32;
+    r16uint: U32;
+    r16sint: I32;
+    r16float: F32;
+    rg8unorm: F32;
+    rg8snorm: F32;
+    rg8uint: U32;
+    rg8sint: I32;
+    r32uint: U32;
+    r32sint: I32;
+    r32float: F32;
+    rg16uint: U32;
+    rg16sint: I32;
+    rg16float: F32;
+    rgba8unorm: F32;
+    'rgba8unorm-srgb': F32;
+    rgba8snorm: F32;
+    rgba8uint: U32;
+    rgba8sint: I32;
+    bgra8unorm: F32;
+    'bgra8unorm-srgb': F32;
+    rgb9e5ufloat: F32;
+    rgb10a2uint: U32;
+    rgb10a2unorm: F32;
+    rg11b10ufloat: F32;
+    rg32uint: U32;
+    rg32sint: I32;
+    rg32float: F32;
+    rgba16uint: U32;
+    rgba16sint: I32;
+    rgba16float: F32;
+    rgba32uint: U32;
+    rgba32sint: I32;
+    rgba32float: F32;
+    stencil8: F32;
+    depth16unorm: F32;
+    depth24plus: F32;
+    'depth24plus-stencil8': F32;
+    depth32float: F32;
+    'depth32float-stencil8': F32;
+    'bc1-rgba-unorm': F32;
+    'bc1-rgba-unorm-srgb': F32;
+    'bc2-rgba-unorm': F32;
+    'bc2-rgba-unorm-srgb': F32;
+    'bc3-rgba-unorm': F32;
+    'bc3-rgba-unorm-srgb': F32;
+    'bc4-r-unorm': F32;
+    'bc4-r-snorm': F32;
+    'bc5-rg-unorm': F32;
+    'bc5-rg-snorm': F32;
+    'bc6h-rgb-ufloat': F32;
+    'bc6h-rgb-float': F32;
+    'bc7-rgba-unorm': F32;
+    'bc7-rgba-unorm-srgb': F32;
+    'etc2-rgb8unorm': F32;
+    'etc2-rgb8unorm-srgb': F32;
+    'etc2-rgb8a1unorm': F32;
+    'etc2-rgb8a1unorm-srgb': F32;
+    'etc2-rgba8unorm': F32;
+    'etc2-rgba8unorm-srgb': F32;
+    'eac-r11unorm': F32;
+    'eac-r11snorm': F32;
+    'eac-rg11unorm': F32;
+    'eac-rg11snorm': F32;
+    'astc-4x4-unorm': F32;
+    'astc-4x4-unorm-srgb': F32;
+    'astc-5x4-unorm': F32;
+    'astc-5x4-unorm-srgb': F32;
+    'astc-5x5-unorm': F32;
+    'astc-5x5-unorm-srgb': F32;
+    'astc-6x5-unorm': F32;
+    'astc-6x5-unorm-srgb': F32;
+    'astc-6x6-unorm': F32;
+    'astc-6x6-unorm-srgb': F32;
+    'astc-8x5-unorm': F32;
+    'astc-8x5-unorm-srgb': F32;
+    'astc-8x6-unorm': F32;
+    'astc-8x6-unorm-srgb': F32;
+    'astc-8x8-unorm': F32;
+    'astc-8x8-unorm-srgb': F32;
+    'astc-10x5-unorm': F32;
+    'astc-10x5-unorm-srgb': F32;
+    'astc-10x6-unorm': F32;
+    'astc-10x6-unorm-srgb': F32;
+    'astc-10x8-unorm': F32;
+    'astc-10x8-unorm-srgb': F32;
+    'astc-10x10-unorm': F32;
+    'astc-10x10-unorm-srgb': F32;
+    'astc-12x10-unorm': F32;
+    'astc-12x10-unorm-srgb': F32;
+    'astc-12x12-unorm': F32;
+    'astc-12x12-unorm-srgb': F32;
+};
+type TexelFormatToChannelType = typeof texelFormatToChannelType;
+type TexelFormatToStringChannels = {
+    [Key in keyof TexelFormatToChannelType]: TexelFormatToChannelType[Key]['type'];
+};
+type KeysWithValue<T extends Record<string, unknown>, TValue> = keyof {
+    [Key in keyof T as T[Key] extends TValue ? Key : never]: Key;
+};
+type ChannelTypeToLegalFormats = {
+    [Key in TexelFormatToChannelType[keyof TexelFormatToChannelType]['type']]: KeysWithValue<TexelFormatToStringChannels, Key>;
+};
+type SampleTypeToStringChannelType = {
+    float: 'f32';
+    'unfilterable-float': 'f32';
+    depth: 'f32';
+    sint: 'i32';
+    uint: 'u32';
+};
+type ViewDimensionToDimension = {
+    '1d': '1d';
+    '2d': '2d';
+    '2d-array': '2d';
+    '3d': '3d';
+    cube: '2d';
+    'cube-array': '2d';
+};
+/**
+ * https://www.w3.org/TR/WGSL/#storage-texel-formats
+ */
+type StorageTextureTexelFormat = 'rgba8unorm' | 'rgba8snorm' | 'rgba8uint' | 'rgba8sint' | 'rgba16uint' | 'rgba16sint' | 'rgba16float' | 'r32uint' | 'r32sint' | 'r32float' | 'rg32uint' | 'rg32sint' | 'rg32float' | 'rgba32uint' | 'rgba32sint' | 'rgba32float' | 'bgra8unorm';
+declare const texelFormatToDataType: {
+    readonly rgba8unorm: Vec4f;
+    readonly rgba8snorm: Vec4f;
+    readonly rgba8uint: Vec4u;
+    readonly rgba8sint: Vec4i;
+    readonly rgba16uint: Vec4u;
+    readonly rgba16sint: Vec4i;
+    readonly rgba16float: Vec4f;
+    readonly r32uint: Vec4u;
+    readonly r32sint: Vec4i;
+    readonly r32float: Vec4f;
+    readonly rg32uint: Vec4u;
+    readonly rg32sint: Vec4i;
+    readonly rg32float: Vec4f;
+    readonly rgba32uint: Vec4u;
+    readonly rgba32sint: Vec4i;
+    readonly rgba32float: Vec4f;
+    readonly bgra8unorm: Vec4f;
+};
+declare const channelFormatToSchema: {
+    float: F32;
+    'unfilterable-float': F32;
+    uint: U32;
+    sint: I32;
+    depth: F32;
+};
+type ChannelFormatToSchema = typeof channelFormatToSchema;
+type TexelFormatToDataType = typeof texelFormatToDataType;
+type TexelFormatToDataTypeOrNever<T> = T extends keyof TexelFormatToDataType ? TexelFormatToDataType[T] : never;
+/**
+ * Represents what formats a storage view can choose from based on its owner texture's props.
+ */
+type StorageFormatOptions<TProps extends TextureProps> = Extract<TProps['format'] | Default<TProps['viewFormats'], []>[number], StorageTextureTexelFormat>;
+/**
+ * Represents what formats a sampled view can choose from based on its owner texture's props.
+ */
+type SampledFormatOptions<TProps extends TextureProps> = TProps['format'] | Default<TProps['viewFormats'], []>[number];
+
+interface Sampled {
+    usableAsSampled: true;
+}
+interface Render {
+    usableAsRender: true;
+}
+type LiteralToExtensionMap = {
+    storage: Storage;
+    sampled: Sampled;
+    render: Render;
+};
+type AllowedUsages<TProps extends TextureProps> = 'sampled' | 'render' | (TProps['format'] extends StorageTextureTexelFormat ? 'storage' : never);
+declare function isUsableAsSampled<T>(value: T): value is T & Sampled;
+declare function isUsableAsRender<T>(value: T): value is T & Render;
+
+type ResolveStorageDimension<TDimension extends GPUTextureViewDimension, TProps extends TextureProps> = StorageTextureDimension extends TDimension ? Default<TProps['dimension'], '2d'> : TDimension extends StorageTextureDimension ? TDimension : '2d';
+type ViewUsages<TProps extends TextureProps, TTexture extends TgpuTexture<TProps>> = boolean extends TTexture['usableAsSampled'] ? boolean extends TTexture['usableAsStorage'] ? never : 'readonly' | 'writeonly' | 'mutable' : boolean extends TTexture['usableAsStorage'] ? 'sampled' : 'readonly' | 'writeonly' | 'mutable' | 'sampled';
+type ChannelData = U32 | I32 | F32;
+type TexelData = Vec4u | Vec4i | Vec4f;
+/**
+ * @param TProps all properties that distinguish this texture apart from other textures on the type level.
+ */
+interface TgpuTexture<TProps extends TextureProps = TextureProps> extends TgpuNamable {
+    readonly resourceType: 'texture';
+    readonly props: TProps;
+    readonly label: string | undefined;
+    readonly usableAsStorage: boolean;
+    readonly usableAsSampled: boolean;
+    readonly usableAsRender: boolean;
+    $usage<T extends AllowedUsages<TProps>[]>(...usages: T): this & UnionToIntersection<LiteralToExtensionMap[T[number]]>;
+    createView<TUsage extends ViewUsages<TProps, this>, TDimension extends 'sampled' extends TUsage ? GPUTextureViewDimension : StorageTextureDimension, TFormat extends 'sampled' extends TUsage ? SampledFormatOptions<TProps> : StorageFormatOptions<TProps>>(access: TUsage, params?: TextureViewParams<TDimension, TFormat>): {
+        mutable: TgpuMutableTexture<ResolveStorageDimension<TDimension, TProps>, TexelFormatToDataTypeOrNever<StorageFormatOptions<TProps> extends TFormat ? TProps['format'] : TFormat>>;
+        readonly: TgpuReadonlyTexture<ResolveStorageDimension<TDimension, TProps>, TexelFormatToDataTypeOrNever<StorageFormatOptions<TProps> extends TFormat ? TProps['format'] : TFormat>>;
+        writeonly: TgpuWriteonlyTexture<ResolveStorageDimension<TDimension, TProps>, TexelFormatToDataTypeOrNever<StorageFormatOptions<TProps> extends TFormat ? TProps['format'] : TFormat>>;
+        sampled: TgpuSampledTexture<GPUTextureViewDimension extends TDimension ? Default<TProps['dimension'], '2d'> : TDimension, TexelFormatToChannelType[SampledFormatOptions<TProps> extends TFormat ? TProps['format'] : TFormat]>;
+    }[TUsage];
+    destroy(): void;
+}
+type StorageTextureAccess = 'readonly' | 'writeonly' | 'mutable';
+/**
+ * Based on @see GPUTextureViewDimension
+ * https://www.w3.org/TR/WGSL/#texture-depth
+ */
+type StorageTextureDimension = '1d' | '2d' | '2d-array' | '3d';
+type TextureViewParams<TDimension extends GPUTextureViewDimension | undefined, TFormat extends GPUTextureFormat | undefined> = {
+    format?: TFormat;
+    dimension?: TDimension;
+    aspect?: GPUTextureAspect;
+    baseMipLevel?: number;
+    mipLevelCount?: number;
+    baseArrayLayout?: number;
+    arrayLayerCount?: number;
+};
+interface TgpuStorageTexture<TDimension extends StorageTextureDimension = StorageTextureDimension, TData extends TexelData = TexelData> {
+    readonly resourceType: 'texture-storage-view';
+    readonly dimension: TDimension;
+    readonly texelDataType: TData;
+    readonly access: StorageTextureAccess;
+}
+/**
+ * A texture accessed as "readonly" storage on the GPU.
+ */
+interface TgpuReadonlyTexture<TDimension extends StorageTextureDimension = StorageTextureDimension, TData extends TexelData = TexelData> extends TgpuStorageTexture<TDimension, TData> {
+    readonly access: 'readonly';
+}
+/**
+ * A texture accessed as "writeonly" storage on the GPU.
+ */
+interface TgpuWriteonlyTexture<TDimension extends StorageTextureDimension = StorageTextureDimension, TData extends TexelData = TexelData> extends TgpuStorageTexture<TDimension, TData> {
+    readonly access: 'writeonly';
+}
+/**
+ * A texture accessed as "mutable" (or read_write) storage on the GPU.
+ */
+interface TgpuMutableTexture<TDimension extends StorageTextureDimension = StorageTextureDimension, TData extends TexelData = TexelData> extends TgpuStorageTexture<TDimension, TData> {
+    readonly access: 'mutable';
+}
+/**
+ * A texture accessed as sampled on the GPU.
+ */
+interface TgpuSampledTexture<TDimension extends GPUTextureViewDimension = GPUTextureViewDimension, TData extends ChannelData = ChannelData> {
+    readonly resourceType: 'texture-sampled-view';
+    readonly dimension: TDimension;
+    readonly channelDataType: TData;
+}
+declare function isTexture<T extends TgpuTexture>(value: unknown | T): value is T;
+declare function isStorageTextureView<T extends TgpuReadonlyTexture | TgpuWriteonlyTexture | TgpuMutableTexture>(value: unknown | T): value is T;
+declare function isSampledTextureView<T extends TgpuSampledTexture>(value: unknown | T): value is T;
+type TgpuAnyTextureView = TgpuReadonlyTexture | TgpuWriteonlyTexture | TgpuMutableTexture | TgpuSampledTexture;
+
+interface Unwrapper {
+    readonly device: GPUDevice;
+    unwrap(resource: TgpuComputePipeline): GPUComputePipeline;
+    unwrap(resource: TgpuBindGroupLayout): GPUBindGroupLayout;
+    unwrap(resource: TgpuBindGroup): GPUBindGroup;
+    unwrap(resource: TgpuBuffer$1<AnyData>): GPUBuffer;
+    unwrap(resource: TgpuTexture): GPUTexture;
+    unwrap(resource: TgpuReadonlyTexture | TgpuWriteonlyTexture | TgpuMutableTexture | TgpuSampledTexture): GPUTextureView;
+}
+
+type WithLocations<T extends IORecord> = {
+    [Key in keyof T]: IsBuiltin<T[Key]> extends true ? T[Key] : HasCustomLocation<T[Key]> extends true ? T[Key] : Decorate<T[Key], Location<number>>;
+};
+type IOLayoutToOutputSchema<T extends IOLayout> = T extends BaseWgslData ? Decorate<T, Location<0>> : T extends IORecord ? TgpuStruct<WithLocations<T>> : never;
+
+/**
+ * Describes a fragment entry function signature (its arguments and return type)
+ */
+interface TgpuFragmentFnShell<FragmentIn extends IOLayout, FragmentOut extends IOLayout<Vec4f>> {
+    readonly argTypes: [FragmentIn];
+    readonly returnType: FragmentOut;
+    /**
+     * Creates a type-safe implementation of this signature
+     */
+    does(implementation: (input: InferIO<FragmentIn>) => InferIO<FragmentOut>): TgpuFragmentFn<OmitBuiltins<FragmentIn>, OmitBuiltins<FragmentOut>>;
+    /**
+     * @param implementation
+     *   Raw WGSL function implementation with header and body
+     *   without `fn` keyword and function name
+     *   e.g. `"(x: f32) -> f32 { return x; }"`;
+     */
+    does(implementation: string): TgpuFragmentFn<OmitBuiltins<FragmentIn>, OmitBuiltins<FragmentOut>>;
+}
+interface TgpuFragmentFn<Varying extends IOLayout = IOLayout, Output extends IOLayout<Vec4f> = IOLayout<Vec4f>> extends TgpuNamable {
+    readonly shell: TgpuFragmentFnShell<Varying, Output>;
+    readonly outputType: IOLayoutToOutputSchema<Output>;
+    $uses(dependencyMap: Record<string, unknown>): this;
+}
+/**
+ * Creates a shell of a typed entry function for the fragment shader stage. Any function
+ * that implements this shell can run for each fragment (pixel), allowing the inner code
+ * to process information received from the vertex shader stage and builtins to determine
+ * the final color of the pixel (many pixels in case of multiple targets).
+ *
+ * @param inputType
+ *   Values computed in the vertex stage and builtins to be made available to functions that implement this shell.
+ * @param outputType
+ *   A `vec4f`, signaling this function outputs a color for one target, or a struct/array containing
+ *   colors for multiple targets.
+ */
+declare function fragmentFn<FragmentIn extends IORecord, FragmentOut extends IOLayout<Vec4f>>(inputType: FragmentIn, outputType: FragmentOut): TgpuFragmentFnShell<ExoticIO<FragmentIn>, ExoticIO<FragmentOut>>;
+
+/**
+ * Describes a vertex entry function signature (its arguments and return type)
+ */
+interface TgpuVertexFnShell<VertexIn extends IOLayout, VertexOut extends IOLayout> {
+    readonly argTypes: [VertexIn];
+    readonly returnType: VertexOut;
+    /**
+     * Creates a type-safe implementation of this signature
+     */
+    does(implementation: (input: InferIO<VertexIn>) => InferIO<VertexOut>): TgpuVertexFn<OmitBuiltins<VertexIn>, OmitBuiltins<VertexOut>>;
+    /**
+     * @param implementation
+     *   Raw WGSL function implementation with header and body
+     *   without `fn` keyword and function name
+     *   e.g. `"(x: f32) -> f32 { return x; }"`;
+     */
+    does(implementation: string): TgpuVertexFn<OmitBuiltins<VertexIn>, OmitBuiltins<VertexOut>>;
+}
+interface TgpuVertexFn<VertexIn extends IOLayout = IOLayout, VertexOut extends IOLayout = IOLayout> extends TgpuNamable {
+    readonly shell: TgpuVertexFnShell<VertexIn, VertexOut>;
+    readonly outputType: IOLayoutToOutputSchema<VertexOut>;
+    $uses(dependencyMap: Record<string, unknown>): this;
+}
+/**
+ * Creates a shell of a typed entry function for the vertex shader stage. Any function
+ * that implements this shell can run for each vertex, allowing the inner code to process
+ * attributes and determine the final position of the vertex.
+ *
+ * @param inputType
+ *   Vertex attributes and builtins to be made available to functions that implement this shell.
+ * @param outputType
+ *   A struct type containing the final position of the vertex, and any information
+ *   passed onto the fragment shader stage.
+ */
+declare function vertexFn<VertexIn extends IOLayout, VertexOut extends IORecord>(inputType: VertexIn, outputType: VertexOut): TgpuVertexFnShell<ExoticIO<VertexIn>, ExoticIO<VertexOut>>;
+
+/**
+ * The array can hold T, where T is a single/multi-component numeric, or a struct with members of type T.
+ * Examples of valid array members:
+ * - Vec3f,
+ * - unorm8x2
+ * - TgpuStruct<{ a: Vec3f, b: unorm8x2 }>
+ * - TgpuStruct<{ nested: TgpuStruct<{ a: Vec3f }> }>
+ */
+type DataToContainedAttribs<T> = T extends WgslStruct | Unstruct ? {
+    [Key in keyof T['propTypes']]: DataToContainedAttribs<T['propTypes'][Key]>;
+} : T extends {
+    type: VertexFormat;
+} ? TgpuVertexAttrib<T['type']> : T extends {
+    type: keyof KindToDefaultFormatMap;
+} ? TgpuVertexAttrib<KindToDefaultFormatMap[T['type']]> : never;
+/**
+ * Interprets an array as a set of vertex attributes.
+ */
+type ArrayToContainedAttribs<T extends WgslArray | Disarray> = DataToContainedAttribs<T['elementType']>;
+type LayoutToAllowedAttribs<T> = T extends {
+    type: keyof KindToAcceptedAttribMap;
+} ? KindToAcceptedAttribMap[T['type']] : T extends Record<string, unknown> ? {
+    [Key in keyof T]: LayoutToAllowedAttribs<T[Key]>;
+} : never;
+
+interface TgpuVertexLayout<TData extends WgslArray | Disarray = WgslArray | Disarray> extends TgpuNamable, Labelled {
+    readonly resourceType: 'vertex-layout';
+    readonly stride: number;
+    readonly stepMode: 'vertex' | 'instance';
+    readonly attrib: ArrayToContainedAttribs<TData>;
+    schemaForCount(n: number): TData;
+}
+declare function vertexLayout<TData extends WgslArray | Disarray>(schemaForCount: (count: number) => TData, stepMode?: 'vertex' | 'instance'): TgpuVertexLayout<ExoticIO<TData>>;
+
+interface TgpuRenderPipeline<Output extends IOLayout = IOLayout> extends TgpuNamable {
+    readonly resourceType: 'render-pipeline';
+    readonly label: string | undefined;
+    with<TData extends WgslArray | Disarray>(vertexLayout: TgpuVertexLayout<TData>, buffer: TgpuBuffer$1<TData> & Vertex): TgpuRenderPipeline<IOLayout>;
+    with<Entries extends Record<string, TgpuLayoutEntry | null>>(bindGroupLayout: TgpuBindGroupLayout<Entries>, bindGroup: TgpuBindGroup<Entries>): TgpuRenderPipeline<IOLayout>;
+    withColorAttachment(attachment: FragmentOutToColorAttachment<Output>): TgpuRenderPipeline<IOLayout>;
+    draw(vertexCount: number, instanceCount?: number, firstVertex?: number, firstInstance?: number): void;
+}
+type FragmentOutToTargets<T extends IOLayout> = T extends IOData ? GPUColorTargetState : T extends Record<string, unknown> ? {
+    [Key in keyof T]: GPUColorTargetState;
+} : never;
+type FragmentOutToColorAttachment<T extends IOLayout> = T extends IOData ? ColorAttachment : T extends Record<string, unknown> ? {
+    [Key in keyof T]: ColorAttachment;
+} : never;
+interface ColorAttachment {
+    /**
+     * A {@link GPUTextureView} describing the texture subresource that will be output to for this
+     * color attachment.
+     */
+    view: (TgpuTexture & Render) | GPUTextureView;
+    /**
+     * Indicates the depth slice index of {@link GPUTextureViewDimension#"3d"} {@link GPURenderPassColorAttachment#view}
+     * that will be output to for this color attachment.
+     */
+    depthSlice?: GPUIntegerCoordinate;
+    /**
+     * A {@link GPUTextureView} describing the texture subresource that will receive the resolved
+     * output for this color attachment if {@link GPURenderPassColorAttachment#view} is
+     * multisampled.
+     */
+    resolveTarget?: GPUTextureView;
+    /**
+     * Indicates the value to clear {@link GPURenderPassColorAttachment#view} to prior to executing the
+     * render pass. If not map/exist|provided, defaults to `{r: 0, g: 0, b: 0, a: 0}`. Ignored
+     * if {@link GPURenderPassColorAttachment#loadOp} is not {@link GPULoadOp#"clear"}.
+     * The components of {@link GPURenderPassColorAttachment#clearValue} are all double values.
+     * They are converted to a texel value of texture format matching the render attachment.
+     * If conversion fails, a validation error is generated.
+     */
+    clearValue?: GPUColor;
+    /**
+     * Indicates the load operation to perform on {@link GPURenderPassColorAttachment#view} prior to
+     * executing the render pass.
+     * Note: It is recommended to prefer clearing; see {@link GPULoadOp#"clear"} for details.
+     */
+    loadOp: GPULoadOp;
+    /**
+     * The store operation to perform on {@link GPURenderPassColorAttachment#view}
+     * after executing the render pass.
+     */
+    storeOp: GPUStoreOp;
+}
+
+interface WithCompute {
+    createPipeline(): TgpuComputePipeline;
+}
+type ValidateFragmentIn<VertexOut extends IORecord, FragmentIn extends IORecord, FragmentOut extends IOLayout<Vec4f>> = FragmentIn extends Partial<VertexOut> ? VertexOut extends FragmentIn ? [
+    entryFn: TgpuFragmentFn<FragmentIn, FragmentOut>,
+    targets: FragmentOutToTargets<FragmentOut>
+] : [
+    entryFn: 'n/a',
+    targets: 'n/a',
+    MissingFromVertexOutput: {
+        [Key in Exclude<keyof FragmentIn, keyof VertexOut>]: FragmentIn[Key];
+    }
+] : [
+    entryFn: 'n/a',
+    targets: 'n/a',
+    MismatchedVertexOutput: {
+        [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> {
+    withFragment<FragmentIn extends IORecord, FragmentOut extends IOLayout<Vec4f>>(...args: ValidateFragmentIn<VertexOut, FragmentIn, FragmentOut>): WithFragment<FragmentOut>;
+}
+interface WithFragment<Output extends IOLayout<Vec4f> = IOLayout<Vec4f>> {
+    withPrimitive(primitiveState: GPUPrimitiveState | undefined): WithFragment<Output>;
+    createPipeline(): TgpuRenderPipeline<Output>;
+}
+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(entryFn: TgpuComputeFn): WithCompute;
+    withVertex<VertexIn extends IOLayout, VertexOut extends IORecord>(entryFn: TgpuVertexFn<VertexIn, VertexOut>, attribs: LayoutToAllowedAttribs<OmitBuiltins<VertexIn>>): WithVertex<VertexOut>;
+}
+type CreateTextureOptions<TSize, TFormat extends GPUTextureFormat, TMipLevelCount extends number, TSampleCount extends number, TViewFormat extends GPUTextureFormat, TDimension extends GPUTextureDimension> = {
+    /**
+     * The width, height, and depth or layer count of the texture.
+     */
+    size: TSize;
+    /**
+     * The format of the texture.
+     */
+    format: TFormat;
+    /**
+     * The number of mip levels the texture will contain.
+     * @default 1
+     */
+    mipLevelCount?: TMipLevelCount | undefined;
+    /**
+     * The sample count of the texture. A sampleCount > 1 indicates a multisampled texture.
+     * @default 1
+     */
+    sampleCount?: TSampleCount | undefined;
+    /**
+     * Specifies extra formats (in addition to the texture's actual format) that can be used
+     * when creating views of this texture.
+     * @default []
+     */
+    viewFormats?: TViewFormat[] | undefined;
+    /**
+     * Whether the texture is one-dimensional, an array of two-dimensional layers, or three-dimensional.
+     * @default '2d'
+     */
+    dimension?: TDimension | undefined;
+};
+type CreateTextureResult<TSize extends readonly number[], TFormat extends GPUTextureFormat, TMipLevelCount extends number, TSampleCount extends number, TViewFormat extends GPUTextureFormat, TDimension extends GPUTextureDimension> = Prettify<{
+    size: Mutable<TSize>;
+    format: TFormat;
+} & OmitProps<{
+    dimension: GPUTextureDimension extends TDimension ? undefined : TDimension extends '2d' ? undefined : TDimension;
+    mipLevelCount: number extends TMipLevelCount ? undefined : TMipLevelCount extends 1 ? undefined : TMipLevelCount;
+    sampleCount: number extends TSampleCount ? undefined : TSampleCount extends 1 ? undefined : TSampleCount;
+    viewFormats: GPUTextureFormat extends TViewFormat ? undefined : TViewFormat[] extends never[] ? undefined : TViewFormat[];
+}, undefined>>;
 interface TgpuRoot extends Unwrapper {
     /**
      * The GPU device associated with this root.
      */
     readonly device: GPUDevice;
     /**
+     * Allocates memory on the GPU, allows passing data between host and shader.
+     *
+     * @remarks
+     * Typed wrapper around a GPUBuffer.
+     *
      * @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<Exotic<TData>> | undefined): TgpuBuffer$1<Exotic<TData>>;
     /**
+     * Allocates memory on the GPU, allows passing data between host and shader.
+     *
+     * @remarks
+     * Typed wrapper around a GPUBuffer.
+     *
      * @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$1<Exotic<TData>>;
+    /**
+     * Creates a group of resources that can be bound to a shader based on a specified layout.
+     *
+     * @remarks
+     * Typed wrapper around a GPUBindGroup.
+     *
+     * @example
+     * const fooLayout = tgpu.bindGroupLayout({
+     *  foo: { uniform: d.vec3f },
+     *  bar: { texture: 'float' },
+     * });
+     *
+     * const fooBuffer = ...;
+     * const barTexture = ...;
+     *
+     * const fooBindGroup = root.createBindGroup(fooLayout, {
+     *  foo: fooBuffer,
+     *  bar: barTexture,
+     * });
+     *
+     * @param layout Layout describing the bind group to be created.
+     * @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>;
+    /**
+     * Destroys all underlying resources (i.e. buffers...) created through this root object.
+     * If the object is created via `tgpu.init` instead of `tgpu.initFromDevice`,
+     * then the inner GPU device is destroyed as well.
+     */
     destroy(): void;
+    '~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;
+    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>>;
+    /**
+     * Causes all commands enqueued by pipelines to be
+     * submitted to the GPU.
+     */
+    flush(): void;
+}
+
+interface Uniform {
+    usableAsUniform: true;
+}
+declare const Uniform: Uniform;
+interface Vertex {
+    usableAsVertex: true;
+}
+declare const Vertex: Vertex;
+type LiteralToUsageType<T extends 'uniform' | 'storage' | 'vertex'> = T extends 'uniform' ? Uniform : T extends 'storage' ? Storage : T extends 'vertex' ? Vertex : never;
+interface TgpuBuffer$1<TData extends AnyData> extends TgpuNamable {
+    readonly resourceType: 'buffer';
+    readonly dataType: TData;
+    readonly initial?: Infer<TData> | undefined;
+    readonly label: string | undefined;
+    readonly buffer: GPUBuffer;
+    readonly destroyed: boolean;
+    $usage<T extends RestrictVertexUsages<TData>>(...usages: T): this & UnionToIntersection<LiteralToUsageType<T[number]>>;
+    $addFlags(flags: GPUBufferUsageFlags): this;
+    write(data: Infer<TData>): void;
+    copyFrom(srcBuffer: TgpuBuffer$1<TData>): void;
+    read(): Promise<Infer<TData>>;
+    destroy(): void;
+}
+declare function isBuffer<T extends TgpuBuffer$1<AnyData>>(value: T | unknown): value is T;
+declare function isUsableAsUniform<T extends TgpuBuffer$1<AnyData>>(buffer: T): buffer is T & Uniform;
+declare function isUsableAsVertex<T extends TgpuBuffer$1<AnyData>>(buffer: T): buffer is T & Vertex;
+type RestrictVertexUsages<TData extends AnyData> = TData extends {
+    readonly type: WgslTypeLiteral;
+} ? ('uniform' | 'storage' | 'vertex')[] : 'vertex'[];
+
+interface SamplerProps {
+    addressModeU?: GPUAddressMode;
+    addressModeV?: GPUAddressMode;
+    /**
+     * Specifies the address modes for the texture width, height, and depth
+     * coordinates, respectively.
+     */
+    addressModeW?: GPUAddressMode;
+    /**
+     * Specifies the sampling behavior when the sample footprint is smaller than or equal to one
+     * texel.
+     */
+    magFilter?: GPUFilterMode;
+    /**
+     * Specifies the sampling behavior when the sample footprint is larger than one texel.
+     */
+    minFilter?: GPUFilterMode;
+    /**
+     * Specifies behavior for sampling between mipmap levels.
+     */
+    mipmapFilter?: GPUMipmapFilterMode;
+    lodMinClamp?: number;
+    /**
+     * Specifies the minimum and maximum levels of detail, respectively, used internally when
+     * sampling a texture.
+     */
+    lodMaxClamp?: number;
+    /**
+     * Specifies the maximum anisotropy value clamp used by the sampler. Anisotropic filtering is
+     * enabled when {@link GPUSamplerDescriptor.maxAnisotropy} is > 1 and the implementation supports it.
+     * Anisotropic filtering improves the image quality of textures sampled at oblique viewing
+     * angles. Higher {@link GPUSamplerDescriptor.maxAnisotropy} values indicate the maximum ratio of
+     * anisotropy supported when filtering.
+     *
+     * Most implementations support {@link GPUSamplerDescriptor.maxAnisotropy} values in range
+     * between 1 and 16, inclusive. The used value of {@link GPUSamplerDescriptor.maxAnisotropy}
+     * will be clamped to the maximum value that the platform supports.
+     * The precise filtering behavior is implementation-dependent.
+     */
+    maxAnisotropy?: number;
+}
+interface ComparisonSamplerProps {
+    compare: GPUCompareFunction;
+    addressModeU?: GPUAddressMode;
+    addressModeV?: GPUAddressMode;
+    /**
+     * Specifies the address modes for the texture width, height, and depth
+     * coordinates, respectively.
+     */
+    addressModeW?: GPUAddressMode;
+    /**
+     * Specifies the sampling behavior when the sample footprint is smaller than or equal to one
+     * texel.
+     */
+    magFilter?: GPUFilterMode;
+    /**
+     * Specifies the sampling behavior when the sample footprint is larger than one texel.
+     */
+    minFilter?: GPUFilterMode;
+    /**
+     * Specifies behavior for sampling between mipmap levels.
+     */
+    mipmapFilter?: GPUMipmapFilterMode;
+    lodMinClamp?: number;
+    /**
+     * Specifies the minimum and maximum levels of detail, respectively, used internally when
+     * sampling a texture.
+     */
+    lodMaxClamp?: number;
+    /**
+     * Specifies the maximum anisotropy value clamp used by the sampler. Anisotropic filtering is
+     * enabled when {@link GPUSamplerDescriptor.maxAnisotropy} is > 1 and the implementation supports it.
+     * Anisotropic filtering improves the image quality of textures sampled at oblique viewing
+     * angles. Higher {@link GPUSamplerDescriptor.maxAnisotropy} values indicate the maximum ratio of
+     * anisotropy supported when filtering.
+     *
+     * Most implementations support {@link GPUSamplerDescriptor.maxAnisotropy} values in range
+     * between 1 and 16, inclusive. The used value of {@link GPUSamplerDescriptor.maxAnisotropy}
+     * will be clamped to the maximum value that the platform supports.
+     * The precise filtering behavior is implementation-dependent.
+     */
+    maxAnisotropy?: number;
+}
+interface TgpuSampler {
+    readonly resourceType: 'sampler';
+}
+interface TgpuComparisonSampler {
+    readonly resourceType: 'sampler-comparison';
+}
+declare function sampler(props: SamplerProps): TgpuSampler;
+declare function comparisonSampler(props: ComparisonSamplerProps): TgpuComparisonSampler;
+declare function isSampler(resource: unknown): resource is TgpuSampler;
+declare function isComparisonSampler(resource: unknown): resource is TgpuComparisonSampler;
+
+type TgpuLayoutEntryBase = {
+    /**
+     * Limits this resource's visibility to specific shader stages.
+     *
+     * By default, each resource is visible to all shader stage types, but
+     * depending on the underlying implementation, this may have performance implications.
+     *
+     * @default ['compute'] for mutable resources
+     * @default ['compute','vertex','fragment'] for everything else
+     */
+    visibility?: TgpuShaderStage[];
+};
+type TgpuLayoutUniform = TgpuLayoutEntryBase & {
+    uniform: AnyWgslData;
+};
+type TgpuLayoutStorage = TgpuLayoutEntryBase & {
+    storage: AnyWgslData | ((arrayLength: number) => AnyWgslData);
+    /** @default 'readonly' */
+    access?: 'mutable' | 'readonly';
+};
+type TgpuLayoutSampler = TgpuLayoutEntryBase & {
+    sampler: 'filtering' | 'non-filtering';
+};
+type TgpuLayoutComparisonSampler = TgpuLayoutEntryBase & {
+    sampler: 'comparison';
+};
+type TgpuLayoutTexture<TSampleType extends GPUTextureSampleType = GPUTextureSampleType> = TgpuLayoutEntryBase & {
+    /**
+     * - 'float' - f32
+     * - 'unfilterable-float' - f32, cannot be used with filtering samplers
+     * - 'depth' - f32
+     * - 'sint' - i32
+     * - 'uint' - u32
+     */
+    texture: TSampleType;
+    /**
+     * @default '2d'
+     */
+    viewDimension?: GPUTextureViewDimension;
+    /**
+     * @default false
+     */
+    multisampled?: boolean;
+};
+type TgpuLayoutStorageTexture<TFormat extends StorageTextureTexelFormat = StorageTextureTexelFormat> = TgpuLayoutEntryBase & {
+    storageTexture: TFormat;
+    /** @default 'writeonly' */
+    access?: 'readonly' | 'writeonly' | 'mutable';
+    /** @default '2d' */
+    viewDimension?: StorageTextureDimension;
+};
+type TgpuLayoutExternalTexture = TgpuLayoutEntryBase & {
+    externalTexture: Record<string, never>;
+};
+type TgpuLayoutEntry = TgpuLayoutUniform | TgpuLayoutStorage | TgpuLayoutSampler | TgpuLayoutComparisonSampler | TgpuLayoutTexture | TgpuLayoutStorageTexture | TgpuLayoutExternalTexture;
+type UnwrapRuntimeConstructorInner<T extends BaseWgslData | ((_: number) => BaseWgslData)> = T extends (_: number) => BaseWgslData ? 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 resourceType: 'bind-group-layout';
+    readonly label: string | undefined;
+    readonly entries: Entries;
+    readonly bound: {
+        [K in keyof Entries]: BindLayoutEntry<Entries[K]>;
+    };
+    /**
+     * An explicit numeric index assigned to this bind group layout. If undefined, a unique
+     * index is assigned automatically during resolution. This can be changed with the
+     * `.$idx()` method.
+     */
+    readonly index: number | undefined;
+    /**
+     * Associates this bind group layout with an explicit numeric index. When a call to this
+     * method is omitted, a unique numeric index is assigned to it automatically.
+     *
+     * Used when generating WGSL code: `@group(${index}) @binding(...) ...;`
+     */
+    $idx(index?: number): this;
+    /**
+     * @deprecated Use the `root.createBindGroup` API instead, accessible through `await tgpu.init()`
+     */
+    populate(entries: {
+        [K in keyof OmitProps<Entries, null>]: LayoutEntryToInput<Entries[K]>;
+    }): TgpuBindGroup<Entries>;
+    /**
+     * Creates a raw WebGPU resource based on the typed descriptor.
+     * NOTE: This creates a new resource every time, better to use `root.unwrap(...)` instead.
+     * @param unwrapper Used to unwrap any resources that this resource depends on.
+     */
+    unwrap(unwrapper: Unwrapper): GPUBindGroupLayout;
+}
+type StorageUsageForEntry<T extends TgpuLayoutStorage> = T extends {
+    access?: infer Access;
+} ? 'mutable' | 'readonly' extends Access ? TgpuBufferReadonly$1<UnwrapRuntimeConstructor<T['storage']>> | TgpuBufferMutable$1<UnwrapRuntimeConstructor<T['storage']>> : 'readonly' extends Access ? TgpuBufferReadonly$1<UnwrapRuntimeConstructor<T['storage']>> : 'mutable' extends Access ? TgpuBufferMutable$1<UnwrapRuntimeConstructor<T['storage']>> : TgpuBufferReadonly$1<UnwrapRuntimeConstructor<T['storage']>> | TgpuBufferMutable$1<UnwrapRuntimeConstructor<T['storage']>> : TgpuBufferReadonly$1<UnwrapRuntimeConstructor<T['storage']>>;
+type GetUsageForStorageTexture<T extends TgpuLayoutStorageTexture, TAccess extends 'readonly' | 'writeonly' | 'mutable'> = {
+    mutable: TgpuMutableTexture<Default<GetDimension<T['viewDimension']>, '2d'>, TexelFormatToDataType[T['storageTexture']]>;
+    readonly: TgpuReadonlyTexture<Default<GetDimension<T['viewDimension']>, '2d'>, TexelFormatToDataType[T['storageTexture']]>;
+    writeonly: TgpuWriteonlyTexture<Default<GetDimension<T['viewDimension']>, '2d'>, TexelFormatToDataType[T['storageTexture']]>;
+}[TAccess];
+type StorageTextureUsageForEntry<T extends TgpuLayoutStorageTexture> = T extends unknown ? GetUsageForStorageTexture<T, Default<T['access'], 'writeonly'>> : never;
+type GetDimension<T extends GPUTextureViewDimension | undefined> = T extends keyof ViewDimensionToDimension ? ViewDimensionToDimension[T] : undefined;
+type GetTextureRestriction<T extends TgpuLayoutTexture> = Default<GetDimension<T['viewDimension']>, '2d'> extends infer Dimension ? Dimension extends '2d' ? {
+    format: ChannelTypeToLegalFormats[SampleTypeToStringChannelType[T['texture']]];
+    dimension?: Dimension;
+} : {
+    format: ChannelTypeToLegalFormats[SampleTypeToStringChannelType[T['texture']]];
+    dimension: Dimension;
+} : never;
+type GetStorageTextureRestriction<T extends TgpuLayoutStorageTexture> = Default<GetDimension<T['viewDimension']>, '2d'> extends infer Dimension ? Dimension extends '2d' ? {
+    format: T['storageTexture'];
+    dimension?: Dimension;
+} : {
+    format: T['storageTexture'];
+    dimension: Dimension;
+} : never;
+type LayoutEntryToInput<T extends TgpuLayoutEntry | null> = T extends TgpuLayoutUniform ? (TgpuBuffer$1<UnwrapRuntimeConstructor<T['uniform']>> & Uniform) | GPUBuffer : T extends TgpuLayoutStorage ? (TgpuBuffer$1<UnwrapRuntimeConstructor<T['storage']>> & Storage) | GPUBuffer : T extends TgpuLayoutSampler ? TgpuSampler | GPUSampler : T extends TgpuLayoutComparisonSampler ? TgpuComparisonSampler | GPUSampler : T extends TgpuLayoutTexture ? GPUTextureView | (Sampled & TgpuTexture<Prettify<TextureProps & GetTextureRestriction<T>>>) : T extends TgpuLayoutStorageTexture ? GPUTextureView | (Storage & TgpuTexture<Prettify<TextureProps & GetStorageTextureRestriction<T>>>) : T extends TgpuLayoutExternalTexture ? GPUExternalTexture : never;
+type BindLayoutEntry<T extends TgpuLayoutEntry | null> = T extends TgpuLayoutUniform ? TgpuBufferUniform$1<UnwrapRuntimeConstructor<T['uniform']>> : T extends TgpuLayoutStorage ? StorageUsageForEntry<T> : T extends TgpuLayoutSampler ? TgpuSampler : T extends TgpuLayoutComparisonSampler ? TgpuComparisonSampler : T extends TgpuLayoutTexture ? TgpuSampledTexture<Default<GetDimension<T['viewDimension']>, '2d'>, ChannelFormatToSchema[T['texture']]> : T extends TgpuLayoutStorageTexture ? StorageTextureUsageForEntry<T> : never;
+type TgpuBindGroup<Entries extends Record<string, TgpuLayoutEntry | null> = Record<string, TgpuLayoutEntry | null>> = {
+    readonly resourceType: 'bind-group';
+    readonly layout: TgpuBindGroupLayout<Entries>;
+    unwrap(unwrapper: Unwrapper): GPUBindGroup;
+};
+type ExoticEntry<T> = T extends Record<string | number | symbol, unknown> ? {
+    [Key in keyof T]: T[Key] extends BaseWgslData ? Exotic<T[Key]> : T[Key] extends (...args: infer TArgs) => infer TReturn ? (...args: TArgs) => Exotic<TReturn> : T[Key];
+} : T;
+type ExoticEntries<T extends Record<string, TgpuLayoutEntry | null>> = {
+    [BindingKey in keyof T]: ExoticEntry<T[BindingKey]>;
+};
+declare function bindGroupLayout<Entries extends Record<string, TgpuLayoutEntry | null>>(entries: Entries): TgpuBindGroupLayout<Prettify<ExoticEntries<Entries>>>;
+
+interface TgpuBufferUsage<TData extends BaseWgslData = BaseWgslData, TUsage extends BindableBufferUsage = BindableBufferUsage> {
+    readonly resourceType: 'buffer-usage';
+    readonly usage: TUsage;
+    readonly '~repr': Infer<TData>;
+    value: Infer<TData>;
+}
+interface TgpuBufferUniform$1<TData extends BaseWgslData> extends TgpuBufferUsage<TData, 'uniform'> {
+    readonly value: Infer<TData>;
+}
+interface TgpuBufferReadonly$1<TData extends BaseWgslData> extends TgpuBufferUsage<TData, 'readonly'> {
+    readonly value: Infer<TData>;
+}
+interface TgpuBufferMutable$1<TData extends BaseWgslData> extends TgpuBufferUsage<TData, 'mutable'> {
+}
+declare function asMutable<TData extends AnyWgslData>(buffer: TgpuBuffer$1<TData> & Storage): TgpuBufferMutable$1<TData>;
+declare function asReadonly<TData extends AnyWgslData>(buffer: TgpuBuffer$1<TData> & Storage): TgpuBufferReadonly$1<TData>;
+declare function asUniform<TData extends AnyWgslData>(buffer: TgpuBuffer$1<TData> & Uniform): TgpuBufferUniform$1<TData>;
+
+interface TgpuExternalTexture {
+    readonly resourceType: 'external-texture';
+}
+
+type VariableScope = 'private' | 'workgroup';
+interface TgpuVar<TScope extends VariableScope = VariableScope, TDataType extends AnyWgslData = AnyWgslData> extends TgpuNamable {
+    value: Infer<TDataType>;
+    readonly scope: TScope;
+}
+/**
+ * Defines a variable scoped to each entry function (private).
+ *
+ * @param dataType The schema of the held data's type
+ * @param initialValue If not provided, the variable will be initialized to the dataType's "zero-value".
+ */
+declare function privateVar<TDataType extends AnyWgslData>(dataType: Exotic<TDataType>, initialValue?: Infer<Exotic<TDataType>>): TgpuVar<'private', Exotic<TDataType>>;
+/**
+ * Defines a variable scoped to the whole workgroup, shared between entry functions
+ * of the same invocation.
+ *
+ * @param dataType The schema of the held data's type
+ */
+declare function workgroupVar<TDataType extends AnyWgslData>(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 | AnyWgslData | TgpuFn<any, any>;
+type Wgsl = Eventual<string | number | boolean | ResolvableObject>;
+declare const UnknownData: unique symbol;
+type UnknownData = typeof UnknownData;
+type Resource = {
+    value: unknown;
+    dataType: AnyWgslData | UnknownData;
+};
+type TgpuShaderStage = 'compute' | 'vertex' | 'fragment';
+interface FnToWgslOptions {
+    args: Resource[];
+    returnType: AnyWgslData;
+    body: Block;
+    externalMap: Record<string, unknown>;
+}
+/**
+ * Passed into each resolvable item. All items in a tree share a resolution ctx,
+ * but there can be layers added and removed from the item stack when going down
+ * and up the tree.
+ */
+interface ResolutionCtx {
+    readonly names: NameRegistry;
+    addDeclaration(declaration: string): void;
+    /**
+     * Reserves a bind group number, and returns a placeholder that will be replaced
+     * with a concrete number at the end of the resolution process.
+     */
+    allocateLayoutEntry(layout: TgpuBindGroupLayout): string;
+    /**
+     * Reserves a spot in the catch-all bind group, without the indirection of a bind-group.
+     * This means the resource is 'fixed', and cannot be swapped between code execution.
+     */
+    allocateFixedEntry(layoutEntry: TgpuLayoutEntry, resource: object): {
+        group: string;
+        binding: number;
+    };
+    withSlots<T>(pairs: SlotValuePair<unknown>[], callback: () => T): T;
+    /**
+     * Unwraps all layers of slot/derived indirection and returns the concrete value if available.
+     * @throws {MissingSlotValueError}
+     */
+    unwrap<T>(eventual: Eventual<T>): T;
+    resolve(item: unknown): string;
+    resolveValue<T extends BaseWgslData>(value: Infer<T>, schema: T): string;
+    transpileFn(fn: string): {
+        argNames: string[];
+        body: Block;
+        externalNames: string[];
+    };
+    fnToWgsl(options: FnToWgslOptions): {
+        head: Wgsl;
+        body: Wgsl;
+    };
 }
+/**
+ * Houses a method '~resolve` that returns a code string
+ * representing it, as opposed to offloading the resolution
+ * to another mechanism.
+ */
+interface SelfResolvable {
+    '~resolve'(ctx: ResolutionCtx): string;
+    toString(): string;
+}
+interface Labelled {
+    readonly label?: string | undefined;
+}
+type BindableBufferUsage = 'uniform' | 'readonly' | 'mutable';
+
+/**
+ * Describes a function signature (its arguments and return type)
+ */
+interface TgpuFnShell<Args extends AnyWgslData[] = AnyWgslData[], Return extends AnyWgslData | undefined = AnyWgslData | undefined> {
+    readonly argTypes: Args;
+    readonly returnType: Return | undefined;
+    /**
+     * Creates a type-safe implementation of this signature
+     */
+    does(implementation: (...args: InferArgs<Args>) => InferReturn<Return>): TgpuFn<Args, Return>;
+    /**
+     * @param implementation
+     *   Raw WGSL function implementation with header and body
+     *   without `fn` keyword and function name
+     *   e.g. `"(x: f32) -> f32 { return x; }"`;
+     */
+    does(implementation: string): TgpuFn<Args, Return>;
+}
+interface TgpuFnBase<Args extends AnyWgslData[], Return extends AnyWgslData | undefined = undefined> extends TgpuNamable, Labelled {
+    readonly resourceType: 'function';
+    readonly shell: TgpuFnShell<Args, Return>;
+    $uses(dependencyMap: Record<string, unknown>): this;
+    with<T>(slot: TgpuSlot<T>, value: Eventual<T>): TgpuFn<Args, Return>;
+    with<T extends AnyWgslData>(accessor: TgpuAccessor<T>, value: TgpuFn<[], T> | TgpuBufferUsage<T> | Infer$1<T>): TgpuFn<Args, Return>;
+}
+type TgpuFn<Args extends AnyWgslData[] = AnyWgslData[], Return extends AnyWgslData | undefined = AnyWgslData | undefined> = TgpuFnBase<Args, Return> & ((...args: InferArgs<Args>) => InferReturn<Return>);
+declare function fn<Args extends AnyWgslData[] | []>(argTypes: Args, returnType?: undefined): TgpuFnShell<ExoticArray<Args>, undefined>;
+declare function fn<Args extends AnyWgslData[] | [], Return extends AnyWgslData>(argTypes: Args, returnType: Return): TgpuFnShell<ExoticArray<Args>, Exotic<Return>>;
+declare function isTgpuFn<Args extends AnyWgslData[], Return extends AnyWgslData | undefined = undefined>(value: unknown | TgpuFn<Args, Return>): value is TgpuFn<Args, Return>;
 
 interface TgpuResolveOptions {
     /**
      * Map of external names to their resolvable values.
      */
-    externals: Record<string, TgpuResolvable | AnyWgslData | boolean | number>;
+    externals: Record<string, Wgsl | object>;
     /**
      * The code template to use for the resolution. All external names will be replaced with their resolved values.
      * @default ''
@@ -150,6 +1258,12 @@ declare function init(options?: InitOptions): Promise<TgpuRoot>;
  */
 declare function initFromDevice(options: InitFromDeviceOptions): TgpuRoot;
 
+declare function accessor<T extends AnyWgslData>(schema: T, defaultValue?: TgpuFn<[], Exotic<T>> | TgpuBufferUsage<Exotic<T>> | Infer<Exotic<T>>): TgpuAccessor<Exotic<T>>;
+
+declare function derived<T>(compute: () => T): TgpuDerived<T>;
+
+declare function slot<T>(defaultValue?: T): TgpuSlot<T>;
+
 /**
  * An error that happens during resolution of WGSL code.
  * Contains a trace of all ancestor resolvables in
@@ -163,12 +1277,25 @@ declare class ResolutionError extends Error {
     constructor(cause: unknown, trace: unknown[]);
     appendToTrace(ancestor: unknown): ResolutionError;
 }
+/**
+ * @category Errors
+ */
+declare class MissingSlotValueError extends Error {
+    readonly slot: TgpuSlot<unknown>;
+    constructor(slot: TgpuSlot<unknown>);
+}
 /**
  * @category Errors
  */
 declare class NotUniformError extends Error {
     constructor(value: TgpuBuffer$1<AnyData>);
 }
+declare class MissingLinksError extends Error {
+    constructor(fnLabel: string | undefined, externalNames: string[]);
+}
+declare class MissingBindGroupError extends Error {
+    constructor(layoutLabel: string | undefined);
+}
 
 type TgpuBuffer<TData extends AnyData> = TgpuBuffer$1<Exotic<TData>>;
 type TgpuBufferMutable<TData extends AnyData> = TgpuBufferMutable$1<Exotic<TData>>;
@@ -180,16 +1307,26 @@ type TgpuBufferUniform<TData extends AnyData> = TgpuBufferUniform$1<Exotic<TData
  */
 
 declare const tgpu: {
-    /** @hidden @deprecated Use `'uniform'` string literal instead. */
-    Uniform: "uniform";
-    /** @hidden @deprecated Use `'storage'` string literal instead. */
-    Storage: "storage";
-    /** @hidden @deprecated Use `'vertex'` string literal instead. */
-    Vertex: "vertex";
     bindGroupLayout: typeof bindGroupLayout;
     init: typeof init;
     initFromDevice: typeof initFromDevice;
     resolve: typeof resolve;
+    '~unstable': {
+        fn: typeof fn;
+        fragmentFn: typeof fragmentFn;
+        vertexFn: typeof vertexFn;
+        computeFn: typeof computeFn;
+        vertexLayout: typeof vertexLayout;
+        derived: typeof derived;
+        slot: typeof slot;
+        accessor: typeof accessor;
+        privateVar: typeof privateVar;
+        workgroupVar: typeof workgroupVar;
+        const: typeof constant;
+        declare: typeof declare;
+        sampler: typeof sampler;
+        comparisonSampler: typeof comparisonSampler;
+    };
 };
 
-export { type InitFromDeviceOptions, type InitOptions, LayoutEntryToInput, NotUniformError, ResolutionError, TgpuBindGroup, TgpuBindGroupLayout, type TgpuBuffer, type TgpuBufferMutable, type TgpuBufferReadonly, type TgpuBufferUniform, TgpuLayoutEntry, type TgpuRoot, tgpu as default, tgpu };
+export { type BindLayoutEntry, type Eventual, type InitFromDeviceOptions, type InitOptions, type LayoutEntryToInput, MissingBindGroupError, MissingLinksError, MissingSlotValueError, NotUniformError, RandomNameRegistry, type Render, ResolutionError, type Sampled, Storage, StrictNameRegistry, type TextureProps, type TgpuAccessor, type TgpuAnyTextureView, type TgpuBindGroup, type TgpuBindGroupLayout, type TgpuBuffer, type TgpuBufferMutable, type TgpuBufferReadonly, type TgpuBufferUniform, type TgpuComputeFn, type TgpuComputeFnShell, type TgpuComputePipeline, type TgpuConst, type TgpuDeclare, type TgpuDerived, type TgpuFn, type TgpuFnShell, type TgpuFragmentFn, type TgpuFragmentFnShell, type TgpuLayoutComparisonSampler, type TgpuLayoutEntry, type TgpuLayoutExternalTexture, type TgpuLayoutSampler, type TgpuLayoutStorage, type TgpuLayoutStorageTexture, type TgpuLayoutTexture, type TgpuLayoutUniform, type TgpuMutableTexture, type TgpuReadonlyTexture, type TgpuRenderPipeline, type TgpuRoot, type TgpuSampledTexture, type TgpuSampler, type TgpuSlot, type TgpuTexture, type TgpuVar, type TgpuVertexFn, type TgpuVertexFnShell, type TgpuVertexLayout, type TgpuWriteonlyTexture, Uniform, type VariableScope, Vertex, type WithBinding, type WithCompute, type WithFragment, type WithVertex, tgpu as default, isBuffer, isComparisonSampler, isDerived, isSampledTextureView, isSampler, isSlot, isStorageTextureView, isTexture, isTgpuFn, isUsableAsRender, isUsableAsSampled, isUsableAsStorage, isUsableAsUniform, isUsableAsVertex, tgpu, asMutable as unstable_asMutable, asReadonly as unstable_asReadonly, asUniform as unstable_asUniform };