typegpu 0.8.2 → 0.10.0

package/index.d.ts

@@ -1,61 +1,9 @@
-import { $ as $internal, S as ShelllessRepository, T as TgpuSlot, R as ResolvedSnippet, a as TgpuDerived, b as TgpuBindGroupLayout, c as TgpuBindGroup, L as LogResources, W as Wgsl, C as Configurable, d as WgslExtension, e as ShaderGenerator, f as TgpuBuffer, A as AnyData, g as TgpuVar, h as LogGeneratorOptions, i as TgpuRoot, j as AnyWgslData, k as TgpuFn, l as TgpuBufferUsage, I as Infer, m as TgpuAccessor, n as TgpuVertexLayout, o as WgslArray, D as Disarray, p as fn, q as bindGroupLayout, v as vertexLayout, r as privateVar, w as workgroupVar, s as constant, t as fragmentFn, u as vertexFn, x as computeFn, y as declare } from './tgpuConstant-BTQFNlQH.js';
-export { aw as BindLayoutEntry, aj as Eventual, ax as ExtractBindGroupInputFromLayout, aO as INTERNAL_GlobalExt, a7 as IndexFlag, ay as LayoutEntryToInput, an as RenderFlag, ao as SampledFlag, a3 as Storage, a4 as StorageFlag, am as TextureProps, ad as TgpuBufferMutable, ae as TgpuBufferReadonly, af as TgpuBufferUniform, ar as TgpuComparisonSampler, aL as TgpuComputeFn, aM as TgpuComputeFnShell, a6 as TgpuComputePipeline, ap as TgpuConst, aN as TgpuDeclare, as as TgpuFixedComparisonSampler, at as TgpuFixedSampler, aG as TgpuFnShell, aJ as TgpuFragmentFn, aK as TgpuFragmentFnShell, V as TgpuGuardedComputePipeline, az as TgpuLayoutComparisonSampler, aA as TgpuLayoutEntry, aB as TgpuLayoutExternalTexture, aC as TgpuLayoutSampler, aD as TgpuLayoutStorage, aE as TgpuLayoutTexture, aF as TgpuLayoutUniform, ag as TgpuMutable, av as TgpuQuerySet, ah as TgpuReadonly, a5 as TgpuRenderPipeline, au as TgpuSampler, ak as TgpuTexture, al as TgpuTextureView, ai as TgpuUniform, aH as TgpuVertexFn, aI as TgpuVertexFnShell, a8 as Uniform, a9 as UniformFlag, aa as ValidUsagesFor, X as ValidateBufferSchema, Y as ValidateStorageSchema, Z as ValidateUniformSchema, aq as VariableScope, ab as Vertex, ac as VertexFlag, _ as WithBinding, a0 as WithCompute, a1 as WithFragment, a2 as WithVertex, z as isBuffer, P as isBufferShorthand, G as isComparisonSampler, E as isDerived, H as isSampler, F as isSlot, J as isTexture, Q as isTgpuFn, K as isUsableAsRender, M as isUsableAsSampled, N as isUsableAsStorage, O as isUsableAsUniform, B as isUsableAsVertex, U as isVariable } from './tgpuConstant-BTQFNlQH.js';
-import 'tinyest';
-
-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.
-     */
-    makeUnique(primer?: string): 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;
-}
-
-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-Cdy7USiY.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.
  *
@@ -65,51 +13,54 @@ 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 {
-    /**
-     * 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;
-    /**
-     * 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;
 }
 /**
- * Resolves a template with external values. Each external will get resolved to a code string and replaced in the template.
+ * Resolves a template with external values. Each external that is used 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.
  *
@@ -117,10 +68,7 @@ interface TgpuResolveOptions {
  *
  * @example
  * ```ts
- * const Gradient = d.struct({
- *   from: d.vec3f,
- *   to: d.vec3f,
- * });
+ * const Gradient = d.struct({ from: d.vec3f, to: d.vec3f });
  *
  * const { code, usedBindGroupLayouts, catchall } = tgpu.resolveWithContext({
  *   template: `
@@ -143,13 +91,14 @@ interface TgpuResolveOptions {
  * // }
  * ```
  */
-declare function resolveWithContext(options: TgpuResolveOptions): ResolutionResult;
+declare function resolveWithContext(options: TgpuExtendedResolveOptions): ResolutionResult;
 /**
- * Resolves a template with external values. Each external will get resolved to a code string and replaced in the template.
+ * Resolves given TypeGPU resources.
  * Any dependencies of the externals will also be resolved and included in the output.
+ * @param items - An array of items to resolve.
  * @param options - The options for the resolution.
  *
- * @returns The resolved code.
+ * @returns {ResolutionResult}
  *
  * @example
  * ```ts
@@ -158,7 +107,38 @@ declare function resolveWithContext(options: TgpuResolveOptions): ResolutionResu
  *   to: d.vec3f,
  * });
  *
- * const resolved = tgpu.resolve({
+ * const { code, usedBindGroupLayouts, catchall } =
+ *   tgpu.resolveWithContext([Gradient]);
+ *
+ * console.log(code);
+ * // struct Gradient_0 {
+ * //   from: vec3f,
+ * //   to: vec3f,
+ * // }
+ * ```
+ */
+declare function resolveWithContext(items: ResolvableObject[], options?: TgpuResolveOptions): ResolutionResult;
+/**
+ * A shorthand for calling `tgpu.resolveWithContext(...).code`.
+ *
+ * @example
+ * ```ts
+ * const Gradient = d.struct({ from: d.vec3f, to: d.vec3f });
+ *
+ * const resolved = tgpu.resolve([Gradient]);
+ *
+ * console.log(resolved);
+ * // struct Gradient_0 {
+ * //   from: vec3f,
+ * //   to: vec3f,
+ * // }
+ * ```
+ *
+ * @example
+ * ```ts
+ * const Gradient = d.struct({ from: d.vec3f, to: d.vec3f });
+ *
+ * const code = tgpu.resolve({
  *   template: `
  *     fn getGradientAngle(gradient: Gradient) -> f32 {
  *       return atan(gradient.to.y - gradient.from.y, gradient.to.x - gradient.from.x);
@@ -169,7 +149,7 @@ declare function resolveWithContext(options: TgpuResolveOptions): ResolutionResu
  *   },
  * });
  *
- * console.log(resolved);
+ * console.log(code);
  * // struct Gradient_0 {
  * //   from: vec3f,
  * //   to: vec3f,
@@ -179,13 +159,33 @@ declare function resolveWithContext(options: TgpuResolveOptions): ResolutionResu
  * // }
  * ```
  */
-declare function resolve(options: TgpuResolveOptions): string;
-
+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
@@ -210,160 +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> | 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;
-        /**
-         * @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;
-        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, ResolutionError, TgpuAccessor, TgpuBindGroup, TgpuBindGroupLayout, TgpuBuffer, TgpuDerived, TgpuFn, 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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"}