typegpu 0.5.6 → 0.5.7

package/index.d.cts

@@ -1,1047 +1,6 @@
-import { A as AnyWgslData, T as TgpuNamable, I as Infer, $ as $internal, 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, D as Decorated, n as AnyWgslStruct, o as $repr, B as BaseData, L as Location, W as WgslStruct, p as WgslArray, q as Disarray, r as AnyUnstruct, s as VertexFormat, t as TgpuVertexAttrib, K as KindToDefaultFormatMap, u as KindToAcceptedAttribMap, v as AnyData, O as OmitProps, P as Prettify, M as Mutable, w as WgslTypeLiteral, x as UnionToIntersection, y as InferPartial, z as MemIdentity, C as Default, E as InferGPU, G as AnyVecInstance, H as AnyMatInstance } from './dataTypes-6k4EJeol.cjs';
-import { A as AnyAttribute, a as AnyComputeBuiltin, D as Decorate, I as IsBuiltin, H as HasCustomLocation, b as AnyFragmentInputBuiltin, c as AnyFragmentOutputBuiltin, O as OmitBuiltins } from './attributes-zljQ-iA7.cjs';
-import * as tinyest from 'tinyest';
-import { ArgNames, Block } from 'tinyest';
-import { T as TgpuTexture, R as Render, a as TgpuReadonlyTexture, b as TgpuWriteonlyTexture, c as TgpuMutableTexture, d as TgpuSampledTexture, e as TgpuSampler, f as TgpuComparisonSampler, S as StorageFlag, g as StorageTextureTexelFormat, h as StorageTextureDimension, C as ChannelFormatToSchema, V as ViewDimensionToDimension, i as TexelFormatToDataType, j as Sampled, k as TextureProps, l as ChannelTypeToLegalFormats, m as SampleTypeToStringChannelType, n as TgpuAnyTextureView, s as sampler, o as comparisonSampler } from './sampler-NRTAYTIW.cjs';
-export { y as Storage, q as isComparisonSampler, r as isSampledTextureView, p as isSampler, t as isStorageTextureView, u as isTexture, v as isUsableAsRender, w as isUsableAsSampled, x as isUsableAsStorage } from './sampler-NRTAYTIW.cjs';
-
-interface TgpuConst<TDataType extends AnyWgslData = AnyWgslData> extends TgpuNamable {
-    readonly value: Infer<TDataType>;
-    readonly [$internal]: {
-        readonly dataType: TDataType;
-    };
-}
-/**
- * Creates a module constant with specified value.
- */
-declare function constant<TDataType extends AnyWgslData>(dataType: TDataType, value: Infer<TDataType>): TgpuConst<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;
-
-/**
- * Information extracted from transpiling a JS function.
- */
-type TranspilationResult = {
-    argNames: tinyest.ArgNames;
-    body: tinyest.Block;
-    /**
-     * All identifiers found in the function code that are not declared in the
-     * function itself, or in the block that is accessing that identifier.
-     */
-    externalNames: string[];
-};
-type InferArgs<T extends unknown[]> = {
-    [Idx in keyof T]: Infer<T[Idx]>;
-};
-type InferReturn<T> = T extends undefined ? void : Infer<T>;
-type JsImplementation<Args extends unknown[] | Record<string, unknown> = unknown[] | Record<string, unknown>, Return = unknown> = (...args: Args extends unknown[] ? InferArgs<Args> : Args extends Record<string, never> ? [] : [InferIO<Args>]) => InferReturn<Return>;
-type Implementation<Args extends unknown[] | Record<string, unknown> = unknown[] | Record<string, unknown>, Return = unknown> = string | JsImplementation<Args, Return>;
-type BaseIOData = F32 | F16 | I32 | U32 | Vec2f | Vec3f | Vec4f | Vec2h | Vec3h | Vec4h | Vec2i | Vec3i | Vec4i | Vec2u | Vec3u | Vec4u;
-type 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;
-
-/**
- * Describes a compute entry function signature (its arguments, return type and workgroup size)
- */
-type TgpuComputeFnShellHeader<ComputeIn extends Record<string, AnyComputeBuiltin>> = {
-    readonly argTypes: [AnyWgslStruct] | [];
-    readonly returnType: undefined;
-    readonly workgroupSize: [number, number, number];
-    readonly isEntry: true;
-};
-/**
- * Describes a compute entry function signature (its arguments, return type and workgroup size).
- * Allows creating tgpu compute functions by calling this shell
- * and passing the implementation (as WGSL string or JS function) as the argument.
- */
-type TgpuComputeFnShell<ComputeIn extends Record<string, AnyComputeBuiltin>> = TgpuComputeFnShellHeader<ComputeIn> /**
- * Creates a type-safe implementation of this signature
- */ & ((implementation: (input: InferIO<ComputeIn>) => undefined) => TgpuComputeFn<ComputeIn>) & 
-/**
- * @param implementation
- *   Raw WGSL function implementation with header and body
- *   without `fn` keyword and function name
- *   e.g. `"(x: f32) -> f32 { return x; }"`;
- */
-((implementation: string) => TgpuComputeFn<ComputeIn>) & ((strings: TemplateStringsArray, ...values: unknown[]) => TgpuComputeFn<ComputeIn>) & {
-    /**
-     * @deprecated Invoke the shell as a function instead.
-     */
-    does: ((implementation: (input: InferIO<ComputeIn>) => undefined) => TgpuComputeFn<ComputeIn>) & 
-    /**
-     * @param implementation
-     *   Raw WGSL function implementation with header and body
-     *   without `fn` keyword and function name
-     *   e.g. `"(x: f32) -> f32 { return x; }"`;
-     */
-    ((implementation: string) => TgpuComputeFn<ComputeIn>);
-};
-interface TgpuComputeFn<ComputeIn extends Record<string, AnyComputeBuiltin> = Record<string, AnyComputeBuiltin>> extends TgpuNamable {
-    readonly shell: TgpuComputeFnShell<ComputeIn>;
-    $uses(dependencyMap: Record<string, unknown>): this;
-}
-declare function computeFn(options: {
-    workgroupSize: number[];
-}): TgpuComputeFnShell<{}>;
-declare function computeFn<ComputeIn extends Record<string, AnyComputeBuiltin>>(options: {
-    in: ComputeIn;
-    workgroupSize: number[];
-}): TgpuComputeFnShell<ComputeIn>;
-
-/**
- * Used to transpile JS resources into tinyest on demand.
- */
-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';
-    [$repr]: Infer<T>;
-    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>;
-    [$repr]: Infer<T>;
-    readonly '~providing'?: Providing | undefined;
-    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';
-    [$repr]: Infer<T>;
-    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];
-type Providing = {
-    inner: unknown;
-    pairs: SlotValuePair[];
-};
-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 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 IOLayoutToSchema<T extends IOLayout> = T extends BaseData ? Decorate<T, Location<0>> : T extends IORecord ? WgslStruct<WithLocations<T>> : never;
-
-type FragmentOutConstrained = Vec4f | Decorated<Vec4f, [Location<number>]> | AnyFragmentOutputBuiltin | IORecord<Vec4f | Decorated<Vec4f, [Location<number>]> | AnyFragmentOutputBuiltin>;
-type FragmentInConstrained = IORecord<BaseIOData | Decorated<BaseIOData, AnyAttribute<never>[]> | AnyFragmentInputBuiltin>;
-/**
- * Describes a fragment entry function signature (its arguments, return type and targets)
- */
-type TgpuFragmentFnShellHeader<FragmentIn extends FragmentInConstrained, FragmentOut extends FragmentOutConstrained> = {
-    readonly argTypes: [AnyWgslStruct] | [];
-    readonly targets: FragmentOut;
-    readonly returnType: FragmentOut;
-    readonly isEntry: true;
-};
-/**
- * Describes a fragment entry function signature (its arguments, return type and targets).
- * Allows creating tgpu fragment functions by calling this shell
- * and passing the implementation (as WGSL string or JS function) as the argument.
- */
-type TgpuFragmentFnShell<FragmentIn extends FragmentInConstrained, FragmentOut extends FragmentOutConstrained> = TgpuFragmentFnShellHeader<FragmentIn, FragmentOut> /**
- * Creates a type-safe implementation of this signature
- */ & ((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; }"`;
- */
-((implementation: string) => TgpuFragmentFn<OmitBuiltins<FragmentIn>, OmitBuiltins<FragmentOut>>) & ((strings: TemplateStringsArray, ...values: unknown[]) => TgpuFragmentFn<OmitBuiltins<FragmentIn>, OmitBuiltins<FragmentOut>>) & {
-    /**
-     * @deprecated Invoke the shell as a function instead.
-     */
-    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; }"`;
-     */
-    ((implementation: string) => TgpuFragmentFn<OmitBuiltins<FragmentIn>, OmitBuiltins<FragmentOut>>);
-};
-interface TgpuFragmentFn<Varying extends FragmentInConstrained = FragmentInConstrained, Output extends FragmentOutConstrained = FragmentOutConstrained> extends TgpuNamable {
-    readonly shell: TgpuFragmentFnShellHeader<Varying, Output>;
-    readonly outputType: IOLayoutToSchema<Output>;
-    $uses(dependencyMap: Record<string, unknown>): this;
-}
-declare function fragmentFn<FragmentOut extends FragmentOutConstrained>(options: {
-    out: FragmentOut;
-}): TgpuFragmentFnShell<{}, FragmentOut>;
-declare function fragmentFn<FragmentIn extends FragmentInConstrained, FragmentOut extends FragmentOutConstrained>(options: {
-    in: FragmentIn;
-    out: FragmentOut;
-}): TgpuFragmentFnShell<FragmentIn, FragmentOut>;
-
-/**
- * Describes a vertex entry function signature (its arguments, return type and attributes)
- */
-type TgpuVertexFnShellHeader<VertexIn extends IOLayout, VertexOut extends IOLayout> = {
-    readonly argTypes: [AnyWgslStruct] | [];
-    readonly returnType: VertexOut;
-    readonly attributes: [VertexIn];
-    readonly isEntry: true;
-};
-/**
- * Describes a vertex entry function signature (its arguments, return type and attributes).
- * Allows creating tgpu vertex functions by calling this shell
- * and passing the implementation (as WGSL string or JS function) as the argument.
- */
-type TgpuVertexFnShell<VertexIn extends IOLayout, VertexOut extends IOLayout> = TgpuVertexFnShellHeader<VertexIn, VertexOut> & ((implementation: (input: InferIO<VertexIn>) => InferIO<VertexOut>) => TgpuVertexFn<OmitBuiltins<VertexIn>, OmitBuiltins<VertexOut>>) & ((implementation: string) => TgpuVertexFn<OmitBuiltins<VertexIn>, OmitBuiltins<VertexOut>>) & ((strings: TemplateStringsArray, ...values: unknown[]) => TgpuVertexFn<OmitBuiltins<VertexIn>, OmitBuiltins<VertexOut>>) & {
-    /**
-     * @deprecated Invoke the shell as a function instead.
-     */
-    does: ((implementation: (input: InferIO<VertexIn>) => InferIO<VertexOut>) => TgpuVertexFn<OmitBuiltins<VertexIn>, OmitBuiltins<VertexOut>>) & ((implementation: string) => TgpuVertexFn<OmitBuiltins<VertexIn>, OmitBuiltins<VertexOut>>);
-};
-interface TgpuVertexFn<VertexIn extends IOLayout = IOLayout, VertexOut extends IOLayout = IOLayout> extends TgpuNamable {
-    readonly shell: TgpuVertexFnShellHeader<VertexIn, VertexOut>;
-    readonly outputType: IOLayoutToSchema<VertexOut>;
-    readonly inputType: IOLayoutToSchema<VertexIn>;
-    $uses(dependencyMap: Record<string, unknown>): this;
-}
-declare function vertexFn<VertexOut extends IORecord>(options: {
-    out: VertexOut;
-}): TgpuVertexFnShell<{}, VertexOut>;
-declare function vertexFn<VertexIn extends IORecord, VertexOut extends IORecord>(options: {
-    in: VertexIn;
-    out: VertexOut;
-}): TgpuVertexFnShell<VertexIn, 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
- * - WgslStruct<{ a: Vec3f, b: unorm8x2 }>
- * - WgslStruct<{ nested: WgslStruct<{ a: Vec3f }> }>
- */
-type DataToContainedAttribs<T> = T extends AnyWgslStruct | AnyUnstruct ? {
-    [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']]> : T extends Decorated<infer TInner> ? DataToContainedAttribs<TInner> : 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>;
-    readonly vertexLayout: GPUVertexBufferLayout;
-    schemaForCount(n: number): TData;
-}
-declare function vertexLayout<TData extends WgslArray | Disarray>(schemaForCount: (count: number) => TData, stepMode?: 'vertex' | 'instance'): TgpuVertexLayout<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<TData> & VertexFlag): TgpuRenderPipeline<IOLayout>;
-    with<Entries extends Record<string, TgpuLayoutEntry | null>>(bindGroupLayout: TgpuBindGroupLayout<Entries>, bindGroup: TgpuBindGroup<Entries>): TgpuRenderPipeline<IOLayout>;
-    withColorAttachment(attachment: FragmentOutToColorAttachment<Output>): TgpuRenderPipeline<IOLayout>;
-    withDepthStencilAttachment(attachment: DepthStencilAttachment): TgpuRenderPipeline<IOLayout>;
-    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 DepthStencilAttachment {
-    /**
-     * A {@link GPUTextureView} | ({@link TgpuTexture} & {@link Render}) describing the texture subresource that will be output to
-     * and read from for this depth/stencil attachment.
-     */
-    view: (TgpuTexture & Render) | GPUTextureView;
-    /**
-     * Indicates the value to clear {@link GPURenderPassDepthStencilAttachment#view}'s depth component
-     * to prior to executing the render pass. Ignored if {@link GPURenderPassDepthStencilAttachment#depthLoadOp}
-     * is not {@link GPULoadOp#"clear"}. Must be between 0.0 and 1.0, inclusive (unless unrestricted depth is enabled).
-     */
-    depthClearValue?: number;
-    /**
-     * Indicates the load operation to perform on {@link GPURenderPassDepthStencilAttachment#view}'s
-     * depth component prior to executing the render pass.
-     * Note: It is recommended to prefer clearing; see {@link GPULoadOp#"clear"} for details.
-     */
-    depthLoadOp?: GPULoadOp;
-    /**
-     * The store operation to perform on {@link GPURenderPassDepthStencilAttachment#view}'s
-     * depth component after executing the render pass.
-     */
-    depthStoreOp?: GPUStoreOp;
-    /**
-     * Indicates that the depth component of {@link GPURenderPassDepthStencilAttachment#view}
-     * is read only.
-     */
-    depthReadOnly?: boolean;
-    /**
-     * Indicates the value to clear {@link GPURenderPassDepthStencilAttachment#view}'s stencil component
-     * to prior to executing the render pass. Ignored if {@link GPURenderPassDepthStencilAttachment#stencilLoadOp}
-     * is not {@link GPULoadOp#"clear"}.
-     * The value will be converted to the type of the stencil aspect of `view` by taking the same
-     * number of LSBs as the number of bits in the stencil aspect of one texel block|texel of `view`.
-     */
-    stencilClearValue?: GPUStencilValue;
-    /**
-     * Indicates the load operation to perform on {@link GPURenderPassDepthStencilAttachment#view}'s
-     * stencil component prior to executing the render pass.
-     * Note: It is recommended to prefer clearing; see {@link GPULoadOp#"clear"} for details.
-     */
-    stencilLoadOp?: GPULoadOp;
-    /**
-     * The store operation to perform on {@link GPURenderPassDepthStencilAttachment#view}'s
-     * stencil component after executing the render pass.
-     */
-    stencilStoreOp?: GPUStoreOp;
-    /**
-     * Indicates that the stencil component of {@link GPURenderPassDepthStencilAttachment#view}
-     * is read only.
-     */
-    stencilReadOnly?: boolean;
-}
-
-interface Unwrapper {
-    readonly device: GPUDevice;
-    unwrap(resource: TgpuComputePipeline): GPUComputePipeline;
-    unwrap(resource: TgpuRenderPipeline): GPURenderPipeline;
-    unwrap(resource: TgpuBindGroupLayout): GPUBindGroupLayout;
-    unwrap(resource: TgpuBindGroup): GPUBindGroup;
-    unwrap(resource: TgpuBuffer<AnyData>): GPUBuffer;
-    unwrap(resource: TgpuTexture): GPUTexture;
-    unwrap(resource: TgpuReadonlyTexture | TgpuWriteonlyTexture | TgpuMutableTexture | TgpuSampledTexture): GPUTextureView;
-    unwrap(resource: TgpuVertexLayout): GPUVertexBufferLayout;
-    unwrap(resource: TgpuSampler): GPUSampler;
-    unwrap(resource: TgpuComparisonSampler): GPUSampler;
-}
-
-interface WithCompute {
-    createPipeline(): TgpuComputePipeline;
-}
-type ValidateFragmentIn<VertexOut extends IORecord, FragmentIn extends FragmentInConstrained, FragmentOut extends FragmentOutConstrained> = 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 FragmentInConstrained, FragmentOut extends FragmentOutConstrained>(...args: ValidateFragmentIn<VertexOut, FragmentIn, FragmentOut>): WithFragment<FragmentOut>;
-}
-interface WithFragment<Output extends FragmentOutConstrained = FragmentOutConstrained> {
-    withPrimitive(primitiveState: GPUPrimitiveState | undefined): WithFragment<Output>;
-    withDepthStencil(depthStencilState: GPUDepthStencilState | undefined): WithFragment<Output>;
-    withMultisample(multisampleState: GPUMultisampleState | 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 RenderPass {
-    /**
-     * Sets the viewport used during the rasterization stage to linearly map from
-     * NDC (i.e., normalized device coordinates) to viewport coordinates.
-     * @param x - Minimum X value of the viewport in pixels.
-     * @param y - Minimum Y value of the viewport in pixels.
-     * @param width - Width of the viewport in pixels.
-     * @param height - Height of the viewport in pixels.
-     * @param minDepth - Minimum depth value of the viewport.
-     * @param maxDepth - Maximum depth value of the viewport.
-     */
-    setViewport(x: number, y: number, width: number, height: number, minDepth: number, maxDepth: number): void;
-    /**
-     * Sets the scissor rectangle used during the rasterization stage.
-     * After transformation into viewport coordinates any fragments which fall outside the scissor
-     * rectangle will be discarded.
-     * @param x - Minimum X value of the scissor rectangle in pixels.
-     * @param y - Minimum Y value of the scissor rectangle in pixels.
-     * @param width - Width of the scissor rectangle in pixels.
-     * @param height - Height of the scissor rectangle in pixels.
-     */
-    setScissorRect(x: number, y: number, width: number, height: number): void;
-    /**
-     * Sets the constant blend color and alpha values used with {@link GPUBlendFactor#constant}
-     * and {@link GPUBlendFactor#"one-minus-constant"} {@link GPUBlendFactor}s.
-     * @param color - The color to use when blending.
-     */
-    setBlendConstant(color: GPUColor): void;
-    /**
-     * Sets the {@link RenderState#[[stencilReference]]} value used during stencil tests with
-     * the {@link GPUStencilOperation#"replace"} {@link GPUStencilOperation}.
-     * @param reference - The new stencil reference value.
-     */
-    setStencilReference(reference: GPUStencilValue): undefined;
-    /**
-     * @param queryIndex - The index of the query in the query set.
-     */
-    beginOcclusionQuery(queryIndex: GPUSize32): undefined;
-    endOcclusionQuery(): undefined;
-    /**
-     * Executes the commands previously recorded into the given {@link GPURenderBundle}s as part of
-     * this render pass.
-     * When a {@link GPURenderBundle} is executed, it does not inherit the render pass's pipeline, bind
-     * groups, or vertex and index buffers. After a {@link GPURenderBundle} has executed, the render
-     * pass's pipeline, bind group, and vertex/index buffer state is cleared
-     * (to the initial, empty values).
-     * Note: The state is cleared, not restored to the previous state.
-     * This occurs even if zero {@link GPURenderBundle|GPURenderBundles} are executed.
-     * @param bundles - List of render bundles to execute.
-     */
-    executeBundles(bundles: Iterable<GPURenderBundle>): undefined;
-    setPipeline(pipeline: TgpuRenderPipeline): void;
-    /**
-     * Sets the current index buffer.
-     * @param buffer - Buffer containing index data to use for subsequent drawing commands.
-     * @param indexFormat - Format of the index data contained in `buffer`.
-     * @param offset - Offset in bytes into `buffer` where the index data begins. Defaults to `0`.
-     * @param size - Size in bytes of the index data in `buffer`.
-     * 	             Defaults to the size of the buffer minus the offset.
-     */
-    setIndexBuffer<TData extends WgslArray | Disarray>(buffer: TgpuBuffer<TData> | GPUBuffer, indexFormat: GPUIndexFormat, offset?: GPUSize64, size?: GPUSize64): void;
-    setVertexBuffer<TData extends WgslArray | Disarray>(vertexLayout: TgpuVertexLayout<TData>, buffer: (TgpuBuffer<TData> & VertexFlag) | GPUBuffer, offset?: GPUSize64, size?: GPUSize64): void;
-    setBindGroup<Entries extends Record<string, TgpuLayoutEntry | null>>(bindGroupLayout: TgpuBindGroupLayout<Entries>, bindGroup: TgpuBindGroup<Entries> | GPUBindGroup): void;
-    /**
-     * Draws primitives.
-     * @param vertexCount - The number of vertices to draw.
-     * @param instanceCount - The number of instances to draw.
-     * @param firstVertex - Offset into the vertex buffers, in vertices, to begin drawing from.
-     * @param firstInstance - First instance to draw.
-     */
-    draw(vertexCount: number, instanceCount?: number | undefined, firstVertex?: number | undefined, firstInstance?: number | undefined): void;
-    /**
-     * Draws indexed primitives.
-     * @param indexCount - The number of indices to draw.
-     * @param instanceCount - The number of instances to draw.
-     * @param firstIndex - Offset into the index buffer, in indices, begin drawing from.
-     * @param baseVertex - Added to each index value before indexing into the vertex buffers.
-     * @param firstInstance - First instance to draw.
-     */
-    drawIndexed(indexCount: number, instanceCount?: number | undefined, firstIndex?: number | undefined, baseVertex?: number | undefined, firstInstance?: number | undefined): void;
-    /**
-     * Draws primitives using parameters read from a {@link GPUBuffer}.
-     * Packed block of **four 32-bit unsigned integer values (16 bytes total)**, given in the same
-     * order as the arguments for {@link GPURenderEncoderBase#draw}. For example:
-     * @param indirectBuffer - Buffer containing the indirect draw parameters.
-     * @param indirectOffset - Offset in bytes into `indirectBuffer` where the drawing data begins.
-     */
-    drawIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): undefined;
-    /**
-     * Draws indexed primitives using parameters read from a {@link GPUBuffer}.
-     * Tightly packed block of **five 32-bit unsigned integer values (20 bytes total)**, given in
-     * the same order as the arguments for {@link GPURenderEncoderBase#drawIndexed}. For example:
-     * @param indirectBuffer - Buffer containing the indirect drawIndexed parameters.
-     * @param indirectOffset - Offset in bytes into `indirectBuffer` where the drawing data begins.
-     */
-    drawIndexedIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): 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<TData> | undefined): TgpuBuffer<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<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;
-    createUniform<TData extends AnyWgslData>(typeSchema: TData, initialOrBuffer?: Infer<TData> | GPUBuffer): TgpuBufferUniform<TData> & TgpuFixedBufferUsage<TData>;
-    createMutable<TData extends AnyWgslData>(typeSchema: TData, initialOrBuffer?: Infer<TData> | GPUBuffer): TgpuBufferMutable<TData> & TgpuFixedBufferUsage<TData>;
-    createReadonly<TData extends AnyWgslData>(typeSchema: TData, initialOrBuffer?: Infer<TData> | GPUBuffer): TgpuBufferReadonly<TData> & TgpuFixedBufferUsage<TData>;
-    createTexture<TWidth extends number, THeight extends number, TDepth extends number, TSize extends readonly [TWidth] | readonly [TWidth, THeight] | readonly [TWidth, THeight, TDepth], TFormat extends GPUTextureFormat, TMipLevelCount extends number, TSampleCount extends number, TViewFormat extends GPUTextureFormat, TDimension extends GPUTextureDimension>(props: CreateTextureOptions<TSize, TFormat, TMipLevelCount, TSampleCount, TViewFormat, TDimension>): TgpuTexture<CreateTextureResult<TSize, TFormat, TMipLevelCount, TSampleCount, TViewFormat, TDimension>>;
-    beginRenderPass(descriptor: GPURenderPassDescriptor, callback: (pass: RenderPass) => void): void;
-    /**
-     * Causes all commands enqueued by pipelines to be
-     * submitted to the GPU.
-     */
-    flush(): void;
-}
-
-interface UniformFlag {
-    usableAsUniform: true;
-}
-/**
- * @deprecated Use UniformFlag instead.
- */
-type Uniform = UniformFlag;
-interface VertexFlag {
-    usableAsVertex: true;
-}
-/**
- * @deprecated Use VertexFlag instead.
- */
-type Vertex = VertexFlag;
-type LiteralToUsageType<T extends 'uniform' | 'storage' | 'vertex'> = T extends 'uniform' ? UniformFlag : T extends 'storage' ? StorageFlag : T extends 'vertex' ? VertexFlag : never;
-type ViewUsages<TBuffer extends TgpuBuffer<BaseData>> = (boolean extends TBuffer['usableAsUniform'] ? never : 'uniform') | (boolean extends TBuffer['usableAsStorage'] ? never : 'readonly' | 'mutable');
-type UsageTypeToBufferUsage<TData extends BaseData> = {
-    uniform: TgpuBufferUniform<TData> & TgpuFixedBufferUsage<TData>;
-    mutable: TgpuBufferMutable<TData> & TgpuFixedBufferUsage<TData>;
-    readonly: TgpuBufferReadonly<TData> & TgpuFixedBufferUsage<TData>;
-};
-interface TgpuBuffer<TData extends BaseData> extends TgpuNamable {
-    readonly resourceType: 'buffer';
-    readonly dataType: TData;
-    readonly initial?: Infer<TData> | undefined;
-    readonly label: string | undefined;
-    readonly buffer: GPUBuffer;
-    readonly destroyed: boolean;
-    usableAsUniform: boolean;
-    usableAsStorage: boolean;
-    usableAsVertex: boolean;
-    $usage<T extends RestrictVertexUsages<TData>>(...usages: T): this & UnionToIntersection<LiteralToUsageType<T[number]>>;
-    $addFlags(flags: GPUBufferUsageFlags): this;
-    as<T extends ViewUsages<this>>(usage: T): UsageTypeToBufferUsage<TData>[T];
-    compileWriter(): void;
-    write(data: Infer<TData>): void;
-    writePartial(data: InferPartial<TData>): void;
-    copyFrom(srcBuffer: TgpuBuffer<MemIdentity<TData>>): void;
-    read(): Promise<Infer<TData>>;
-    destroy(): void;
-}
-declare function isBuffer<T extends TgpuBuffer<AnyData>>(value: T | unknown): value is T;
-declare function isUsableAsVertex<T extends TgpuBuffer<AnyData>>(buffer: T): buffer is T & VertexFlag;
-type RestrictVertexUsages<TData extends BaseData> = TData extends {
-    readonly type: WgslTypeLiteral;
-} ? ('uniform' | 'storage' | 'vertex')[] : 'vertex'[];
-
-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 BaseData | ((_: number) => BaseData)> = T extends (_: number) => BaseData ? ReturnType<T> : T;
-type UnwrapRuntimeConstructor<T extends AnyData | ((_: number) => AnyData)> = T extends unknown ? UnwrapRuntimeConstructorInner<T> : never;
-interface TgpuBindGroupLayout<Entries extends Record<string, TgpuLayoutEntry | null> = Record<string, TgpuLayoutEntry | null>> extends TgpuNamable {
-    readonly resourceType: 'bind-group-layout';
-    readonly label: string | undefined;
-    readonly entries: Entries;
-    readonly bound: {
-        [K in keyof Entries]: BindLayoutEntry<Entries[K]>;
-    };
-    readonly value: {
-        [K in keyof Entries]: InferLayoutEntry<Entries[K]>;
-    };
-    readonly $: {
-        [K in keyof Entries]: InferLayoutEntry<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;
-    /**
-     * 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<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 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<UnwrapRuntimeConstructor<T['uniform']>> & UniformFlag) | GPUBuffer : T extends TgpuLayoutStorage ? (TgpuBuffer<UnwrapRuntimeConstructor<T['storage']>> & StorageFlag) | GPUBuffer : T extends TgpuLayoutSampler ? TgpuSampler | GPUSampler : T extends TgpuLayoutComparisonSampler ? TgpuComparisonSampler | GPUSampler : T extends TgpuLayoutTexture ? GPUTextureView | (Sampled & TgpuTexture<Prettify<TextureProps & GetTextureRestriction<T>>>) | TgpuSampledTexture<Default<T['viewDimension'], '2d'>, ChannelFormatToSchema[T['texture']]> : T extends TgpuLayoutStorageTexture ? GPUTextureView | (StorageFlag & TgpuTexture<Prettify<TextureProps & GetStorageTextureRestriction<T>>>) | StorageTextureUsageForEntry<T> : T extends TgpuLayoutExternalTexture ? GPUExternalTexture : never;
-type BindLayoutEntry<T extends TgpuLayoutEntry | null> = T extends TgpuLayoutUniform ? TgpuBufferUniform<T['uniform']> : T extends TgpuLayoutStorage ? StorageUsageForEntry<T> : T extends TgpuLayoutSampler ? TgpuSampler : T extends TgpuLayoutComparisonSampler ? TgpuComparisonSampler : T extends TgpuLayoutTexture ? TgpuSampledTexture<Default<T['viewDimension'], '2d'>, ChannelFormatToSchema[T['texture']]> : T extends TgpuLayoutStorageTexture ? StorageTextureUsageForEntry<T> : never;
-type InferLayoutEntry<T extends TgpuLayoutEntry | null> = T extends TgpuLayoutUniform ? Infer<T['uniform']> : T extends TgpuLayoutStorage ? Infer<UnwrapRuntimeConstructor<T['storage']>> : T extends TgpuLayoutSampler ? TgpuSampler : T extends TgpuLayoutComparisonSampler ? TgpuComparisonSampler : T extends TgpuLayoutTexture ? TgpuSampledTexture<Default<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;
-};
-declare function bindGroupLayout<Entries extends Record<string, TgpuLayoutEntry | null>>(entries: Entries): TgpuBindGroupLayout<Prettify<Entries>>;
-
-interface TgpuBufferUsage<TData extends BaseData = BaseData, TUsage extends BindableBufferUsage = BindableBufferUsage> {
-    readonly resourceType: 'buffer-usage';
-    readonly usage: TUsage;
-    readonly [$repr]: Infer<TData>;
-    value: InferGPU<TData>;
-    readonly [$internal]: {
-        readonly dataType: TData;
-    };
-}
-interface TgpuBufferUniform<TData extends BaseData> extends TgpuBufferUsage<TData, 'uniform'> {
-    readonly value: InferGPU<TData>;
-}
-interface TgpuBufferReadonly<TData extends BaseData> extends TgpuBufferUsage<TData, 'readonly'> {
-    readonly value: InferGPU<TData>;
-}
-interface TgpuFixedBufferUsage<TData extends BaseData> extends TgpuNamable {
-    readonly buffer: TgpuBuffer<TData>;
-    write(data: Infer<TData>): void;
-}
-interface TgpuBufferMutable<TData extends BaseData> extends TgpuBufferUsage<TData, 'mutable'> {
-}
-declare function isUsableAsUniform<T extends TgpuBuffer<AnyData>>(buffer: T): buffer is T & UniformFlag;
-/**
- * @deprecated Use buffer.as('mutable') instead.
- */
-declare function asMutable<TData extends AnyWgslData>(buffer: TgpuBuffer<TData> & StorageFlag): TgpuBufferMutable<TData> & TgpuFixedBufferUsage<TData>;
-/**
- * @deprecated Use buffer.as('readonly') instead.
- */
-declare function asReadonly<TData extends AnyWgslData>(buffer: TgpuBuffer<TData> & StorageFlag): TgpuBufferReadonly<TData> & TgpuFixedBufferUsage<TData>;
-/**
- * @deprecated Use buffer.as('uniform') instead.
- */
-declare function asUniform<TData extends AnyWgslData>(buffer: TgpuBuffer<TData> & UniformFlag): TgpuBufferUniform<TData> & TgpuFixedBufferUsage<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: TDataType, initialValue?: Infer<TDataType>): TgpuVar<'private', 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 | AnyData | TgpuFn<any, any>;
-type Wgsl = Eventual<string | number | boolean | ResolvableObject>;
-declare const UnknownData: {
-    type: "unknown";
-};
-type UnknownData = typeof UnknownData;
-type Snippet = {
-    value: unknown;
-    dataType: AnyData | UnknownData;
-};
-type TgpuShaderStage = 'compute' | 'vertex' | 'fragment';
-interface FnToWgslOptions {
-    args: Snippet[];
-    returnType: AnyWgslData;
-    body: Block;
-    externalMap: Record<string, unknown>;
-}
-type ItemLayer = {
-    type: 'item';
-    usedSlots: Set<TgpuSlot<unknown>>;
-};
-interface ItemStateStack {
-    readonly itemDepth: number;
-    readonly topItem: ItemLayer;
-    pushItem(): void;
-    popItem(): void;
-    pushSlotBindings(pairs: SlotValuePair<unknown>[]): void;
-    popSlotBindings(): void;
-    pushFunctionScope(args: Snippet[], returnType: AnyWgslData | undefined, externalMap: Record<string, unknown>): void;
-    popFunctionScope(): void;
-    pushBlockScope(): void;
-    popBlockScope(): void;
-    pop(type?: 'functionScope' | 'blockScope' | 'slotBinding' | 'item'): void;
-    readSlot<T>(slot: TgpuSlot<T>): T | undefined;
-    getSnippetById(id: string): Snippet | undefined;
-    defineBlockVariable(id: string, type: AnyWgslData | UnknownData): Snippet;
-}
-/**
- * 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 BaseData>(value: Infer<T>, schema: T): string;
-    transpileFn(fn: string): {
-        argNames: ArgNames;
-        body: Block;
-        externalNames: string[];
-    };
-    fnToWgsl(options: FnToWgslOptions): {
-        head: Wgsl;
-        body: Wgsl;
-    };
-    [$internal]: {
-        itemStateStack: ItemStateStack;
-    };
-}
-/**
- * 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)
- */
-type TgpuFnShellHeader<Args extends AnyWgslData[] | Record<string, AnyWgslData>, Return extends AnyWgslData | undefined = AnyWgslData | undefined> = {
-    readonly argTypes: Args;
-    readonly returnType: Return | undefined;
-    readonly isEntry: false;
-};
-/**
- * Describes a function signature (its arguments and return type).
- * Allows creating tgpu functions by calling this shell
- * and passing the implementation (as WGSL string or JS function) as the argument.
- */
-type TgpuFnShell<Args extends AnyWgslData[] | Record<string, AnyWgslData>, Return extends AnyWgslData | undefined = AnyWgslData | undefined> = TgpuFnShellHeader<Args, Return> & ((implementation: (...args: Args extends AnyWgslData[] ? InferArgs<Args> : [InferIO<Args>]) => InferReturn<Return>) => TgpuFn<Args, Return>) & ((implementation: string) => TgpuFn<Args, Return>) & ((strings: TemplateStringsArray, ...values: unknown[]) => TgpuFn<Args, Return>) & {
-    /**
-     * @deprecated Invoke the shell as a function instead.
-     */
-    does: ((implementation: (...args: Args extends AnyWgslData[] ? InferArgs<Args> : [InferIO<Args>]) => InferReturn<Return>) => TgpuFn<Args, Return>) & ((implementation: string) => TgpuFn<Args, Return>);
-};
-interface TgpuFnBase<Args extends AnyWgslData[] | Record<string, AnyWgslData>, Return extends AnyWgslData | undefined = undefined> extends TgpuNamable, Labelled {
-    readonly [$internal]: {
-        implementation: Implementation<Args, Return>;
-    };
-    readonly resourceType: 'function';
-    readonly shell: TgpuFnShellHeader<Args, Return>;
-    readonly '~providing'?: Providing | undefined;
-    $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<T>): TgpuFn<Args, Return>;
-}
-type TgpuFn<Args extends AnyWgslData[] | Record<string, AnyWgslData> = AnyWgslData[], Return extends AnyWgslData | undefined = AnyWgslData | undefined> = TgpuFnBase<Args, Return> & ((...args: Args extends AnyWgslData[] ? InferArgs<Args> : Args extends Record<string, never> ? [] : [InferIO<Args>]) => InferReturn<Return>);
-declare function fn<Args extends AnyWgslData[] | Record<string, AnyWgslData> | []>(argTypes: Args, returnType?: undefined): TgpuFnShell<Args, undefined>;
-declare function fn<Args extends AnyWgslData[] | Record<string, AnyWgslData> | [], Return extends AnyWgslData>(argTypes: Args, returnType: Return): TgpuFnShell<Args, Return>;
-declare function isTgpuFn<Args extends AnyWgslData[], Return extends AnyWgslData | undefined = undefined>(value: unknown | TgpuFn<Args, Return>): value is TgpuFn<Args, Return>;
+import { W as Wgsl, J as JitTranspiler, T as TgpuRoot, A as AnyWgslData, a as TgpuFn, b as TgpuBufferUsage, I as Infer, c as TgpuAccessor, d as TgpuDerived, e as TgpuSlot, f as TgpuBindGroupLayout, g as TgpuVertexLayout, h as WgslArray, D as Disarray, i as TgpuBuffer, j as AnyData, k as bindGroupLayout, v as vertexLayout, l as fn, m as fragmentFn, n as vertexFn, o as computeFn, p as privateVar, w as workgroupVar, q as constant, r as declare, s as sampler, t as comparisonSampler } from './tgpuComputeFn-DH8_PcIR.cjs';
+export { am as BindLayoutEntry, a8 as Eventual, an as ExtractBindGroupInputFromLayout, ao as LayoutEntryToInput, R as RandomNameRegistry, ag as Render, ah as Sampled, Z as Storage, _ as StorageFlag, S as StrictNameRegistry, af as TextureProps, a9 as TgpuAnyTextureView, ap as TgpuBindGroup, a5 as TgpuBufferMutable, a6 as TgpuBufferReadonly, a7 as TgpuBufferUniform, aD as TgpuComputeFn, aE as TgpuComputeFnShell, a0 as TgpuComputePipeline, ai as TgpuConst, aF as TgpuDeclare, ay as TgpuFnShell, aB as TgpuFragmentFn, aC as TgpuFragmentFnShell, aq as TgpuLayoutComparisonSampler, ar as TgpuLayoutEntry, as as TgpuLayoutExternalTexture, at as TgpuLayoutSampler, au as TgpuLayoutStorage, av as TgpuLayoutStorageTexture, aw as TgpuLayoutTexture, ax as TgpuLayoutUniform, aa as TgpuMutableTexture, ab as TgpuReadonlyTexture, $ as TgpuRenderPipeline, ac as TgpuSampledTexture, al as TgpuSampler, ad as TgpuTexture, aj as TgpuVar, az as TgpuVertexFn, aA as TgpuVertexFnShell, ae as TgpuWriteonlyTexture, a1 as Uniform, a2 as UniformFlag, ak as VariableScope, a3 as Vertex, a4 as VertexFlag, U as WithBinding, V as WithCompute, X as WithFragment, Y as WithVertex, u as isBuffer, B as isComparisonSampler, y as isDerived, E as isSampledTextureView, C as isSampler, z as isSlot, F as isStorageTextureView, G as isTexture, Q as isTgpuFn, H as isUsableAsRender, K as isUsableAsSampled, L as isUsableAsStorage, P as isUsableAsUniform, x as isUsableAsVertex, M as unstable_asMutable, N as unstable_asReadonly, O as unstable_asUniform } from './tgpuComputeFn-DH8_PcIR.cjs';
+import 'tinyest';
 
 interface TgpuResolveOptions {
     /**
@@ -1223,4 +182,4 @@ declare const tgpu: {
     };
 };
 
-export { type BindLayoutEntry, type Eventual, type InitFromDeviceOptions, type InitOptions, type LayoutEntryToInput, MissingBindGroupsError, MissingLinksError, MissingSlotValueError, MissingVertexBuffersError, NotUniformError, RandomNameRegistry, Render, ResolutionError, Sampled, StorageFlag, StrictNameRegistry, TextureProps, type TgpuAccessor, 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, TgpuMutableTexture, TgpuReadonlyTexture, type TgpuRenderPipeline, type TgpuRoot, TgpuSampledTexture, TgpuSampler, type TgpuSlot, TgpuTexture, type TgpuVar, type TgpuVertexFn, type TgpuVertexFnShell, type TgpuVertexLayout, TgpuWriteonlyTexture, type Uniform, type UniformFlag, type VariableScope, type Vertex, type VertexFlag, type WithBinding, type WithCompute, type WithFragment, type WithVertex, tgpu as default, isBuffer, isDerived, isSlot, isTgpuFn, isUsableAsUniform, isUsableAsVertex, tgpu, asMutable as unstable_asMutable, asReadonly as unstable_asReadonly, asUniform as unstable_asUniform };
+export { type InitFromDeviceOptions, type InitOptions, MissingBindGroupsError, MissingLinksError, MissingSlotValueError, MissingVertexBuffersError, NotUniformError, ResolutionError, TgpuAccessor, TgpuBindGroupLayout, TgpuBuffer, TgpuDerived, TgpuFn, TgpuRoot, TgpuSlot, TgpuVertexLayout, tgpu as default, tgpu };