typegpu 0.2.0-alpha.0 → 0.3.0-alpha.1

package/index.d.ts

@@ -1,25 +1,401 @@
-import { T as TgpuRenderResource, a as TgpuNamable, b as TgpuBuffer, A as AnyTgpuData, O as OmitProps, c as TgpuBufferUsage, U as Uniform, S as Storage, d as TgpuBufferUniform, e as TgpuShaderStage, f as TgpuBufferReadonly, g as TgpuBufferMutable, h as U32, I as I32, F as F32, V as Vec4u, i as Vec4i, j as Vec4f, k as TgpuPlum, E as ExtractPlumValue, l as Unsubscribe, m as TgpuCode, B as BoundTgpuCode, n as Block, v as vecBase, o as vec3f, p as vec3i, q as vec3u } from './types-qmW7FFqN.js';
-export { r as TgpuData, w as Vertex, s as isUsableAsStorage, t as isUsableAsUniform, u as isUsableAsVertex } from './types-qmW7FFqN.js';
-import { Parsed } from 'typed-binary';
+import { T as TgpuNamable, D as Default, F as F32, U as U32, I as I32, V as Vec4f, a as Vec4u, b as Vec4i, c as UnionToIntersection, A as AnyData, d as Infer, E as Exotic, P as Prettify, M as Mutable, O as OmitProps, B as BaseWgslData, e as AnyWgslData } from './utilityTypes-0b50gROn.js';
+import * as smol from 'tinyest';
+import { Block } from 'tinyest';
 
-declare const TgpuSettableTrait: unique symbol;
-interface TgpuSettable {
-    readonly [TgpuSettableTrait]: true;
+/**
+ * Information extracted from transpiling a JS function.
+ */
+type TranspilationResult = {
+    argNames: string[];
+    body: smol.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[];
+};
+
+/**
+ * Used to transpile JS resources into SMoL on demand.
+ */
+interface JitTranspiler {
+    transpileFn(rawJs: string): TranspilationResult;
 }
 
-type PlumListener<T> = (newValue: T) => unknown;
+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;
+}
 
-interface TgpuSampler extends TgpuRenderResource, TgpuNamable {
-    readonly descriptor: GPUSamplerDescriptor;
+interface NotAllowed<TMsg> {
+    reason: TMsg;
+}
+type ExtensionGuard<TFlag, TMsg, TAllowed> = boolean extends TFlag ? NotAllowed<TMsg> : TAllowed;
+interface Storage {
+    usableAsStorage: true;
 }
+declare const Storage: Storage;
+declare function isUsableAsStorage<T>(value: T): value is T & Storage;
+
+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;
+/**
+ * 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;
+};
+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 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]]>;
+    asReadonly<TDimension extends StorageTextureDimension, TFormat extends StorageFormatOptions<TProps>>(params?: TextureViewParams<TDimension, TFormat>): ExtensionGuard<this['usableAsStorage'], "missing .$usage('storage')", TgpuReadonlyTexture<StorageTextureDimension extends TDimension ? Default<TProps['dimension'], '2d'> : TDimension, TexelFormatToDataTypeOrNever<StorageFormatOptions<TProps> extends TFormat ? TProps['format'] : TFormat>>>;
+    asWriteonly<TDimension extends StorageTextureDimension, TFormat extends StorageFormatOptions<TProps>>(params?: TextureViewParams<TDimension, TFormat>): ExtensionGuard<this['usableAsStorage'], "missing .$usage('storage')", TgpuWriteonlyTexture<StorageTextureDimension extends TDimension ? Default<TProps['dimension'], '2d'> : TDimension, TexelFormatToDataTypeOrNever<StorageFormatOptions<TProps> extends TFormat ? TProps['format'] : TFormat>>>;
+    asMutable<TDimension extends StorageTextureDimension, TFormat extends StorageFormatOptions<TProps>>(params?: TextureViewParams<TDimension, TFormat>): ExtensionGuard<this['usableAsStorage'], "missing .$usage('storage')", TgpuMutableTexture<StorageTextureDimension extends TDimension ? Default<TProps['dimension'], '2d'> : TDimension, TexelFormatToDataTypeOrNever<StorageFormatOptions<TProps> extends TFormat ? TProps['format'] : TFormat>>>;
+    asSampled<TDimension extends GPUTextureViewDimension, TFormat extends SampledFormatOptions<TProps>>(params?: TextureViewParams<TDimension, TFormat>): ExtensionGuard<this['usableAsSampled'], "missing .$usage('sampled')", TgpuSampledTexture<GPUTextureViewDimension extends TDimension ? Default<TProps['dimension'], '2d'> : TDimension, TexelFormatToChannelType[SampledFormatOptions<TProps> extends TFormat ? TProps['format'] : TFormat]>>;
+    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>, TgpuResolvable {
+    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>, TgpuResolvable {
+    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>, TgpuResolvable {
+    readonly access: 'mutable';
+}
+/**
+ * A texture accessed as sampled on the GPU.
+ */
+interface TgpuSampledTexture<TDimension extends GPUTextureViewDimension = GPUTextureViewDimension, TData extends ChannelData = ChannelData> extends TgpuResolvable {
+    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: TgpuBuffer<AnyTgpuData>): GPUBuffer;
+    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 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;
+    /**
+     * @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>>;
+    /**
+     * @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>>;
+    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>>;
+    destroy(): 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 device: GPUDevice;
+    readonly destroyed: boolean;
+    $usage<T extends ('uniform' | 'storage' | 'vertex')[]>(...usages: T): this & UnionToIntersection<LiteralToUsageType<T[number]>>;
+    $addFlags(flags: GPUBufferUsageFlags): this;
+    $device(device: GPUDevice): this;
+    write(data: Infer<TData> | 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;
+
+interface TgpuBufferUsage<TData extends BaseWgslData, TUsage extends BindableBufferUsage = BindableBufferUsage> extends TgpuResolvable {
+    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'> {
+}
+
+interface TgpuSampler {
+    readonly resourceType: 'sampler';
+}
+interface TgpuComparisonSampler {
+    readonly resourceType: 'sampler-comparison';
+}
+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.
@@ -33,10 +409,10 @@ type TgpuLayoutEntryBase = {
     visibility?: TgpuShaderStage[];
 };
 type TgpuLayoutUniform = TgpuLayoutEntryBase & {
-    uniform: AnyTgpuData | ((arrayLength: number) => AnyTgpuData);
+    uniform: AnyWgslData;
 };
 type TgpuLayoutStorage = TgpuLayoutEntryBase & {
-    storage: AnyTgpuData | ((arrayLength: number) => AnyTgpuData);
+    storage: AnyWgslData | ((arrayLength: number) => AnyWgslData);
     /** @default 'readonly' */
     access?: 'mutable' | 'readonly';
 };
@@ -61,23 +437,32 @@ type TgpuLayoutTexture<TSampleType extends GPUTextureSampleType = GPUTextureSamp
      */
     multisampled?: boolean;
 };
-type TgpuLayoutStorageTexture<TFormat extends GPUTextureFormat = GPUTextureFormat> = TgpuLayoutEntryBase & {
+type TgpuLayoutStorageTexture<TFormat extends StorageTextureTexelFormat = StorageTextureTexelFormat> = TgpuLayoutEntryBase & {
     storageTexture: TFormat;
     /** @default 'writeonly' */
     access?: 'readonly' | 'writeonly' | 'mutable';
     /** @default '2d' */
-    viewDimension?: GPUTextureViewDimension;
+    viewDimension?: StorageTextureDimension;
 };
 type TgpuLayoutExternalTexture = TgpuLayoutEntryBase & {
     externalTexture: Record<string, never>;
 };
 type TgpuLayoutEntry = TgpuLayoutUniform | TgpuLayoutStorage | TgpuLayoutSampler | TgpuLayoutTexture | TgpuLayoutStorageTexture | TgpuLayoutExternalTexture;
-type UnwrapRuntimeConstructorInner<T extends AnyTgpuData | ((_: number) => AnyTgpuData)> = T extends AnyTgpuData ? T : T extends (_: number) => infer Return ? Return : never;
-type UnwrapRuntimeConstructor<T extends AnyTgpuData | ((_: number) => AnyTgpuData)> = T extends unknown ? UnwrapRuntimeConstructorInner<T> : never;
+type UnwrapRuntimeConstructorInner<T extends BaseWgslData | ((_: number) => BaseWgslData)> = T extends BaseWgslData ? T : T extends (_: number) => infer Return ? Return : never;
+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;
     populate(entries: {
         [K in keyof OmitProps<Entries, null>]: LayoutEntryToInput<Entries[K]>;
     }): TgpuBindGroup<Entries>;
@@ -90,144 +475,107 @@ interface TgpuBindGroupLayout<Entries extends Record<string, TgpuLayoutEntry | n
 }
 type StorageUsageForEntry<T extends TgpuLayoutStorage> = T extends {
     access?: infer Access;
-} ? 'mutable' | 'readonly' extends Access ? TgpuBufferReadonly<UnwrapRuntimeConstructor<T['storage']>> | TgpuBufferMutable<UnwrapRuntimeConstructor<T['storage']>> : 'readonly' extends Access ? TgpuBufferReadonly<UnwrapRuntimeConstructor<T['storage']>> : 'mutable' extends Access ? TgpuBufferMutable<UnwrapRuntimeConstructor<T['storage']>> : TgpuBufferReadonly<UnwrapRuntimeConstructor<T['storage']>> | TgpuBufferMutable<UnwrapRuntimeConstructor<T['storage']>> : TgpuBufferReadonly<UnwrapRuntimeConstructor<T['storage']>>;
-type LayoutEntryToInput<T extends TgpuLayoutEntry | null> = T extends TgpuLayoutUniform ? TgpuBufferUsage<UnwrapRuntimeConstructor<T['uniform']>, 'uniform'> | (TgpuBuffer<UnwrapRuntimeConstructor<T['uniform']>> & Uniform) | GPUBuffer : T extends TgpuLayoutStorage ? StorageUsageForEntry<T> | (TgpuBuffer<UnwrapRuntimeConstructor<T['storage']>> & Storage) | GPUBuffer : T extends TgpuLayoutSampler ? GPUSampler : T extends TgpuLayoutTexture ? GPUTextureView : T extends TgpuLayoutStorageTexture ? GPUTextureView : T extends TgpuLayoutExternalTexture ? GPUExternalTexture : never;
-type BindLayoutEntry<T extends TgpuLayoutEntry | null> = T extends TgpuLayoutUniform ? TgpuBufferUniform<UnwrapRuntimeConstructor<T['uniform']>> : T extends TgpuLayoutStorage ? StorageUsageForEntry<T> : T extends TgpuLayoutSampler ? TgpuSampler : never;
+} ? '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 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 ? GPUSampler : T extends TgpuLayoutTexture ? // TODO: Allow sampled usages here
+GPUTextureView | TgpuTexture : T extends TgpuLayoutStorageTexture ? // TODO: Allow storage usages here
+GPUTextureView | TgpuTexture : 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 : 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;
 };
-declare function bindGroupLayout<Entries extends Record<string, TgpuLayoutEntry | null>>(entries: Entries): TgpuBindGroupLayout<Entries>;
-
-type StorageTextureAccess = 'read' | 'write' | 'read_write';
-type TextureScalarFormat = U32 | I32 | F32;
-type TexelFormat = Vec4u | Vec4i | Vec4f;
+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>>>;
 
-type Optional<T> = {
-    [P in keyof T]?: T[P] | undefined;
+type Wgsl = string | number | boolean | TgpuResolvable | AnyWgslData;
+declare const UnknownData: unique symbol;
+type UnknownData = typeof UnknownData;
+type Resource = {
+    value: unknown;
+    dataType: AnyWgslData | UnknownData;
 };
-interface TgpuAnyTextureView extends TgpuRenderResource {
-    readonly descriptor: GPUTextureViewDescriptor;
-    readonly texture: TgpuAnyTexture;
-    readonly dataType: TextureScalarFormat | TexelFormat;
-    readonly access: StorageTextureAccess | undefined;
-}
-interface TgpuAnyTexture {
-    readonly descriptor: Omit<GPUTextureDescriptor, 'usage'>;
-    get flags(): GPUTextureUsageFlags;
-}
-interface TgpuTextureExternal extends TgpuRenderResource, TgpuNamable {
-    readonly descriptor: Optional<GPUExternalTextureDescriptor>;
-    get source(): HTMLVideoElement | VideoFrame | undefined;
+type TgpuShaderStage = 'compute' | 'vertex' | 'fragment';
+interface FnToWgslOptions {
+    args: Resource[];
+    returnType: AnyWgslData;
+    body: Block;
+    externalMap: Record<string, unknown>;
 }
-
-type SetPlumAction<T> = T | ((prev: T) => T);
-interface TgpuRoot extends Unwrapper {
-    /**
-     * The GPU device associated with this root.
-     */
-    readonly device: GPUDevice;
-    /**
-     * @param typeSchema The type of data that this buffer will hold.
-     * @param initial The initial value of the buffer. (optional)
-     */
-    createBuffer<TData extends AnyTgpuData>(typeSchema: TData, initial?: Parsed<TData> | TgpuPlum<Parsed<TData>> | undefined): TgpuBuffer<TData>;
+/**
+ * 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;
     /**
-     * @param typeSchema The type of data that this buffer will hold.
-     * @param gpuBuffer A vanilla WebGPU buffer.
+     * Reserves a bind group number, and returns a placeholder that will be replaced
+     * with a concrete number at the end of the resolution process.
      */
-    createBuffer<TData extends AnyTgpuData>(typeSchema: TData, gpuBuffer: GPUBuffer): TgpuBuffer<TData>;
-    unwrap(resource: TgpuBuffer<AnyTgpuData>): GPUBuffer;
-    unwrap(resource: TgpuBindGroupLayout): GPUBindGroupLayout;
-    unwrap(resource: TgpuBindGroup): GPUBindGroup;
-    destroy(): void;
-}
-interface ExperimentalTgpuRoot extends TgpuRoot {
-    readonly jitTranspiler?: JitTranspiler | undefined;
+    allocateLayoutEntry(layout: TgpuBindGroupLayout): string;
     /**
-     * The current command encoder. This property will
-     * hold the same value until `flush()` is called.
+     * 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.
      */
-    readonly commandEncoder: GPUCommandEncoder;
-    readPlum<TPlum extends TgpuPlum>(plum: TPlum): ExtractPlumValue<TPlum>;
-    setPlum<TPlum extends TgpuPlum & TgpuSettable>(plum: TPlum, value: SetPlumAction<ExtractPlumValue<TPlum>>): void;
-    onPlumChange<TValue>(plum: TgpuPlum<TValue>, listener: PlumListener<TValue>): Unsubscribe;
-    setSource(texture: TgpuTextureExternal, source: HTMLVideoElement | VideoFrame): void;
-    isDirty(texture: TgpuTextureExternal): boolean;
-    markClean(texture: TgpuTextureExternal): void;
-    textureFor(view: TgpuAnyTexture | TgpuAnyTextureView): GPUTexture;
-    viewFor(view: TgpuAnyTextureView): GPUTextureView;
-    externalTextureFor(texture: TgpuTextureExternal): GPUExternalTexture;
-    samplerFor(sampler: TgpuSampler): GPUSampler;
+    allocateFixedEntry(layoutEntry: TgpuLayoutEntry, resource: object): {
+        group: string;
+        binding: number;
+    };
     /**
-     * Causes all commands enqueued by pipelines to be
-     * submitted to the GPU.
+     * Unwraps all layers of slot indirection and returns the concrete value if available.
+     * @throws {MissingSlotValueError}
      */
-    flush(): void;
-    makeRenderPipeline(options: RenderPipelineOptions): RenderPipelineExecutor;
-    makeComputePipeline(options: ComputePipelineOptions): ComputePipelineExecutor;
-}
-interface RenderPipelineOptions {
-    vertex: {
-        code: TgpuCode | BoundTgpuCode;
-        output: {
-            [K in symbol]: string;
-        } & {
-            [K in string]: AnyTgpuData;
-        };
+    unwrap<T>(eventual: Eventual<T>): T;
+    resolve(item: Wgsl, slotValueOverrides?: SlotValuePair<unknown>[]): string;
+    transpileFn(fn: string): {
+        argNames: string[];
+        body: Block;
+        externalNames: string[];
     };
-    fragment: {
-        code: TgpuCode | BoundTgpuCode;
-        target: Iterable<GPUColorTargetState | null>;
+    fnToWgsl(options: FnToWgslOptions): {
+        head: Wgsl;
+        body: Wgsl;
     };
-    primitive: GPUPrimitiveState;
-    externalLayouts?: GPUBindGroupLayout[];
-    label?: string;
-}
-interface ComputePipelineOptions {
-    code: TgpuCode | BoundTgpuCode;
-    workgroupSize?: readonly [number, number?, number?];
-    externalLayouts?: GPUBindGroupLayout[];
-    label?: string;
-}
-type RenderPipelineExecutorOptions = GPURenderPassDescriptor & {
-    vertexCount: number;
-    instanceCount?: number;
-    firstVertex?: number;
-    firstInstance?: number;
-    externalBindGroups?: GPUBindGroup[];
-};
-interface RenderPipelineExecutor {
-    execute(options: RenderPipelineExecutorOptions): void;
 }
-type ComputePipelineExecutorOptions = {
-    workgroups?: readonly [number, number?, number?];
-    externalBindGroups?: GPUBindGroup[];
-};
-interface ComputePipelineExecutor {
-    execute(options?: ComputePipelineExecutorOptions): void;
+interface TgpuResolvable {
+    readonly label?: string | undefined;
+    resolve(ctx: ResolutionCtx): string;
 }
-
 /**
- * Information extracted from transpiling a JS function.
+ * Represents a value that is available at resolution time.
  */
-type TranspilationResult = {
-    argNames: string[];
-    body: Block;
+type Eventual<T> = T | TgpuSlot<T>;
+type SlotValuePair<T> = [TgpuSlot<T>, T];
+type BindableBufferUsage = 'uniform' | 'readonly' | 'mutable';
+interface TgpuSlot<T> extends TgpuNamable {
+    readonly __brand: 'TgpuSlot';
+    readonly defaultValue: T | undefined;
+    readonly label?: string | undefined;
     /**
-     * All identifiers found in the function code that are not declared in the
-     * function itself, or in the block that is accessing that identifier.
+     * Used to determine if code generated using either value `a` or `b` in place
+     * of the slot will be equivalent. Defaults to `Object.is`.
      */
-    externalNames: string[];
-};
+    areEqual(a: T, b: T): boolean;
+    readonly value: Infer<T>;
+}
 
-/**
- * Used to transpile JS resources into SMoL on demand.
- */
-interface JitTranspiler {
-    transpileFn(rawJs: string): TranspilationResult;
+interface TgpuResolveOptions {
+    input: string | TgpuResolvable | AnyWgslData | (string | TgpuResolvable | AnyWgslData)[];
+    extraDependencies?: Record<string, TgpuResolvable | AnyWgslData | string | number> | undefined;
+    /**
+     * @default 'random'
+     */
+    names?: 'strict' | 'random' | undefined;
+    jitTranspiler?: JitTranspiler | undefined;
 }
+declare function resolve(options: TgpuResolveOptions): string;
 
 /**
  * Options passed into {@link init}.
@@ -235,6 +583,8 @@ interface JitTranspiler {
 type InitOptions = {
     adapter?: GPURequestAdapterOptions | undefined;
     device?: GPUDeviceDescriptor | undefined;
+    /** @default 'random' */
+    unstable_names?: 'random' | 'strict' | undefined;
     unstable_jitTranspiler?: JitTranspiler | undefined;
 };
 /**
@@ -242,6 +592,8 @@ type InitOptions = {
  */
 type InitFromDeviceOptions = {
     device: GPUDevice;
+    /** @default 'random' */
+    unstable_names?: 'random' | 'strict' | undefined;
     unstable_jitTranspiler?: JitTranspiler | undefined;
 };
 /**
@@ -262,7 +614,7 @@ type InitFromDeviceOptions = {
  * const root = await tgpu.init({ adapter: adapterOptions, device: deviceDescriptor });
  * ```
  */
-declare function init(options?: InitOptions): Promise<ExperimentalTgpuRoot>;
+declare function init(options?: InitOptions): Promise<TgpuRoot>;
 /**
  * Creates a root from the given device, instead of requesting it like @see init.
  *
@@ -272,63 +624,48 @@ declare function init(options?: InitOptions): Promise<ExperimentalTgpuRoot>;
  * const root = tgpu.initFromDevice({ device });
  * ```
  */
-declare function initFromDevice(options: InitFromDeviceOptions): ExperimentalTgpuRoot;
+declare function initFromDevice(options: InitFromDeviceOptions): TgpuRoot;
 
 /**
- * @deprecated Use the `root.createBuffer` API instead, accessible through `await tgpu.init()`
- *
- * @param typeSchema The type of data that this buffer will hold.
- * @param initial The initial value of the buffer. (optional)
- */
-declare function createBuffer<TData extends AnyTgpuData>(typeSchema: TData, initial?: Parsed<TData> | TgpuPlum<Parsed<TData>> | undefined): TgpuBuffer<TData>;
-/**
- * @deprecated Use the `root.createBuffer` API instead, accessible through `await tgpu.init()`
+ * An error that happens during resolution of WGSL code.
+ * Contains a trace of all ancestor resolvables in
+ * which this error originated.
  *
- * @param typeSchema The type of data that this buffer will hold.
- * @param gpuBuffer A vanilla WebGPU buffer.
+ * @category Errors
  */
-declare function createBuffer<TData extends AnyTgpuData>(typeSchema: TData, gpuBuffer: GPUBuffer): TgpuBuffer<TData>;
-
-declare function write<TData extends AnyTgpuData>(buffer: TgpuBuffer<TData>, data: Parsed<TData>): void;
-declare function read<TData extends AnyTgpuData>(buffer: TgpuBuffer<TData>): Promise<Parsed<TData>>;
-
+declare class ResolutionError extends Error {
+    readonly cause: unknown;
+    readonly trace: (TgpuResolvable | AnyWgslData)[];
+    constructor(cause: unknown, trace: (TgpuResolvable | AnyWgslData)[]);
+    appendToTrace(ancestor: TgpuResolvable | AnyWgslData): ResolutionError;
+}
 /**
  * @category Errors
  */
-declare class RecursiveDataTypeError extends Error {
-    constructor();
+declare class NotUniformError extends Error {
+    constructor(value: TgpuBuffer$1<AnyData>);
 }
 
-declare const std: {
-    add<T extends vecBase>(lhs: T, rhs: T): T;
-    sub<T extends vecBase>(lhs: T, rhs: T): T;
-    mul: <T extends vecBase>(s: number, v: T) => T;
-    dot<T extends vecBase>(lhs: T, rhs: T): number;
-    normalize: <T extends vecBase>(v: T) => T;
-    cross<T extends vec3f | vec3i | vec3u>(a: T, b: T): T;
-    fract(a: number): number;
-    length<T extends vecBase>(vector: T): number;
-    sin(radians: number): number;
-    cos(radians: number): number;
-};
+type TgpuBuffer<TData extends AnyData> = TgpuBuffer$1<Exotic<TData>>;
+type TgpuBufferMutable<TData extends AnyData> = TgpuBufferMutable$1<Exotic<TData>>;
+type TgpuBufferReadonly<TData extends AnyData> = TgpuBufferReadonly$1<Exotic<TData>>;
+type TgpuBufferUniform<TData extends AnyData> = TgpuBufferUniform$1<Exotic<TData>>;
 
 /**
  * @module typegpu
  */
 
 declare const tgpu: {
-    /** @deprecated Use `'uniform'` string literal instead. */
+    /** @hidden @deprecated Use `'uniform'` string literal instead. */
     Uniform: "uniform";
-    /** @deprecated Use `'storage'` string literal instead. */
+    /** @hidden @deprecated Use `'storage'` string literal instead. */
     Storage: "storage";
-    /** @deprecated Use `'vertex'` string literal instead. */
+    /** @hidden @deprecated Use `'vertex'` string literal instead. */
     Vertex: "vertex";
     bindGroupLayout: typeof bindGroupLayout;
     init: typeof init;
     initFromDevice: typeof initFromDevice;
-    createBuffer: typeof createBuffer;
-    read: typeof read;
-    write: typeof write;
+    resolve: typeof resolve;
 };
 
-export { AnyTgpuData, type BindLayoutEntry, type LayoutEntryToInput, RecursiveDataTypeError, Storage, type TgpuBindGroup, type TgpuBindGroupLayout, TgpuBuffer, type TgpuLayoutEntry, type TgpuLayoutSampler, type TgpuLayoutUniform, Uniform, tgpu as default, std, tgpu };
+export { type BindLayoutEntry, type InitFromDeviceOptions, type InitOptions, type LayoutEntryToInput, NotUniformError, type Render, ResolutionError, type Sampled, Storage, type TextureProps, type TgpuAnyTextureView, type TgpuBindGroup, type TgpuBindGroupLayout, type TgpuBuffer, type TgpuBufferMutable, type TgpuBufferReadonly, type TgpuBufferUniform, type TgpuLayoutEntry, type TgpuLayoutExternalTexture, type TgpuLayoutSampler, type TgpuLayoutStorage, type TgpuLayoutStorageTexture, type TgpuLayoutTexture, type TgpuLayoutUniform, type TgpuMutableTexture, type TgpuReadonlyTexture, type TgpuRoot, type TgpuSampledTexture, type TgpuSampler, type TgpuTexture, type TgpuWriteonlyTexture, Uniform, Vertex, tgpu as default, isBuffer, isComparisonSampler, isSampledTextureView, isSampler, isStorageTextureView, isTexture, isUsableAsRender, isUsableAsSampled, isUsableAsStorage, isUsableAsUniform, isUsableAsVertex, tgpu };