typegpu 0.10.1 → 0.11.0-rc.1

package/tgpuBindGroupLayout.d.ts

@@ -0,0 +1,161 @@
+import { TgpuNamable } from "./shared/meta.js";
+import { $gpuValueOf, $internal } from "./shared/symbols.js";
+import { Default, NullableToOptional, Prettify } from "./shared/utilityTypes.js";
+import { WgslComparisonSampler, WgslSampler } from "./data/sampler.js";
+import { StorageFlag } from "./extension.js";
+import { TgpuBufferMutable, TgpuBufferReadonly, TgpuBufferUniform } from "./core/buffer/bufferUsage.js";
+import { SampledFlag } from "./core/texture/usageExtension.js";
+import { Unwrapper } from "./unwrapper.js";
+import { TgpuComparisonSampler, TgpuSampler } from "./core/sampler/sampler.js";
+import { TgpuExternalTexture } from "./core/texture/externalTexture.js";
+import { TgpuBuffer, UniformFlag } from "./core/buffer/buffer.js";
+import { TgpuShaderStage } from "./types.js";
+import { AnyWgslData, BaseData, F32, I32, U32 } from "./data/wgslTypes.js";
+import { StorageTextureFormats } from "./core/texture/textureFormats.js";
+import { StorageTextureDimension, TextureSchemaForDescriptor, WgslExternalTexture, WgslStorageTexture, WgslTexture } from "./data/texture.js";
+import { PropsForSchema, TgpuTexture, TgpuTextureView } from "./core/texture/texture.js";
+import { InferGPU, MemIdentity } from "./shared/repr.js";
+
+//#region src/tgpuBindGroupLayout.d.ts
+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','fragment'] for mutable resources
+   * @default ['compute','vertex','fragment'] for everything else
+   */
+  visibility?: TgpuShaderStage[];
+};
+type TgpuLayoutUniform = TgpuLayoutEntryBase & {
+  uniform: BaseData;
+};
+type TgpuLayoutStorage = TgpuLayoutEntryBase & {
+  storage: BaseData | ((arrayLength: number) => BaseData); /** @default 'readonly' */
+  access?: 'mutable' | 'readonly';
+};
+type TgpuLayoutSampler = TgpuLayoutEntryBase & {
+  sampler: 'filtering' | 'non-filtering';
+};
+type TgpuLayoutComparisonSampler = TgpuLayoutEntryBase & {
+  sampler: 'comparison';
+};
+type TgpuLayoutTexture<TSchema extends WgslTexture = WgslTexture> = TgpuLayoutEntryBase & {
+  texture: TSchema;
+  sampleType?: GPUTextureSampleType;
+};
+type TgpuLayoutStorageTexture<TSchema extends WgslStorageTexture = WgslStorageTexture> = TgpuLayoutEntryBase & {
+  storageTexture: TSchema;
+};
+type TgpuLayoutExternalTexture = TgpuLayoutEntryBase & {
+  externalTexture: WgslExternalTexture;
+};
+type TgpuLegacyLayoutTexture<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 TgpuLegacyLayoutStorageTexture<TFormat extends StorageTextureFormats = StorageTextureFormats> = TgpuLayoutEntryBase & {
+  storageTexture: TFormat; /** @default 'writeonly' */
+  access?: 'readonly' | 'writeonly' | 'mutable'; /** @default '2d' */
+  viewDimension?: StorageTextureDimension;
+};
+type TgpuLegacyLayoutExternalTexture = TgpuLayoutEntryBase & {
+  externalTexture: Record<string, never>;
+};
+type TgpuLegacyLayoutEntry = TgpuLayoutUniform | TgpuLayoutStorage | TgpuLayoutSampler | TgpuLayoutComparisonSampler | TgpuLegacyLayoutTexture | TgpuLegacyLayoutStorageTexture | TgpuLegacyLayoutExternalTexture;
+type TgpuLayoutEntry = TgpuLayoutUniform | TgpuLayoutStorage | TgpuLayoutSampler | TgpuLayoutComparisonSampler | TgpuLayoutTexture | TgpuLayoutStorageTexture | TgpuLayoutExternalTexture;
+type SampleTypeToPrimitive = {
+  float: F32;
+  'unfilterable-float': F32;
+  depth: F32;
+  sint: I32;
+  uint: U32;
+};
+type LeagcyAccessToAccess = {
+  writeonly: 'write-only';
+  readonly: 'read-only';
+  mutable: 'read-write';
+};
+type MapLegacyTextureToUpToDate<T extends Record<string, TgpuLegacyLayoutEntry | TgpuLayoutEntry | null>> = { [K in keyof T]: T[K] extends TgpuLayoutEntry | null ? T[K] : T[K] extends TgpuLegacyLayoutTexture<infer SampleType> ? TgpuLayoutTexture<TextureSchemaForDescriptor<{
+  dimension: Default<T[K]['viewDimension'], '2d'>;
+  sampleType: SampleTypeToPrimitive[SampleType];
+  multisampled: Default<T[K]['multisampled'], false>;
+}>> : T[K] extends TgpuLegacyLayoutStorageTexture<infer Format> ? TgpuLayoutStorageTexture<TextureSchemaForDescriptor<{
+  access: LeagcyAccessToAccess[Default<T[K]['access'], 'writeonly'>];
+  format: Format;
+  dimension: Default<T[K]['viewDimension'], '2d'>;
+}>> : T[K] extends TgpuLegacyLayoutExternalTexture ? TgpuLayoutExternalTexture : never };
+type UnwrapRuntimeConstructorInner<T extends BaseData | ((_: number) => BaseData)> = T extends ((_: number) => BaseData) ? ReturnType<T> : T;
+type UnwrapRuntimeConstructor<T extends BaseData | ((_: number) => BaseData)> = T extends unknown ? UnwrapRuntimeConstructorInner<T> : never;
+interface BindGroupLayoutInternals<Entries extends Record<string, TgpuLayoutEntry | null>> {
+  bound: { [K in keyof Entries]: BindLayoutEntry<Entries[K]> };
+}
+interface TgpuBindGroupLayout<Entries extends Record<string, TgpuLayoutEntry | null> = Record<string, TgpuLayoutEntry | null>> extends TgpuNamable {
+  readonly [$internal]: BindGroupLayoutInternals<Entries>;
+  readonly resourceType: 'bind-group-layout';
+  readonly entries: Entries;
+  /**
+   * @deprecated Use `layout.$.foo` instead of `layout.bound.foo.$`
+   */
+  readonly bound: { [K in keyof Entries]: BindLayoutEntry<Entries[K]> };
+  readonly [$gpuValueOf]: { [K in keyof Entries]: InferLayoutEntry<Entries[K]> };
+  /**
+   * @deprecated Use `.$` instead, works the same way.
+   */
+  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 LayoutEntryToInput<T extends TgpuLayoutEntry | null> = TgpuLayoutEntry | null extends T ? TgpuBuffer<AnyWgslData> | GPUBuffer | TgpuSampler | GPUSampler | TgpuComparisonSampler | TgpuTexture | GPUTextureView | GPUExternalTexture : T extends TgpuLayoutUniform ? (TgpuBuffer<MemIdentity<UnwrapRuntimeConstructor<T['uniform']>>> & UniformFlag) | GPUBuffer : T extends TgpuLayoutStorage ? (TgpuBuffer<MemIdentity<UnwrapRuntimeConstructor<T['storage']>>> & StorageFlag) | GPUBuffer : T extends TgpuLayoutSampler ? TgpuSampler | GPUSampler : T extends TgpuLayoutComparisonSampler ? TgpuComparisonSampler | GPUSampler : T extends TgpuLayoutTexture ? GPUTextureView | GPUTexture | (SampledFlag & TgpuTexture<Prettify<PropsForSchema<T['texture']>>>) | TgpuTextureView<WgslTexture> : T extends TgpuLayoutStorageTexture ? GPUTextureView | GPUTexture | (StorageFlag & TgpuTexture<Prettify<PropsForSchema<T['storageTexture']>>>) | TgpuTextureView<WgslStorageTexture> : 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<infer TSchema> ? TgpuTextureView<TSchema> : T extends TgpuLayoutStorageTexture<infer TSchema> ? TgpuTextureView<TSchema> : T extends TgpuLayoutExternalTexture ? TgpuExternalTexture : never;
+type InferLayoutEntry<T extends TgpuLayoutEntry | null> = T extends TgpuLayoutUniform ? InferGPU<T['uniform']> : T extends TgpuLayoutStorage ? InferGPU<UnwrapRuntimeConstructor<T['storage']>> : T extends TgpuLayoutSampler ? InferGPU<WgslSampler> : T extends TgpuLayoutComparisonSampler ? InferGPU<WgslComparisonSampler> : T extends TgpuLayoutTexture<infer TSchema> ? InferGPU<TSchema> : T extends TgpuLayoutStorageTexture<infer TSchema> ? InferGPU<TSchema> : T extends TgpuLayoutExternalTexture ? InferGPU<T['externalTexture']> : never;
+type ExtractBindGroupInputFromLayout<T extends Record<string, TgpuLayoutEntry | null>> = NullableToOptional<{ [K in keyof T]: LayoutEntryToInput<T[K]> }>;
+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>>;
+/**
+ * @deprecated Layouts containing the legacy texture api entries are deprecated and will be removed in future versions. Please use the up-to-date texture api entries instead.
+ */
+declare function bindGroupLayout<Entries extends Record<string, TgpuLegacyLayoutEntry | null>>(entries: Entries): TgpuBindGroupLayout<Prettify<MapLegacyTextureToUpToDate<Entries>>>;
+//#endregion
+export { BindLayoutEntry, ExtractBindGroupInputFromLayout, LayoutEntryToInput, TgpuBindGroup, TgpuBindGroupLayout, TgpuLayoutComparisonSampler, TgpuLayoutEntry, TgpuLayoutExternalTexture, TgpuLayoutSampler, TgpuLayoutStorage, TgpuLayoutTexture, TgpuLayoutUniform, UnwrapRuntimeConstructor, bindGroupLayout };

package/tgpuBindGroupLayout.js

@@ -0,0 +1,272 @@
+import { $gpuValueOf, $internal } from "./shared/symbols.js";
+import { getName, setName } from "./shared/meta.js";
+import { NotUniformError } from "./errors.js";
+import { safeStringify } from "./shared/stringify.js";
+import { f32, i32, u32 } from "./data/numeric.js";
+import { NotStorageError, isUsableAsStorage } from "./extension.js";
+import { TgpuLaidOutBufferImpl, isUsableAsUniform } from "./core/buffer/bufferUsage.js";
+import { isBuffer } from "./core/buffer/buffer.js";
+import { comparisonSampler, sampler } from "./data/sampler.js";
+import { TgpuLaidOutSamplerImpl, isComparisonSampler, isSampler } from "./core/sampler/sampler.js";
+import { textureDescriptorToSchema } from "./data/texture.js";
+import { TgpuExternalTextureImpl } from "./core/texture/externalTexture.js";
+import { TgpuLaidOutTextureViewImpl, isTexture, isTextureView } from "./core/texture/texture.js";
+import { NotSampledError, isUsableAsSampled } from "./core/texture/usageExtension.js";
+//#region src/tgpuBindGroupLayout.ts
+/**
+* Converts legacy entries to new API format
+*/
+function convertLegacyEntries(entries) {
+	const result = {};
+	for (const [key, entry] of Object.entries(entries)) {
+		if (entry === null) {
+			result[key] = null;
+			continue;
+		}
+		if ("texture" in entry && typeof entry.texture === "string") {
+			const sampleType = entry.texture;
+			result[key] = {
+				...entry,
+				texture: textureDescriptorToSchema({
+					dimension: entry.viewDimension ?? "2d",
+					sampleType: sampleType === "sint" ? i32 : sampleType === "uint" ? u32 : f32,
+					multisampled: entry.multisampled ?? false
+				})
+			};
+		} else if ("storageTexture" in entry && typeof entry.storageTexture === "string") {
+			const accessMap = {
+				readonly: "read-only",
+				writeonly: "write-only",
+				mutable: "read-write"
+			};
+			result[key] = {
+				...entry,
+				storageTexture: textureDescriptorToSchema({
+					access: accessMap[entry.access ?? "writeonly"],
+					format: entry.storageTexture,
+					dimension: entry.viewDimension ?? "2d"
+				})
+			};
+		} else if ("externalTexture" in entry && Object.keys(entry.externalTexture).length === 0) result[key] = {
+			...entry,
+			externalTexture: {
+				type: "texture_external",
+				dimension: "2d"
+			}
+		};
+		else result[key] = entry;
+	}
+	return result;
+}
+function bindGroupLayout(entries) {
+	return new TgpuBindGroupLayoutImpl(convertLegacyEntries(entries));
+}
+function isBindGroupLayout(value) {
+	return !!value && value.resourceType === "bind-group-layout";
+}
+function isBindGroup(value) {
+	return !!value && value.resourceType === "bind-group";
+}
+/**
+* @category Errors
+*/
+var MissingBindingError = class MissingBindingError extends Error {
+	constructor(groupLabel, key) {
+		super(`Bind group '${groupLabel ?? "<unnamed>"}' is missing a required binding '${key}'`);
+		Object.setPrototypeOf(this, MissingBindingError.prototype);
+	}
+};
+const DEFAULT_MUTABLE_VISIBILITY = ["compute", "fragment"];
+const DEFAULT_READONLY_VISIBILITY = [
+	"compute",
+	"vertex",
+	"fragment"
+];
+var TgpuBindGroupLayoutImpl = class {
+	#index;
+	[$internal];
+	resourceType = "bind-group-layout";
+	value = {};
+	$ = this.value;
+	entries;
+	get [$gpuValueOf]() {
+		return this.$;
+	}
+	constructor(entries) {
+		this.entries = entries;
+		let idx = 0;
+		const bound = {};
+		this[$internal] = { bound };
+		for (const [key, entry] of Object.entries(entries)) {
+			if (entry === null) {
+				idx++;
+				continue;
+			}
+			const membership = {
+				layout: this,
+				key,
+				idx
+			};
+			if ("uniform" in entry) bound[key] = new TgpuLaidOutBufferImpl("uniform", entry.uniform, membership);
+			if ("storage" in entry) {
+				const dataType = "type" in entry.storage ? entry.storage : entry.storage(0);
+				bound[key] = new TgpuLaidOutBufferImpl(entry.access ?? "readonly", dataType, membership);
+			}
+			if ("texture" in entry) bound[key] = new TgpuLaidOutTextureViewImpl(entry.texture, membership);
+			if ("storageTexture" in entry) bound[key] = new TgpuLaidOutTextureViewImpl(entry.storageTexture, membership);
+			if ("externalTexture" in entry) bound[key] = new TgpuExternalTextureImpl(entry.externalTexture, membership);
+			if ("sampler" in entry) bound[key] = new TgpuLaidOutSamplerImpl(entry.sampler === "comparison" ? comparisonSampler() : sampler(), membership);
+			Object.defineProperty(this.value, key, { get: () => {
+				return bound[key].value;
+			} });
+			idx++;
+		}
+	}
+	toString() {
+		return `bindGroupLayout:${getName(this) ?? "<unnamed>"}`;
+	}
+	get index() {
+		return this.#index;
+	}
+	$name(label) {
+		setName(this, label);
+		return this;
+	}
+	get bound() {
+		return this[$internal].bound;
+	}
+	$idx(index) {
+		this.#index = index;
+		return this;
+	}
+	unwrap(unwrapper) {
+		return unwrapper.device.createBindGroupLayout({
+			label: getName(this) ?? "<unnamed>",
+			entries: Object.values(this.entries).map((entry, idx) => {
+				if (entry === null) return null;
+				let visibility = entry.visibility;
+				const binding = {
+					binding: idx,
+					visibility: 0
+				};
+				if ("uniform" in entry) {
+					visibility = visibility ?? DEFAULT_READONLY_VISIBILITY;
+					binding.buffer = { type: "uniform" };
+				} else if ("storage" in entry) {
+					visibility = visibility ?? (entry.access === "mutable" ? DEFAULT_MUTABLE_VISIBILITY : DEFAULT_READONLY_VISIBILITY);
+					binding.buffer = { type: entry.access === "mutable" ? "storage" : "read-only-storage" };
+				} else if ("sampler" in entry) {
+					visibility = visibility ?? DEFAULT_READONLY_VISIBILITY;
+					binding.sampler = { type: entry.sampler };
+				} else if ("texture" in entry) {
+					visibility = visibility ?? DEFAULT_READONLY_VISIBILITY;
+					const { multisampled, dimension, bindingSampleType } = entry.texture;
+					binding.texture = {
+						sampleType: entry.sampleType ?? bindingSampleType[0],
+						viewDimension: dimension,
+						multisampled
+					};
+				} else if ("storageTexture" in entry) {
+					visibility = visibility ?? DEFAULT_MUTABLE_VISIBILITY;
+					const { dimension, access, format } = entry.storageTexture;
+					binding.storageTexture = {
+						access,
+						format,
+						viewDimension: dimension
+					};
+				} else if ("externalTexture" in entry) {
+					visibility = visibility ?? DEFAULT_READONLY_VISIBILITY;
+					binding.externalTexture = {};
+				}
+				if (visibility?.includes("compute")) binding.visibility |= GPUShaderStage.COMPUTE;
+				if (visibility?.includes("vertex")) binding.visibility |= GPUShaderStage.VERTEX;
+				if (visibility?.includes("fragment")) binding.visibility |= GPUShaderStage.FRAGMENT;
+				return binding;
+			}).filter((v) => v !== null)
+		});
+	}
+};
+var TgpuBindGroupImpl = class {
+	resourceType = "bind-group";
+	layout;
+	entries;
+	constructor(layout, entries) {
+		this.layout = layout;
+		this.entries = entries;
+		for (const key of Object.keys(layout.entries)) if (layout.entries[key] !== null && !(key in entries)) throw new MissingBindingError(getName(layout), key);
+	}
+	unwrap(unwrapper) {
+		return unwrapper.device.createBindGroup({
+			label: getName(this.layout) ?? "<unnamed>",
+			layout: unwrapper.unwrap(this.layout),
+			entries: Object.entries(this.layout.entries).map(([key, entry], idx) => {
+				if (entry === null) return null;
+				const value = this.entries[key];
+				if (value === void 0) throw new Error(`'${key}' is a resource required to populate bind group layout '${getName(this.layout) ?? "<unnamed>"}'.`);
+				if ("uniform" in entry) {
+					let resource;
+					if (isBuffer(value)) {
+						if (!isUsableAsUniform(value)) throw new NotUniformError(value);
+						resource = { buffer: unwrapper.unwrap(value) };
+					} else resource = { buffer: value };
+					return {
+						binding: idx,
+						resource
+					};
+				}
+				if ("storage" in entry) {
+					let resource;
+					if (isBuffer(value)) {
+						if (!isUsableAsStorage(value)) throw new NotStorageError(value);
+						resource = { buffer: unwrapper.unwrap(value) };
+					} else resource = { buffer: value };
+					return {
+						binding: idx,
+						resource
+					};
+				}
+				if ("texture" in entry) {
+					let resource;
+					if (isTexture(value)) {
+						if (!isUsableAsSampled(value)) throw new NotSampledError(value);
+						resource = unwrapper.unwrap(value.createView(entry.texture));
+					} else if (isTextureView(value)) resource = unwrapper.unwrap(value);
+					else resource = value;
+					return {
+						binding: idx,
+						resource
+					};
+				}
+				if ("storageTexture" in entry) {
+					let resource;
+					if (isTexture(value)) {
+						if (!isUsableAsStorage(value)) throw new NotStorageError(value);
+						resource = unwrapper.unwrap(value.createView(entry.storageTexture));
+					} else if (isTextureView(value)) resource = unwrapper.unwrap(value);
+					else resource = value;
+					return {
+						binding: idx,
+						resource
+					};
+				}
+				if ("sampler" in entry) {
+					if (isComparisonSampler(value) || isSampler(value)) return {
+						binding: idx,
+						resource: unwrapper.unwrap(value)
+					};
+					return {
+						binding: idx,
+						resource: value
+					};
+				}
+				if ("externalTexture" in entry) return {
+					binding: idx,
+					resource: value
+				};
+				throw new Error(`Malformed bind group entry: ${safeStringify(value)}`);
+			}).filter((v) => v !== null)
+		});
+	}
+};
+//#endregion
+export { TgpuBindGroupImpl, bindGroupLayout, isBindGroup, isBindGroupLayout };

package/tgpuUnstable.d.ts

@@ -0,0 +1,48 @@
+import { computeFn } from "./core/function/tgpuComputeFn.js";
+import { privateVar, workgroupVar } from "./core/variable/tgpuVariable.js";
+import { fragmentFn } from "./core/function/tgpuFragmentFn.js";
+import { vertexFn } from "./core/function/tgpuVertexFn.js";
+import { vertexLayout } from "./core/vertexLayout/vertexLayout.js";
+import { declare } from "./core/declare/tgpuDeclare.js";
+import { fn } from "./core/function/tgpuFn.js";
+import { constant } from "./core/constant/tgpuConstant.js";
+import { comptime } from "./core/function/comptime.js";
+import { namespace } from "./core/resolve/namespace.js";
+import { slot } from "./core/slot/slot.js";
+import { lazy } from "./core/slot/lazy.js";
+import { accessor, mutableAccessor } from "./core/slot/accessor.js";
+import { rawCodeSnippet } from "./core/rawCodeSnippet/tgpuRawCodeSnippet.js";
+import { simulate } from "./core/simulate/tgpuSimulate.js";
+
+//#region src/tgpuUnstable.d.ts
+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 };
+}
+/** @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
+export { tgpuUnstable_d_exports };

package/tgpuUnstable.js

@@ -0,0 +1,64 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { comptime } from "./core/function/comptime.js";
+import { constant } from "./core/constant/tgpuConstant.js";
+import { fn } from "./core/function/tgpuFn.js";
+import { namespace } from "./core/resolve/namespace.js";
+import { slot } from "./core/slot/slot.js";
+import { privateVar, workgroupVar } from "./core/variable/tgpuVariable.js";
+import { computeFn } from "./core/function/tgpuComputeFn.js";
+import { vertexLayout } from "./core/vertexLayout/vertexLayout.js";
+import { lazy } from "./core/slot/lazy.js";
+import { accessor, mutableAccessor } from "./core/slot/accessor.js";
+import { fragmentFn } from "./core/function/tgpuFragmentFn.js";
+import { vertexFn } from "./core/function/tgpuVertexFn.js";
+import { declare } from "./core/declare/tgpuDeclare.js";
+import { rawCodeSnippet } from "./core/rawCodeSnippet/tgpuRawCodeSnippet.js";
+import { simulate } from "./core/simulate/tgpuSimulate.js";
+//#region src/tgpuUnstable.ts
+var tgpuUnstable_exports = /* @__PURE__ */ __exportAll({
+	accessor: () => _accessor,
+	comptime: () => _comptime,
+	computeFn: () => _computeFn,
+	const: () => _constant,
+	declare: () => declare,
+	derived: () => _lazy,
+	fn: () => _fn,
+	fragmentFn: () => _fragmentFn,
+	mutableAccessor: () => _mutableAccessor,
+	namespace: () => namespace,
+	privateVar: () => _privateVar,
+	rawCodeSnippet: () => rawCodeSnippet,
+	simulate: () => simulate,
+	slot: () => _slot,
+	vertexFn: () => _vertexFn,
+	vertexLayout: () => _vertexLayout,
+	workgroupVar: () => _workgroupVar
+});
+/** @deprecated This feature is now stable, use tgpu.const. */
+const _constant = constant;
+/** @deprecated This feature is now stable, use tgpu.comptime. */
+const _comptime = comptime;
+/** @deprecated This feature is now stable, use tgpu.computeFn. */
+const _computeFn = computeFn;
+/** @deprecated This feature is now stable, use tgpu.fn. */
+const _fn = fn;
+/** @deprecated This feature is now stable, use tgpu.fragmentFn. */
+const _fragmentFn = fragmentFn;
+/** @deprecated This feature is now stable, use tgpu.vertexFn. */
+const _vertexFn = vertexFn;
+/** @deprecated This feature is now stable, use tgpu.accessor. */
+const _accessor = accessor;
+/** @deprecated This feature is now stable, use tgpu.mutableAccessor. */
+const _mutableAccessor = mutableAccessor;
+/** @deprecated This feature is now stable, use tgpu.lazy. */
+const _lazy = lazy;
+/** @deprecated This feature is now stable, use tgpu.slot. */
+const _slot = slot;
+/** @deprecated This feature is now stable, use tgpu.privateVar. */
+const _privateVar = privateVar;
+/** @deprecated This feature is now stable, use tgpu.workgroupVar. */
+const _workgroupVar = workgroupVar;
+/** @deprecated This feature is now stable, use tgpu.vertexLayout. */
+const _vertexLayout = vertexLayout;
+//#endregion
+export { tgpuUnstable_exports };

package/tgsl/accessIndex.js

@@ -0,0 +1,43 @@
+import { isNaturallyEphemeral, isPtr, isVec, isWgslArray, isWgslStruct } from "../data/wgslTypes.js";
+import { MatrixColumnsAccess, UnknownData, isDisarray } from "../data/dataTypes.js";
+import { isEphemeralSnippet, snip } from "../data/snippet.js";
+import { isKnownAtComptime } from "../types.js";
+import { stitch } from "../core/resolve/stitch.js";
+import { derefSnippet } from "../data/ref.js";
+import { coerceToSnippet } from "./generationHelpers.js";
+import { vec2f, vec3f, vec4f } from "../data/vector.js";
+import { accessProp } from "./accessProp.js";
+//#region src/tgsl/accessIndex.ts
+const indexableTypeToResult = {
+	mat2x2f: vec2f,
+	mat3x3f: vec3f,
+	mat4x4f: vec4f
+};
+function accessIndex(target, indexArg) {
+	const index = typeof indexArg === "number" ? coerceToSnippet(indexArg) : indexArg;
+	if (isWgslArray(target.dataType) || isDisarray(target.dataType)) {
+		const elementType = target.dataType.elementType;
+		const isElementNatEph = isNaturallyEphemeral(elementType);
+		const isTargetEphemeral = isEphemeralSnippet(target);
+		const isIndexConstant = index.origin === "constant";
+		let origin;
+		if (target.origin === "constant-tgpu-const-ref") if (isIndexConstant) origin = isElementNatEph ? "constant" : "constant-tgpu-const-ref";
+		else origin = isElementNatEph ? "runtime" : "runtime-tgpu-const-ref";
+		else if (target.origin === "runtime-tgpu-const-ref") origin = isElementNatEph ? "runtime" : "runtime-tgpu-const-ref";
+		else if (!isTargetEphemeral && !isElementNatEph) origin = target.origin;
+		else if (isIndexConstant && target.origin === "constant") origin = "constant";
+		else origin = "runtime";
+		return snip(isKnownAtComptime(target) && isKnownAtComptime(index) ? target.value[index.value] : stitch`${target}[${index}]`, elementType, origin);
+	}
+	if (isVec(target.dataType)) return snip(isKnownAtComptime(target) && isKnownAtComptime(index) ? target.value[index.value] : stitch`${target}[${index}]`, target.dataType.primitive, target.origin === "constant" || target.origin === "constant-tgpu-const-ref" ? "constant" : "runtime");
+	if (isPtr(target.dataType)) return accessIndex(derefSnippet(target), index);
+	if (target.value instanceof MatrixColumnsAccess) {
+		const propType = indexableTypeToResult[target.value.matrix.dataType.type];
+		return snip(stitch`${target.value.matrix}[${index}]`, propType, target.origin);
+	}
+	if (target.dataType.type in indexableTypeToResult) throw new Error("The only way of accessing matrix elements in TypeGPU functions is through the 'columns' property.");
+	if (isKnownAtComptime(target) && isKnownAtComptime(index) || target.dataType === UnknownData) return coerceToSnippet(target.value[index.value]);
+	if (isWgslStruct(target.dataType) && isKnownAtComptime(index) && typeof index.value === "string") return accessProp(target, index.value);
+}
+//#endregion
+export { accessIndex };