typegpu 0.3.0-alpha.5 → 0.3.0-alpha.7

package/index.d.ts

@@ -1,6 +1,6 @@
-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, O as OmitProps, P as Prettify, M as Mutable, W as WgslTypeLiteral, B as BaseWgslData, e as AnyWgslData } from './utilityTypes-CRzYf73j.js';
+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 * as smol from 'tinyest';
-import { Block } from 'tinyest';
 
 /**
  * Information extracted from transpiling a JS function.
@@ -22,309 +22,6 @@ 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;
-}
-
-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: 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.
@@ -340,249 +37,68 @@ interface TgpuRoot extends Unwrapper {
      * @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>>;
     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>;
     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 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 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 extends TgpuResolvable {
-    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.
-     *
-     * 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: GPUSamplerBindingType;
-};
-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 | TgpuLayoutTexture | TgpuLayoutStorageTexture | TgpuLayoutExternalTexture;
-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;
-    /**
-     * @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>;
+interface TgpuResolveOptions {
     /**
-     * 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.
+     * Map of external names to their resolvable values.
      */
-    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 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;
-};
-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 Wgsl = string | number | boolean | TgpuResolvable | AnyWgslData;
-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;
+    externals: Record<string, TgpuResolvable | AnyWgslData | boolean | number>;
     /**
-     * Reserves a bind group number, and returns a placeholder that will be replaced
-     * with a concrete number at the end of the resolution process.
+     * The code template to use for the resolution. All external names will be replaced with their resolved values.
+     * @default ''
      */
-    allocateLayoutEntry(layout: TgpuBindGroupLayout): string;
+    template?: string | undefined;
     /**
-     * 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.
+     * The naming strategy used for generating identifiers for resolved externals and their dependencies.
+     * @default 'random'
      */
-    allocateFixedEntry(layoutEntry: TgpuLayoutEntry, resource: object): {
-        group: string;
-        binding: number;
-    };
+    names?: 'strict' | 'random' | undefined;
     /**
-     * Unwraps all layers of slot indirection and returns the concrete value if available.
-     * @throws {MissingSlotValueError}
+     * Optional JIT transpiler for resolving TGSL functions.
+     * @experimental
      */
-    unwrap<T>(eventual: Eventual<T>): T;
-    resolve(item: Wgsl, slotValueOverrides?: SlotValuePair<unknown>[]): string;
-    transpileFn(fn: string): {
-        argNames: string[];
-        body: Block;
-        externalNames: string[];
-    };
-    fnToWgsl(options: FnToWgslOptions): {
-        head: Wgsl;
-        body: Wgsl;
-    };
-}
-interface TgpuResolvable {
-    readonly label?: string | undefined;
-    resolve(ctx: ResolutionCtx): string;
+    unstable_jitTranspiler?: JitTranspiler | undefined;
 }
 /**
- * Represents a value that is available at resolution time.
+ * Resolves a template with external values. Each external will get resolved to a code string and replaced in the template.
+ * Any dependencies of the externals will also be resolved and included in the output.
+ * @param options - The options for the resolution.
+ *
+ * @returns The resolved code.
+ *
+ * @example
+ * ```ts
+ * const Gradient = d.struct({
+ *   from: d.vec3f,
+ *   to: d.vec3f,
+ * });
+ *
+ * const resolved = tgpu.resolve({
+ *   template: `
+ *     fn getGradientAngle(gradient: Gradient) -> f32 {
+ *       return atan(gradient.to.y - gradient.from.y, gradient.to.x - gradient.from.x);
+ *     }
+ *   `,
+ *   externals: {
+ *     Gradient,
+ *   },
+ * });
+ *
+ * console.log(resolved);
+ * // struct Gradient_0 {
+ * //   from: vec3f,
+ * //   to: vec3f,
+ * // }
+ * // fn getGradientAngle(gradient: Gradient_0) -> f32 {
+ * //   return atan(gradient.to.y - gradient.from.y, gradient.to.x - gradient.from.x);
+ * // }
+ * ```
  */
-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;
-    /**
-     * 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 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;
 
 /**
@@ -643,9 +159,9 @@ declare function initFromDevice(options: InitFromDeviceOptions): TgpuRoot;
  */
 declare class ResolutionError extends Error {
     readonly cause: unknown;
-    readonly trace: (TgpuResolvable | AnyWgslData)[];
-    constructor(cause: unknown, trace: (TgpuResolvable | AnyWgslData)[]);
-    appendToTrace(ancestor: TgpuResolvable | AnyWgslData): ResolutionError;
+    readonly trace: unknown[];
+    constructor(cause: unknown, trace: unknown[]);
+    appendToTrace(ancestor: unknown): ResolutionError;
 }
 /**
  * @category Errors
@@ -676,4 +192,4 @@ declare const tgpu: {
     resolve: typeof resolve;
 };
 
-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 };
+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 };