typegpu 0.9.0 → 0.10.1

package/index.d.ts

@@ -1,116 +1,9 @@
-import { A as AnyData, O as Origin, I as InferGPU, $ as $internal, S as ShelllessRepository, T as TgpuSlot, R as ResolvedSnippet, a as TgpuDerived, b as TgpuBindGroupLayout, c as TgpuBindGroup, L as LogResources, C as Configurable, W as WgslExtension, d as ShaderGenerator, e as Wgsl, f as ResolvableObject, g as TgpuBuffer, h as TgpuVar, i as LogGeneratorOptions, j as TgpuRoot, k as AnyWgslData, l as TgpuFn, m as TgpuBufferUsage, n as TgpuBufferShorthand, o as Infer, p as TgpuAccessor, q as TgpuVertexLayout, r as WgslArray, D as Disarray, s as fn, t as bindGroupLayout, v as vertexLayout, u as privateVar, w as workgroupVar, x as constant, y as fragmentFn, z as vertexFn, B as computeFn, E as declare } from './tgpuConstant-BOn7U_lv.js';
-export { aA as BindLayoutEntry, an as Eventual, aB as ExtractBindGroupInputFromLayout, aS as INTERNAL_GlobalExt, ab as IndexFlag, aC as LayoutEntryToInput, ar as RenderFlag, as as SampledFlag, a7 as Storage, a8 as StorageFlag, aq as TextureProps, ah as TgpuBufferMutable, ai as TgpuBufferReadonly, aj as TgpuBufferUniform, av as TgpuComparisonSampler, aP as TgpuComputeFn, aQ as TgpuComputeFnShell, aa as TgpuComputePipeline, at as TgpuConst, aR as TgpuDeclare, aw as TgpuFixedComparisonSampler, ax as TgpuFixedSampler, aK as TgpuFnShell, aN as TgpuFragmentFn, aO as TgpuFragmentFnShell, _ as TgpuGuardedComputePipeline, aD as TgpuLayoutComparisonSampler, aE as TgpuLayoutEntry, aF as TgpuLayoutExternalTexture, aG as TgpuLayoutSampler, aH as TgpuLayoutStorage, aI as TgpuLayoutTexture, aJ as TgpuLayoutUniform, ak as TgpuMutable, az as TgpuQuerySet, al as TgpuReadonly, a9 as TgpuRenderPipeline, ay as TgpuSampler, ao as TgpuTexture, ap as TgpuTextureView, am as TgpuUniform, aL as TgpuVertexFn, aM as TgpuVertexFnShell, ac as Uniform, ad as UniformFlag, ae as ValidUsagesFor, a0 as ValidateBufferSchema, a1 as ValidateStorageSchema, a2 as ValidateUniformSchema, au as VariableScope, af as Vertex, ag as VertexFlag, a3 as WithBinding, a4 as WithCompute, a5 as WithFragment, a6 as WithVertex, F as isBuffer, X as isBufferShorthand, K as isComparisonSampler, H as isDerived, M as isSampler, J as isSlot, N as isTexture, Y as isTgpuFn, P as isUsableAsRender, Q as isUsableAsSampled, U as isUsableAsStorage, V as isUsableAsUniform, G as isUsableAsVertex, Z as isVariable } from './tgpuConstant-BOn7U_lv.js';
-import { c as comptime } from './comptime-DKpw1IVu.js';
-export { T as TgpuComptime } from './comptime-DKpw1IVu.js';
-import 'tinyest';
-
-/**
- * Extra declaration that will be included in final WGSL code
- * when resolving objects that use it.
- */
-interface TgpuRawCodeSnippet<TDataType extends AnyData> {
-    $: InferGPU<TDataType>;
-    value: InferGPU<TDataType>;
-    $uses(dependencyMap: Record<string, unknown>): this;
-}
-type RawCodeSnippetOrigin = Exclude<Origin, 'function' | 'this-function' | 'argument' | 'constant-ref'>;
-/**
- * An advanced API that creates a typed shader expression which
- * can be injected into the final shader bundle upon use.
- *
- * @param expression The code snippet that will be injected in place of `foo.$`
- * @param type The type of the expression
- * @param [origin='runtime'] Where the value originates from.
- *
- * **-- Which origin to choose?**
- *
- * Usually 'runtime' (the default) is a safe bet, but if you're sure that the expression or
- * computation is constant (either a reference to a constant, a numeric literal,
- * or an operation on constants), then pass 'constant' as it might lead to better
- * optimizations.
- *
- * If what the expression is a direct reference to an existing value (e.g. a uniform, a
- * storage binding, ...), then choose from 'uniform', 'mutable', 'readonly', 'workgroup',
- * 'private' or 'handle' depending on the address space of the referred value.
- *
- * @example
- * ```ts
- * // An identifier that we know will be in the
- * // final shader bundle, but we cannot
- * // refer to it in any other way.
- * const existingGlobal = tgpu['~unstable']
- *   .rawCodeSnippet('EXISTING_GLOBAL', d.f32, 'constant');
- *
- * const foo = () => {
- *   'use gpu';
- *   return existingGlobal.$ * 2;
- * };
- *
- * const wgsl = tgpu.resolve([foo]);
- * // fn foo() -> f32 {
- * //   return EXISTING_GLOBAL * 2;
- * // }
- * ```
- */
-declare function rawCodeSnippet<TDataType extends AnyData>(expression: string, type: TDataType, origin?: RawCodeSnippetOrigin | undefined): TgpuRawCodeSnippet<TDataType>;
-
-interface NameRegistry {
-    /**
-     * Creates a valid WGSL identifier, each guaranteed to be unique
-     * in the lifetime of a single resolution process.
-     * Should append "_" to primer, followed by some id.
-     * @param primer Used in the generation process, makes the identifier more recognizable.
-     * @param global Whether the name should be registered in the global scope (true), or in the current function scope (false)
-     */
-    makeUnique(primer: string | undefined, global: boolean): string;
-    /**
-     * Creates a valid WGSL identifier.
-     * Renames identifiers that are WGSL reserved words.
-     * @param primer Used in the generation process.
-     *
-     * @example
-     * makeValid("notAKeyword"); // "notAKeyword"
-     * makeValid("struct"); // makeUnique("struct")
-     * makeValid("struct_1"); // makeUnique("struct_1") (to avoid potential name collisions)
-     * makeValid("_"); // ERROR (too difficult to make valid to care)
-     */
-    makeValid(primer: string): string;
-    pushFunctionScope(): void;
-    popFunctionScope(): void;
-}
-
-type SlotToValueMap = Map<TgpuSlot<unknown>, unknown>;
-interface NamespaceInternal {
-    readonly nameRegistry: NameRegistry;
-    readonly shelllessRepo: ShelllessRepository;
-    memoizedResolves: WeakMap<object, {
-        slotToValueMap: SlotToValueMap;
-        result: ResolvedSnippet;
-    }[]>;
-    memoizedDerived: WeakMap<TgpuDerived<unknown>, {
-        slotToValueMap: SlotToValueMap;
-        result: unknown;
-    }[]>;
-    listeners: {
-        [K in keyof NamespaceEventMap]: Set<(event: NamespaceEventMap[K]) => void>;
-    };
-}
-type NamespaceEventMap = {
-    'name': {
-        target: object;
-        name: string;
-    };
-};
-type DetachListener = () => void;
-interface Namespace {
-    readonly [$internal]: NamespaceInternal;
-    on<TEvent extends keyof NamespaceEventMap>(event: TEvent, listener: (event: NamespaceEventMap[TEvent]) => void): DetachListener;
-}
-interface NamespaceOptions {
-    names?: 'random' | 'strict' | undefined;
-}
-declare function namespace(options?: NamespaceOptions | undefined): Namespace;
+import { $o as TgpuLayoutComparisonSampler, $r as comptime, Ac as TgpuComputePipeline, Al as Storage, Ao as UniformFlag, Bc as isSlot, Bo as ValidateStorageSchema, Cc as TgpuFragmentFnShell, Co as fn, Dc as AutoFragmentOut, Do as IndexFlag, Ec as AutoFragmentIn, Eo as declare, Fc as TgpuMutableAccessor, Fo as isUsableAsVertex, Gc as workgroupVar, Go as WithVertex, Gr as rawCodeSnippet, Hc as VariableScope, Ho as WithBinding, Ic as TgpuSlot, Io as Configurable, Jc as computeFn, Jo as BindLayoutEntry, Jr as init, Kc as TgpuComputeFn, Ko as Withable, Kr as InitFromDeviceOptions, Lc as isAccessor, Ll as $internal, Lo as TgpuGuardedComputePipeline, Mc as Eventual, Ml as isUsableAsStorage, Mo as Vertex, Nc as TgpuAccessor, No as VertexFlag, Oc as AutoVertexIn, Oo as TgpuBuffer, Pc as TgpuLazy, Po as isBuffer, Qo as TgpuBindGroupLayout, Qr as TgpuComptime, Rc as isLazy, Rl as INTERNAL_GlobalExt, Ro as TgpuRoot, Sc as TgpuFragmentFn, So as TgpuGenericFn, Tc as isTgpuFragmentFn, To as TgpuDeclare, Uc as isVariable, Uo as WithCompute, Ur as RawCodeSnippetOrigin, Vc as TgpuVar, Vo as ValidateUniformSchema, Wc as privateVar, Wo as WithFragment, Wr as TgpuRawCodeSnippet, Xo as LayoutEntryToInput, Xr as Namespace, Yc as isTgpuComputeFn, Yo as ExtractBindGroupInputFromLayout, Yr as initFromDevice, Zo as TgpuBindGroup, Zr as namespace, _c as TextureProps, _i as isTexture, _o as ResolvableObject, _s as TgpuVertexLayout, a as MissingVertexBuffersError, al as LogResources, as as TgpuLayoutUniform, bc as isTgpuVertexFn, bo as TgpuFn, cl as TgpuUniform, cs as TgpuComparisonSampler, dl as TgpuBufferReadonly, ds as TgpuSampler, ei as TgpuConst, es as TgpuLayoutEntry, fl as TgpuBufferUniform, fs as isComparisonSampler, gc as isUsableAsSampled, gi as TgpuTextureView, go as GPUCallable, gs as TgpuRenderPipeline, hc as isUsableAsRender, hi as TgpuTexture, hs as TgpuPrimitiveState, i as MissingSlotValueError, is as TgpuLayoutTexture, jl as StorageFlag, jo as ValidUsagesFor, kc as AutoVertexOut, ko as Uniform, ll as isBufferShorthand, ls as TgpuFixedComparisonSampler, mc as SampledFlag, ml as TgpuQuerySet, ms as ColorAttachment, n as MissingBindGroupsError, ni as AnyData, ns as TgpuLayoutSampler, o as NotUniformError, oa as BaseData, ol as TgpuMutable, os as UnwrapRuntimeConstructor, pc as RenderFlag, pl as isUsableAsUniform, ps as isSampler, qc as TgpuComputeFnShell, qo as ShaderGenerator, qr as InitOptions, r as MissingLinksError, rs as TgpuLayoutStorage, s as ResolutionError, sl as TgpuReadonly, ss as bindGroupLayout, t as TgpuRenderPipelineDescriptor, ti as constant, ts as TgpuLayoutExternalTexture, ul as TgpuBufferMutable, us as TgpuFixedSampler, vc as TgpuVertexFn, vo as Wgsl, vs as vertexLayout, wc as fragmentFn, wo as isTgpuFn, xc as vertexFn, xo as TgpuFnShell, yc as TgpuVertexFnShell, yo as WgslExtension, zc as isMutableAccessor, zo as ValidateBufferSchema } from "./indexNamedExports-oL6tyaJ9.js";
+import { t as index_d_exports$1 } from "./data/index.js";
+import { t as index_d_exports$2 } from "./std/index.js";
+import { t as index_d_exports } from "./common/index.js";
 
+//#region src/resolutionCtx.d.ts
 /**
  * The results of a WGSL resolution.
  *
@@ -120,50 +13,51 @@ declare function namespace(options?: NamespaceOptions | undefined): Namespace;
  * @param logResources - Buffers and information about used console.logs needed to decode the raw data.
  */
 interface ResolutionResult {
-    code: string;
-    usedBindGroupLayouts: TgpuBindGroupLayout[];
-    catchall: [number, TgpuBindGroup] | undefined;
-    logResources: LogResources | undefined;
+  code: string;
+  usedBindGroupLayouts: TgpuBindGroupLayout[];
+  catchall: [number, TgpuBindGroup] | undefined;
+  logResources: LogResources | undefined;
 }
-
+//#endregion
+//#region src/core/resolve/tgpuResolve.d.ts
 interface TgpuResolveOptions {
-    /**
-     * The naming strategy used for generating identifiers for resolved externals and their dependencies.
-     *
-     * ## Namespaces
-     * Each call to `tgpu.resolve` uses it's own namespace by default, but a
-     * custom namespace can be created with `tgpu.namespace` and passed in.
-     *
-     * This allows tracking the behavior of the resolution process, as well as
-     * sharing state between calls to `tgpu.resolve`.
-     *
-     * @default 'random'
-     */
-    names?: 'strict' | 'random' | Namespace | undefined;
-    /**
-     * A function to configure the resolution context.
-     */
-    config?: ((cfg: Configurable) => Configurable) | undefined;
-    /**
-     * List of WGSL shader extensions to enable.
-     */
-    enableExtensions?: WgslExtension[] | undefined;
-    /**
-     * A custom shader code generator, used when resolving TGSL.
-     * If not provided, the default WGSL generator will be used.
-     */
-    shaderGenerator?: ShaderGenerator | undefined;
+  /**
+   * The naming strategy used for generating identifiers for resolved externals and their dependencies.
+   *
+   * ## Namespaces
+   * Each call to `tgpu.resolve` uses it's own namespace by default, but a
+   * custom namespace can be created with `tgpu.namespace` and passed in.
+   *
+   * This allows tracking the behavior of the resolution process, as well as
+   * sharing state between calls to `tgpu.resolve`.
+   *
+   * @default 'random'
+   */
+  names?: 'strict' | 'random' | Namespace | undefined;
+  /**
+   * A function to configure the resolution context.
+   */
+  config?: ((cfg: Configurable) => Configurable) | undefined;
+  /**
+   * List of WGSL shader extensions to enable.
+   */
+  enableExtensions?: WgslExtension[] | undefined;
+  /**
+   * A custom shader code generator, used when resolving TypeGPU functions.
+   * If not provided, the default WGSL generator will be used.
+   */
+  shaderGenerator?: ShaderGenerator | undefined;
 }
 interface TgpuExtendedResolveOptions extends TgpuResolveOptions {
-    /**
-     * Map of external names to their resolvable values.
-     */
-    externals: Record<string, Wgsl | object>;
-    /**
-     * The code template to use for the resolution. All external names will be replaced with their resolved values.
-     * @default ''
-     */
-    template?: string | undefined;
+  /**
+   * Map of external names to their resolvable values.
+   */
+  externals: Record<string, Wgsl | object>;
+  /**
+   * The code template to use for the resolution. All external names will be replaced with their resolved values.
+   * @default ''
+   */
+  template?: string | undefined;
 }
 /**
  * Resolves a template with external values. Each external that is used will get resolved to a code string and replaced in the template.
@@ -267,12 +161,31 @@ declare function resolveWithContext(items: ResolvableObject[], options?: TgpuRes
  */
 declare function resolve(options: TgpuExtendedResolveOptions): string;
 declare function resolve(items: ResolvableObject[], options?: TgpuResolveOptions): string;
-
+//#endregion
+//#region src/core/slot/slot.d.ts
+declare function slot<T>(defaultValue?: T): TgpuSlot<T>;
+//#endregion
+//#region src/core/slot/lazy.d.ts
+declare function lazy<T>(compute: () => T): TgpuLazy<T>;
+//#endregion
+//#region src/core/slot/accessor.d.ts
+declare function accessor<T extends AnyData | ((count: number) => AnyData)>(schemaOrConstructor: T, defaultValue?: TgpuAccessor.In<NoInfer<T>>): TgpuAccessor<UnwrapRuntimeConstructor<T>>;
+declare function mutableAccessor<T extends AnyData | ((count: number) => AnyData)>(schemaOrConstructor: T, defaultValue?: TgpuMutableAccessor.In<NoInfer<T>>): TgpuMutableAccessor<UnwrapRuntimeConstructor<T>>;
+//#endregion
+//#region src/core/unroll/tgpuUnroll.d.ts
+/**
+ * Marks an iterable to be unrolled by the wgslGenerator.
+ */
+declare const unroll: (<T extends Iterable<unknown>>(value: T) => T) & GPUCallable<[value: Iterable<unknown>]> & {
+  [$internal]: true;
+};
+//#endregion
+//#region src/core/simulate/tgpuSimulate.d.ts
 interface SimulationResult<T> {
-    value: T;
-    buffers: Map<TgpuBuffer<AnyData>, unknown>;
-    privateVars: Map<TgpuVar<'private', AnyData>, unknown>[][][];
-    workgroupVars: Map<TgpuVar<'workgroup', AnyData>, unknown>[][][];
+  value: T;
+  buffers: Map<TgpuBuffer<BaseData>, unknown>;
+  privateVars: Map<TgpuVar<'private'>, unknown>[][][];
+  workgroupVars: Map<TgpuVar<'workgroup'>, unknown>[][][];
 }
 /**
  * Runs the provided callback in a simulated environment, giving
@@ -297,162 +210,63 @@ interface SimulationResult<T> {
  * console.log(result.value); // 3
  */
 declare function simulate<T>(callback: () => T): SimulationResult<T>;
-
-/**
- * Options passed into {@link init}.
- */
-type InitOptions = {
-    adapter?: GPURequestAdapterOptions | undefined;
-    device?: GPUDeviceDescriptor & {
-        optionalFeatures?: Iterable<GPUFeatureName>;
-    } | undefined;
-    /** @default 'random' */
-    unstable_names?: 'random' | 'strict' | undefined;
-    /**
-     * A custom shader code generator, used when resolving TGSL.
-     * If not provided, the default WGSL generator will be used.
-     */
-    shaderGenerator?: ShaderGenerator | undefined;
-    unstable_logOptions?: LogGeneratorOptions;
-};
-/**
- * Options passed into {@link initFromDevice}.
- */
-type InitFromDeviceOptions = {
-    device: GPUDevice;
-    /** @default 'random' */
-    unstable_names?: 'random' | 'strict' | undefined;
-    /**
-     * A custom shader code generator, used when resolving TGSL.
-     * If not provided, the default WGSL generator will be used.
-     */
-    shaderGenerator?: ShaderGenerator | undefined;
-    unstable_logOptions?: LogGeneratorOptions;
-};
-/**
- * Requests a new GPU device and creates a root around it.
- * If a specific device should be used instead, use @see initFromDevice.
- *
- * @example
- * When given no options, the function will ask the browser for a suitable GPU device.
- * ```ts
- * const root = await tgpu.init();
- * ```
- *
- * @example
- * If there are specific options that should be used when requesting a device, you can pass those in.
- * ```ts
- * const adapterOptions: GPURequestAdapterOptions = ...;
- * const deviceDescriptor: GPUDeviceDescriptor = ...;
- * const root = await tgpu.init({ adapter: adapterOptions, device: deviceDescriptor });
- * ```
- */
-declare function init(options?: InitOptions): Promise<TgpuRoot>;
-/**
- * Creates a root from the given device, instead of requesting it like @see init.
- *
- * @example
- * ```ts
- * const device: GPUDevice = ...;
- * const root = tgpu.initFromDevice({ device });
- * ```
- */
-declare function initFromDevice(options: InitFromDeviceOptions): TgpuRoot;
-
-declare function accessor<T extends AnyWgslData>(schema: T, defaultValue?: TgpuFn<() => T> | TgpuBufferUsage<T> | TgpuBufferShorthand<T> | Infer<T>): TgpuAccessor<T>;
-
-declare function derived<T>(compute: () => T): TgpuDerived<T>;
-
-declare function slot<T>(defaultValue?: T): TgpuSlot<T>;
-
-/**
- * An error that happens during resolution of WGSL code.
- * Contains a trace of all ancestor resolvables in
- * which this error originated.
- *
- * @category Errors
- */
-declare class ResolutionError extends Error {
-    readonly cause: unknown;
-    readonly trace: unknown[];
-    constructor(cause: unknown, trace: unknown[]);
-    appendToTrace(ancestor: unknown): ResolutionError;
-}
-/**
- * @category Errors
- */
-declare class MissingSlotValueError extends Error {
-    readonly slot: TgpuSlot<unknown>;
-    constructor(slot: TgpuSlot<unknown>);
+declare namespace tgpuUnstable_d_exports {
+  export { _accessor as accessor, _comptime as comptime, _computeFn as computeFn, _constant as const, declare, _lazy as derived, _fn as fn, _fragmentFn as fragmentFn, _mutableAccessor as mutableAccessor, namespace, _privateVar as privateVar, rawCodeSnippet, simulate, _slot as slot, _vertexFn as vertexFn, _vertexLayout as vertexLayout, _workgroupVar as workgroupVar };
 }
-/**
- * @category Errors
- */
-declare class NotUniformError extends Error {
-    constructor(value: TgpuBuffer<AnyData>);
-}
-declare class MissingLinksError extends Error {
-    constructor(fnLabel: string | undefined, externalNames: string[]);
-}
-declare class MissingBindGroupsError extends Error {
-    constructor(layouts: Iterable<TgpuBindGroupLayout>);
-}
-declare class MissingVertexBuffersError extends Error {
-    constructor(layouts: Iterable<TgpuVertexLayout<WgslArray | Disarray>>);
-}
-
+/** @deprecated This feature is now stable, use tgpu.const. */
+declare const _constant: typeof constant;
+/** @deprecated This feature is now stable, use tgpu.comptime. */
+declare const _comptime: typeof comptime;
+/** @deprecated This feature is now stable, use tgpu.computeFn. */
+declare const _computeFn: typeof computeFn;
+/** @deprecated This feature is now stable, use tgpu.fn. */
+declare const _fn: typeof fn;
+/** @deprecated This feature is now stable, use tgpu.fragmentFn. */
+declare const _fragmentFn: typeof fragmentFn;
+/** @deprecated This feature is now stable, use tgpu.vertexFn. */
+declare const _vertexFn: typeof vertexFn;
+/** @deprecated This feature is now stable, use tgpu.accessor. */
+declare const _accessor: typeof accessor;
+/** @deprecated This feature is now stable, use tgpu.mutableAccessor. */
+declare const _mutableAccessor: typeof mutableAccessor;
+/** @deprecated This feature is now stable, use tgpu.lazy. */
+declare const _lazy: typeof lazy;
+/** @deprecated This feature is now stable, use tgpu.slot. */
+declare const _slot: typeof slot;
+/** @deprecated This feature is now stable, use tgpu.privateVar. */
+declare const _privateVar: typeof privateVar;
+/** @deprecated This feature is now stable, use tgpu.workgroupVar. */
+declare const _workgroupVar: typeof workgroupVar;
+/** @deprecated This feature is now stable, use tgpu.vertexLayout. */
+declare const _vertexLayout: typeof vertexLayout;
+//#endregion
+//#region src/index.d.ts
 /**
  * @module typegpu
  */
-
+// NOTE: This is a barrel file, internal files should not import things from this file
 declare const tgpu: {
-    fn: typeof fn;
-    bindGroupLayout: typeof bindGroupLayout;
-    vertexLayout: typeof vertexLayout;
-    slot: typeof slot;
-    init: typeof init;
-    initFromDevice: typeof initFromDevice;
-    resolve: typeof resolve;
-    resolveWithContext: typeof resolveWithContext;
-    privateVar: typeof privateVar;
-    workgroupVar: typeof workgroupVar;
-    const: typeof constant;
-    '~unstable': {
-        /**
-         * @deprecated This feature is now stable, use tgpu.fn.
-         */
-        fn: typeof fn;
-        fragmentFn: typeof fragmentFn;
-        vertexFn: typeof vertexFn;
-        computeFn: typeof computeFn;
-        comptime: typeof comptime;
-        /**
-         * @deprecated This feature is now stable, use tgpu.vertexLayout.
-         */
-        vertexLayout: typeof vertexLayout;
-        namespace: typeof namespace;
-        derived: typeof derived;
-        /**
-         * @deprecated This feature is now stable, use tgpu.slot.
-         */
-        slot: typeof slot;
-        accessor: typeof accessor;
-        /**
-         * @deprecated This feature is now stable, use tgpu.privateVar.
-         */
-        privateVar: typeof privateVar;
-        /**
-         * @deprecated This feature is now stable, use tgpu.workgroupVar.
-         */
-        workgroupVar: typeof workgroupVar;
-        /**
-         * @deprecated This feature is now stable, use tgpu.const.
-         */
-        const: typeof constant;
-        declare: typeof declare;
-        rawCodeSnippet: typeof rawCodeSnippet;
-        simulate: typeof simulate;
-    };
+  const: typeof constant;
+  fn: typeof fn;
+  comptime: typeof comptime;
+  resolve: typeof resolve;
+  resolveWithContext: typeof resolveWithContext;
+  init: typeof init;
+  initFromDevice: typeof initFromDevice;
+  slot: typeof slot;
+  lazy: typeof lazy;
+  accessor: typeof accessor;
+  mutableAccessor: typeof mutableAccessor;
+  privateVar: typeof privateVar;
+  workgroupVar: typeof workgroupVar;
+  vertexLayout: typeof vertexLayout;
+  bindGroupLayout: typeof bindGroupLayout;
+  computeFn: typeof computeFn;
+  fragmentFn: typeof fragmentFn;
+  vertexFn: typeof vertexFn;
+  unroll: typeof unroll;
+  '~unstable': typeof tgpuUnstable_d_exports;
 };
-
-export { Configurable, type InitFromDeviceOptions, type InitOptions, MissingBindGroupsError, MissingLinksError, MissingSlotValueError, MissingVertexBuffersError, type Namespace, NotUniformError, type RawCodeSnippetOrigin, ResolutionError, TgpuAccessor, TgpuBindGroup, TgpuBindGroupLayout, TgpuBuffer, TgpuDerived, TgpuFn, type TgpuRawCodeSnippet, TgpuRoot, TgpuSlot, TgpuVar, TgpuVertexLayout, tgpu as default, tgpu };
+//#endregion
+export { AutoFragmentIn, AutoFragmentOut, AutoVertexIn, AutoVertexOut, BindLayoutEntry, ColorAttachment, Configurable, Eventual, ExtractBindGroupInputFromLayout, INTERNAL_GlobalExt, IndexFlag, InitFromDeviceOptions, InitOptions, LayoutEntryToInput, MissingBindGroupsError, MissingLinksError, MissingSlotValueError, MissingVertexBuffersError, Namespace, NotUniformError, RawCodeSnippetOrigin, RenderFlag, ResolutionError, SampledFlag, Storage, StorageFlag, TextureProps, TgpuAccessor, TgpuBindGroup, TgpuBindGroupLayout, TgpuBuffer, TgpuBufferMutable, TgpuBufferReadonly, TgpuBufferUniform, TgpuComparisonSampler, TgpuComptime, TgpuComputeFn, TgpuComputeFnShell, TgpuComputePipeline, TgpuConst, TgpuDeclare, TgpuFixedComparisonSampler, TgpuFixedSampler, TgpuFn, TgpuFnShell, TgpuFragmentFn, TgpuFragmentFnShell, TgpuGenericFn, TgpuGuardedComputePipeline, TgpuLayoutComparisonSampler, TgpuLayoutEntry, TgpuLayoutExternalTexture, TgpuLayoutSampler, TgpuLayoutStorage, TgpuLayoutTexture, TgpuLayoutUniform, TgpuLazy, TgpuMutable, TgpuMutableAccessor, TgpuPrimitiveState, TgpuQuerySet, TgpuRawCodeSnippet, TgpuReadonly, TgpuRenderPipeline, TgpuRenderPipelineDescriptor, TgpuRoot, TgpuSampler, TgpuSlot, TgpuTexture, TgpuTextureView, TgpuUniform, TgpuVar, TgpuVertexFn, TgpuVertexFnShell, TgpuVertexLayout, Uniform, UniformFlag, ValidUsagesFor, ValidateBufferSchema, ValidateStorageSchema, ValidateUniformSchema, VariableScope, Vertex, VertexFlag, WithBinding, WithCompute, WithFragment, WithVertex, Withable, index_d_exports as common, index_d_exports$1 as d, tgpu as default, tgpu, isAccessor, isBuffer, isBufferShorthand, isComparisonSampler, isLazy, isMutableAccessor, isSampler, isSlot, isTexture, isTgpuComputeFn, isTgpuFn, isTgpuFragmentFn, isTgpuVertexFn, isUsableAsRender, isUsableAsSampled, isUsableAsStorage, isUsableAsUniform, isUsableAsVertex, isVariable, index_d_exports$2 as std };
+//# sourceMappingURL=index.d.ts.map

package/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":["__core_function_tgpuFn_ts0","__core_function_comptime_ts0","__core_resolve_tgpuResolve_ts0","__core_root_init_ts0","__core_slot_slot_ts0","__core_slot_lazy_ts0","__core_slot_accessor_ts0","__core_variable_tgpuVariable_ts0","__core_vertexLayout_vertexLayout_ts0","__tgpuBindGroupLayout_ts0","__core_function_tgpuComputeFn_ts0","__core_function_tgpuFragmentFn_ts0","__core_function_tgpuVertexFn_ts0","__core_unroll_tgpuUnroll_ts0","__tgpuUnstable_ts0","tgpu","__core_constant_tgpuConstant_ts0","constant","fn","comptime","resolve","resolveWithContext","init","initFromDevice","slot","lazy","accessor","mutableAccessor","privateVar","workgroupVar","vertexLayout","bindGroupLayout","computeFn","fragmentFn","vertexFn","unroll","const","default"],"sources":["../src/resolutionCtx.ts","../src/core/resolve/tgpuResolve.ts","../src/core/slot/slot.ts","../src/core/slot/lazy.ts","../src/core/slot/accessor.ts","../src/core/unroll/tgpuUnroll.ts","../src/core/simulate/tgpuSimulate.ts","../src/tgpuUnstable.ts","../src/index.d.ts"],"mappings":"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"}