typegpu 0.10.1 → 0.11.0-rc.1

package/tgsl/conversion.js

@@ -0,0 +1,198 @@
+import { DEV, TEST } from "../shared/env.js";
+import { isMat, isPtr, isVec } from "../data/wgslTypes.js";
+import { UnknownData, undecorate } from "../data/dataTypes.js";
+import { snip } from "../data/snippet.js";
+import { WgslTypeError, invariant } from "../errors.js";
+import { stitch } from "../core/resolve/stitch.js";
+import { RefOperator, derefSnippet } from "../data/ref.js";
+import { schemaCallWrapperGPU } from "../data/schemaCallWrapper.js";
+import { safeStringify } from "../shared/stringify.js";
+import { assertExhaustive } from "../shared/utilityTypes.js";
+//#region src/tgsl/conversion.ts
+const INFINITE_RANK = {
+	rank: Number.POSITIVE_INFINITY,
+	action: "none"
+};
+function getAutoConversionRank(src, dest) {
+	const trueSrc = undecorate(src);
+	const trueDst = undecorate(dest);
+	if (trueSrc.type === trueDst.type) return {
+		rank: 0,
+		action: "none"
+	};
+	if (trueSrc.type === "abstractFloat") {
+		if (trueDst.type === "f32") return {
+			rank: 1,
+			action: "none"
+		};
+		if (trueDst.type === "f16") return {
+			rank: 2,
+			action: "none"
+		};
+	}
+	if (trueSrc.type === "abstractInt") {
+		if (trueDst.type === "i32") return {
+			rank: 3,
+			action: "none"
+		};
+		if (trueDst.type === "u32") return {
+			rank: 4,
+			action: "none"
+		};
+		if (trueDst.type === "abstractFloat") return {
+			rank: 5,
+			action: "none"
+		};
+		if (trueDst.type === "f32") return {
+			rank: 6,
+			action: "none"
+		};
+		if (trueDst.type === "f16") return {
+			rank: 7,
+			action: "none"
+		};
+	}
+	if (isVec(trueSrc) && isVec(trueDst) && trueSrc.type[3] === trueDst.type[3]) return getAutoConversionRank(trueSrc.primitive, trueDst.primitive);
+	if (isMat(trueSrc) && isMat(trueDst) && trueSrc.type[3] === trueDst.type[3]) return {
+		rank: 0,
+		action: "none"
+	};
+	return INFINITE_RANK;
+}
+function getImplicitConversionRank(src, dest) {
+	const trueSrc = undecorate(src);
+	const trueDst = undecorate(dest);
+	if (isPtr(trueSrc) && trueSrc.implicit && getAutoConversionRank(trueSrc.inner, trueDst).rank < Number.POSITIVE_INFINITY) return {
+		rank: 0,
+		action: "deref"
+	};
+	if (isPtr(trueDst) && getAutoConversionRank(trueSrc, trueDst.inner).rank < Number.POSITIVE_INFINITY) return {
+		rank: 1,
+		action: "ref"
+	};
+	const primitivePreference = {
+		f32: 0,
+		f16: 1,
+		i32: 2,
+		u32: 3,
+		bool: 4
+	};
+	if (trueSrc.type in primitivePreference && trueDst.type in primitivePreference) {
+		const srcType = trueSrc.type;
+		const destType = trueDst.type;
+		if (srcType !== destType) {
+			const srcPref = primitivePreference[srcType];
+			return {
+				rank: primitivePreference[destType] < srcPref ? 10 : 20,
+				action: "cast",
+				targetType: trueDst
+			};
+		}
+	}
+	if (trueSrc.type === "abstractFloat") {
+		if (trueDst.type === "u32") return {
+			rank: 2,
+			action: "cast",
+			targetType: trueDst
+		};
+		if (trueDst.type === "i32") return {
+			rank: 1,
+			action: "cast",
+			targetType: trueDst
+		};
+	}
+	return INFINITE_RANK;
+}
+function getConversionRank(src, dest, allowImplicit) {
+	const autoRank = getAutoConversionRank(src, dest);
+	if (autoRank.rank < Number.POSITIVE_INFINITY) return autoRank;
+	if (allowImplicit) return getImplicitConversionRank(src, dest);
+	return INFINITE_RANK;
+}
+function findBestType(types, uniqueTypes, allowImplicit) {
+	let bestResult;
+	for (const targetType of uniqueTypes) {
+		const details = [];
+		let sum = 0;
+		for (const sourceType of types) {
+			const conversion = getConversionRank(sourceType, targetType, allowImplicit);
+			sum += conversion.rank;
+			if (conversion.rank === Number.POSITIVE_INFINITY) break;
+			details.push(conversion);
+		}
+		if (sum < (bestResult?.sum ?? Number.POSITIVE_INFINITY)) bestResult = {
+			type: targetType,
+			details,
+			sum
+		};
+	}
+	if (!bestResult) return;
+	const actions = bestResult.details.map((detail, index) => ({
+		sourceIndex: index,
+		action: detail.action,
+		...detail.action === "cast" && { targetType: detail.targetType }
+	}));
+	return {
+		targetType: bestResult.type,
+		actions,
+		hasImplicitConversions: actions.some((action) => action.action === "cast")
+	};
+}
+function getBestConversion(types, targetTypes) {
+	if (types.length === 0) return void 0;
+	const uniqueTargetTypes = [...new Set((targetTypes || types).map(undecorate))];
+	const explicitResult = findBestType(types, uniqueTargetTypes, false);
+	if (explicitResult) return explicitResult;
+	const implicitResult = findBestType(types, uniqueTargetTypes, true);
+	if (implicitResult) return implicitResult;
+}
+function applyActionToSnippet(ctx, snippet, action, targetType) {
+	if (action.action === "none") return snip(snippet.value, targetType, snippet.origin);
+	switch (action.action) {
+		case "ref": return snip(new RefOperator(snippet, targetType), targetType, snippet.origin);
+		case "deref": return derefSnippet(snippet);
+		case "cast": return schemaCallWrapperGPU(ctx, targetType, snippet);
+		default: assertExhaustive(action.action, "applyActionToSnippet");
+	}
+}
+function unify(inTypes, restrictTo) {
+	if (inTypes.some((type) => type === UnknownData)) return;
+	const conversion = getBestConversion(inTypes, restrictTo);
+	if (!conversion) return;
+	return inTypes.map((type) => isVec(type) || isMat(type) ? type : conversion.targetType);
+}
+function convertToCommonType(ctx, values, restrictTo, verbose = true) {
+	const types = values.map((value) => value.dataType);
+	if (types.some((type) => type === UnknownData)) return;
+	if (DEV && Array.isArray(restrictTo) && restrictTo.length === 0) console.warn("convertToCommonType was called with an empty restrictTo array, which prevents any conversions from being made. If you intend to allow all conversions, pass undefined instead. If this was intended call the function conditionally since the result will always be undefined.");
+	const conversion = getBestConversion(types, restrictTo);
+	if (!conversion) return;
+	if ((TEST || DEV) && verbose && conversion.hasImplicitConversions) console.warn(`Implicit conversions from [\n${values.map((v) => `  ${v.value}: ${safeStringify(v.dataType)}`).join(",\n")}\n] to ${conversion.targetType.type} are supported, but not recommended.
+Consider using explicit conversions instead.`);
+	return values.map((value, index) => {
+		const action = conversion.actions[index];
+		invariant(action, "Action should not be undefined");
+		return applyActionToSnippet(ctx, value, action, conversion.targetType);
+	});
+}
+function tryConvertSnippet(ctx, snippet, targetDataTypes, verbose = true) {
+	const targets = Array.isArray(targetDataTypes) ? targetDataTypes : [targetDataTypes];
+	const { value, dataType, origin } = snippet;
+	if (targets.length === 1) {
+		const target = targets[0];
+		if (target === dataType) return snip(value, target, origin);
+		if (dataType === UnknownData) return snip(stitch`${snip(value, target, origin)}`, target, origin);
+	}
+	const converted = convertToCommonType(ctx, [snippet], targets, verbose);
+	if (converted) return converted[0];
+	throw new WgslTypeError(`Cannot convert value of type '${String(dataType)}' to any of the target types: [${targets.map((t) => t.type).join(", ")}]`);
+}
+function convertStructValues(ctx, structType, values) {
+	return Object.entries(structType.propTypes).map(([key, targetType]) => {
+		const val = values[key];
+		if (!val) throw new Error(`Missing property ${key}`);
+		return convertToCommonType(ctx, [val], [targetType])?.[0] ?? val;
+	});
+}
+//#endregion
+export { convertStructValues, convertToCommonType, getBestConversion, tryConvertSnippet, unify };

package/tgsl/forOfUtils.js

@@ -0,0 +1,71 @@
+import { $gpuCallable } from "../shared/symbols.js";
+import { isPtr, isVec, isWgslArray } from "../data/wgslTypes.js";
+import { UnknownData } from "../data/dataTypes.js";
+import { isEphemeralSnippet, snip } from "../data/snippet.js";
+import { WgslTypeError, invariant } from "../errors.js";
+import { stitch } from "../core/resolve/stitch.js";
+import { createPtrFromOrigin, implicitFrom } from "../data/ptr.js";
+import { i32, u32 } from "../data/numeric.js";
+import { ArrayExpression, concretize } from "./generationHelpers.js";
+import { accessIndex } from "./accessIndex.js";
+import { arrayLength } from "../std/array.js";
+import { isTgpuRange } from "../std/range.js";
+//#region src/tgsl/forOfUtils.ts
+function getLoopVarKind(elementSnippet) {
+	return elementSnippet.origin === "constant-tgpu-const-ref" ? "const" : "let";
+}
+function getElementSnippet(iterableSnippet, index) {
+	const elementSnippet = accessIndex(iterableSnippet, index);
+	if (!elementSnippet) throw new WgslTypeError("`for ... of ...` loops only support array or vector iterables");
+	return elementSnippet;
+}
+function getElementType(elementSnippet, iterableSnippet) {
+	let elementType = elementSnippet.dataType;
+	if (elementType === UnknownData) throw new WgslTypeError(stitch`The elements in iterable ${iterableSnippet} are of unknown type`);
+	if (isEphemeralSnippet(elementSnippet) || elementSnippet.origin === "constant-tgpu-const-ref" || elementSnippet.origin === "runtime-tgpu-const-ref") return elementType;
+	if (!isPtr(elementType)) {
+		const ptrType = createPtrFromOrigin(elementSnippet.origin, concretize(elementType));
+		invariant(ptrType !== void 0, `Creating pointer type from origin ${elementSnippet.origin}`);
+		elementType = ptrType;
+	}
+	return implicitFrom(elementType);
+}
+function getRangeSnippets(ctx, iterableSnippet, unroll = false) {
+	const { value, dataType } = iterableSnippet;
+	if (isTgpuRange(value)) return {
+		start: snip(value.start, i32, "constant"),
+		end: snip(value.end, i32, "constant"),
+		step: snip(value.step, i32, "constant"),
+		comparison: value.step < 0 ? ">" : "<"
+	};
+	if (!unroll && isEphemeralSnippet(iterableSnippet)) throw new Error(`\`for ... of ...\` loops only support std.range or iterables stored in variables.
+-----
+You can wrap iterable with \`tgpu.unroll(...)\`. If iterable is known at comptime, the loop will be unrolled.
+-----`);
+	const defaults = {
+		start: snip(0, u32, "constant"),
+		step: snip(1, u32, "constant"),
+		comparison: "<"
+	};
+	if (isWgslArray(dataType)) return {
+		...defaults,
+		end: dataType.elementCount > 0 ? snip(dataType.elementCount, u32, "constant") : arrayLength[$gpuCallable].call(ctx, [iterableSnippet])
+	};
+	if (isVec(dataType)) return {
+		...defaults,
+		end: snip(dataType.componentCount, u32, "constant")
+	};
+	if (unroll) {
+		if (Array.isArray(value)) return {
+			...defaults,
+			end: snip(value.length, u32, "constant")
+		};
+		if (value instanceof ArrayExpression) return {
+			...defaults,
+			end: snip(value.elements.length, u32, "constant")
+		};
+	}
+	throw new WgslTypeError("`for ... of ...` loops only support array or vector iterables");
+}
+//#endregion
+export { getElementSnippet, getElementType, getLoopVarKind, getRangeSnippets };

package/tgsl/generationHelpers.d.ts

@@ -0,0 +1,37 @@
+import { Snippet } from "../data/snippet.js";
+import { ShelllessRepository } from "./shellless.js";
+import { FunctionScopeLayer, ResolutionCtx } from "../types.js";
+import { BaseData } from "../data/wgslTypes.js";
+
+//#region src/tgsl/generationHelpers.d.ts
+type GenerationCtx = ResolutionCtx & {
+  readonly pre: string;
+  /**
+   * Used by `typedExpression` to signal downstream
+   * expression resolution what type is expected of them.
+   *
+   * It is used exclusively for inferring the types of structs and arrays.
+   * It is modified exclusively by `typedExpression` function.
+   */
+  expectedType: (BaseData | BaseData[]) | undefined;
+  readonly topFunctionScope: FunctionScopeLayer | undefined;
+  readonly topFunctionReturnType: BaseData | undefined;
+  indent(): string;
+  dedent(): string;
+  pushBlockScope(): void;
+  popBlockScope(): void;
+  generateLog(op: string, args: Snippet[]): Snippet;
+  getById(id: string): Snippet | null;
+  defineVariable(id: string, snippet: Snippet): void;
+  setBlockExternals(externals: Record<string, Snippet>): void;
+  clearBlockExternals(): void;
+  /**
+   * Types that are used in `return` statements are
+   * reported using this function, and used to infer
+   * the return type of the owning function.
+   */
+  reportReturnType(dataType: BaseData): void;
+  readonly shelllessRepo: ShelllessRepository;
+};
+//#endregion
+export { GenerationCtx };

package/tgsl/generationHelpers.js

@@ -0,0 +1,67 @@
+import { $internal, $resolve } from "../shared/symbols.js";
+import { WORKAROUND_getSchema, isMatInstance, isNaturallyEphemeral, isVecInstance } from "../data/wgslTypes.js";
+import { UnknownData } from "../data/dataTypes.js";
+import { isEphemeralSnippet, isSnippet, snip } from "../data/snippet.js";
+import { WgslTypeError } from "../errors.js";
+import { getOwnSnippet } from "../types.js";
+import { stitch } from "../core/resolve/stitch.js";
+import { isRef } from "../data/ref.js";
+import { abstractFloat, abstractInt, bool, f32, i32 } from "../data/numeric.js";
+//#region src/tgsl/generationHelpers.ts
+function numericLiteralToSnippet(value) {
+	if (value >= 2 ** 63 || value < -(2 ** 63)) return snip(value, abstractFloat, "constant");
+	if (Number.isInteger(value)) {
+		if (!Number.isSafeInteger(value)) console.warn(`The integer ${value} exceeds the safe integer range and may have lost precision.`);
+		return snip(value, abstractInt, "constant");
+	}
+	return snip(value, abstractFloat, "constant");
+}
+function concretize(type) {
+	if (type.type === "abstractFloat") return f32;
+	if (type.type === "abstractInt") return i32;
+	return type;
+}
+function concretizeSnippet(snippet) {
+	return snip(snippet.value, concretize(snippet.dataType), snippet.origin);
+}
+function concretizeSnippets(args) {
+	return args.map(concretizeSnippet);
+}
+function coerceToSnippet(value) {
+	if (isSnippet(value)) return value;
+	if (isRef(value)) throw new Error("Cannot use refs (d.ref(...)) from the outer scope.");
+	const ownSnippet = getOwnSnippet(value);
+	if (ownSnippet) return ownSnippet;
+	if (isVecInstance(value) || isMatInstance(value)) return snip(value, WORKAROUND_getSchema(value), "constant");
+	if (typeof value === "string" || typeof value === "function" || typeof value === "object" || typeof value === "symbol" || typeof value === "undefined" || value === null) return snip(value, UnknownData, "constant");
+	if (typeof value === "number") return numericLiteralToSnippet(value);
+	if (typeof value === "boolean") return snip(value, bool, "constant");
+	return snip(value, UnknownData, "constant");
+}
+/**
+* Intermediate representation for WGSL array expressions.
+* Defers resolution. Stores array elements as snippets so the
+* generator can access them when needed.
+*/
+var ArrayExpression = class {
+	[$internal] = true;
+	type;
+	elements;
+	constructor(type, elements) {
+		this.type = type;
+		this.elements = elements;
+	}
+	toString() {
+		return "ArrayExpression";
+	}
+	[$resolve](ctx) {
+		for (const elem of this.elements) if (elem.origin === "argument" && !isNaturallyEphemeral(elem.dataType) || !isEphemeralSnippet(elem)) {
+			const snippetStr = ctx.resolve(elem.value, elem.dataType).value;
+			const snippetType = ctx.resolve(concretize(elem.dataType)).value;
+			throw new WgslTypeError(`'${snippetStr}' reference cannot be used in an array constructor.\n-----\nTry '${snippetType}(${snippetStr})' or 'arrayOf(${snippetType}, count)([...])' to copy the value instead.\n-----`);
+		}
+		return snip(stitch`${`array<${ctx.resolve(this.type.elementType).value}, ${this.elements.length}>`}(${this.elements})`, this.type, "runtime");
+	}
+};
+//#endregion
+export { ArrayExpression, coerceToSnippet, concretize, concretizeSnippets, numericLiteralToSnippet };

package/tgsl/math.js

@@ -0,0 +1,43 @@
+import { f32 } from "../data/numeric.js";
+import { abs, acos, acosh, asin, asinh, atan, atan2, atanh, ceil, cos, cosh, countLeadingZeros, exp, floor, log, log2, max, min, pow, sign, sin, sinh, sqrt, tan, tanh, trunc } from "../std/numeric.js";
+//#region src/tgsl/math.ts
+const mathToStd = {
+	abs,
+	acos,
+	acosh,
+	asin,
+	asinh,
+	atan,
+	atan2,
+	atanh,
+	ceil,
+	cos,
+	cosh,
+	exp,
+	floor,
+	fround: f32,
+	clz32: countLeadingZeros,
+	trunc,
+	log,
+	log2,
+	pow,
+	sign,
+	sin,
+	sinh,
+	sqrt,
+	tan,
+	tanh,
+	max,
+	min,
+	cbrt: void 0,
+	log10: void 0,
+	log1p: void 0,
+	f16round: void 0,
+	hypot: void 0,
+	expm1: void 0,
+	random: void 0,
+	imul: void 0,
+	round: void 0
+};
+//#endregion
+export { mathToStd };

package/tgsl/shaderGenerator.d.ts

@@ -0,0 +1,20 @@
+import { ResolvedSnippet, Snippet } from "../data/snippet.js";
+import { GenerationCtx } from "./generationHelpers.js";
+import { BaseData } from "../data/wgslTypes.js";
+import { Block } from "tinyest";
+
+//#region src/tgsl/shaderGenerator.d.ts
+/**
+ * **NOTE: This is an unstable API and may change in the future.**
+ *
+ * An interface meant to be used by other systems to generate snippets of
+ * shader code in the target language (WGSL, GLSL, etc.).
+ */
+interface ShaderGenerator {
+  initGenerator(ctx: GenerationCtx): void;
+  functionDefinition(body: Block): string;
+  typeInstantiation(schema: BaseData, args: readonly Snippet[]): ResolvedSnippet;
+  typeAnnotation(schema: BaseData): string;
+}
+//#endregion
+export { ShaderGenerator };

package/tgsl/shaderGenerator_members.d.ts

@@ -0,0 +1,2 @@
+import { ResolutionCtx } from "../types.js";
+import { UnknownData } from "../data/dataTypes.js";

package/tgsl/shaderGenerator_members.js

@@ -0,0 +1,6 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { UnknownData } from "../data/dataTypes.js";
+//#region src/tgsl/shaderGenerator_members.ts
+var shaderGenerator_members_exports = /* @__PURE__ */ __exportAll({ UnknownData: () => UnknownData });
+//#endregion
+export { shaderGenerator_members_exports };

package/tgsl/shellless.d.ts

@@ -0,0 +1,11 @@
+import { Snippet } from "../data/snippet.js";
+import { ShelllessImpl } from "../core/function/shelllessImpl.js";
+
+//#region src/tgsl/shellless.d.ts
+type AnyFn = (...args: never[]) => unknown;
+declare class ShelllessRepository {
+  cache: Map<AnyFn, ShelllessImpl[]>;
+  get(fn: AnyFn, argSnippets: Snippet[] | undefined): ShelllessImpl | undefined;
+}
+//#endregion
+export { ShelllessRepository };

package/tgsl/shellless.js

@@ -0,0 +1,46 @@
+import { getMetaData, getName } from "../shared/meta.js";
+import { isPtr, isWgslArray, isWgslStruct } from "../data/wgslTypes.js";
+import { UnknownData } from "../data/dataTypes.js";
+import { WgslTypeError } from "../errors.js";
+import { RefOperator } from "../data/ref.js";
+import { concretize } from "./generationHelpers.js";
+import { createShelllessImpl } from "../core/function/shelllessImpl.js";
+//#region src/tgsl/shellless.ts
+function shallowEqualSchemas(a, b) {
+	if (a.type !== b.type) return false;
+	if (isPtr(a) && isPtr(b)) return a.access === b.access && a.addressSpace === b.addressSpace && a.implicit === b.implicit && shallowEqualSchemas(a.inner, b.inner);
+	if (isWgslArray(a) && isWgslArray(b)) return a.elementCount === b.elementCount && shallowEqualSchemas(a.elementType, b.elementType);
+	if (isWgslStruct(a) && isWgslStruct(b)) return a === b;
+	return true;
+}
+var ShelllessRepository = class {
+	cache = /* @__PURE__ */ new Map();
+	get(fn, argSnippets) {
+		const meta = getMetaData(fn);
+		if (!meta?.ast) return void 0;
+		if (!argSnippets && meta.ast.params.length > 0) throw new Error(`Cannot resolve '${getName(fn)}' directly, because it expects arguments. Either call it from another function, or wrap it in a shell`);
+		const argTypes = (argSnippets ?? []).map((s, index) => {
+			if (s.value instanceof RefOperator) {
+				if (s.dataType === UnknownData) throw new WgslTypeError(`d.ref() created with primitive types must be stored in a variable before use`);
+				return s.dataType;
+			}
+			if (s.dataType === UnknownData) throw new Error(`Passed illegal value ${s.value} as the #${index} argument to ${meta.name}(...)\nShellless functions can only accept arguments representing WGSL resources: constructible WGSL types, d.refs, samplers or texture views.\nRemember, that arguments such as samplers, texture views, accessors, slots etc. should be dereferenced via '.$' first.`);
+			let type = concretize(s.dataType);
+			if (isPtr(type) && type.implicit) type = type.inner;
+			return type;
+		});
+		let cache = this.cache.get(fn);
+		if (cache) {
+			const variant = cache.find((v) => v.argTypes.length === argTypes.length && v.argTypes.every((t, i) => shallowEqualSchemas(t, argTypes[i])));
+			if (variant) return variant;
+		} else {
+			cache = [];
+			this.cache.set(fn, cache);
+		}
+		const shellless = createShelllessImpl(argTypes, fn);
+		cache.push(shellless);
+		return shellless;
+	}
+};
+//#endregion
+export { ShelllessRepository };

package/tgsl/wgslGenerator.d.ts

@@ -0,0 +1,36 @@
+import { Origin, ResolvedSnippet, Snippet } from "../data/snippet.js";
+import { GenerationCtx } from "./generationHelpers.js";
+import { ShaderGenerator } from "./shaderGenerator.js";
+import { BaseData, StorableData } from "../data/wgslTypes.js";
+import { UnknownData } from "../data/dataTypes.js";
+import { ExternalMap } from "../core/resolve/externals.js";
+import * as tinyest from "tinyest";
+
+//#region src/tgsl/wgslGenerator.d.ts
+declare class WgslGenerator implements ShaderGenerator {
+  #private;
+  initGenerator(ctx: GenerationCtx): void;
+  protected get ctx(): GenerationCtx;
+  _block([_, statements]: tinyest.Block, externalMap?: ExternalMap): string;
+  refVariable(id: string, dataType: StorableData): string;
+  blockVariable(varType: 'var' | 'let' | 'const', id: string, dataType: BaseData | UnknownData, origin: Origin): Snippet;
+  protected emitVarDecl(pre: string, keyword: 'var' | 'let' | 'const', name: string, _dataType: BaseData | UnknownData, rhsStr: string): string;
+  _identifier(id: string): Snippet;
+  /**
+   * A wrapper for `generateExpression` that updates `ctx.expectedType`
+   * and tries to convert the result when it does not match the expected type.
+   */
+  _typedExpression(expression: tinyest.Expression, expectedType: BaseData | BaseData[]): Snippet;
+  _expression(expression: tinyest.Expression): Snippet;
+  functionDefinition(body: tinyest.Block): string;
+  /**
+   * Generates a WGSL type string for the given data type, and adds necessary
+   * definitions to the shader preamble. This shouldn't be called directly, only
+   * through `ctx.resolve` to properly cache the result.
+   */
+  typeAnnotation(data: BaseData): string;
+  typeInstantiation(schema: BaseData, args: readonly Snippet[]): ResolvedSnippet;
+  _statement(statement: tinyest.Statement): string;
+}
+//#endregion
+export { WgslGenerator };