typegpu 0.10.1 → 0.10.2

package/core/function/extractArgs.js

@@ -0,0 +1,204 @@
+//#region src/core/function/extractArgs.ts
+/**
+* Extracts info about arguments of a given WGSL function string.
+* @example
+* const code = `
+*   fn add(a: i32, ＠location(0) b: i32, c) -> i32 {
+*     return a + b + c;
+*   }`;
+*
+* extractArgs(code);
+* // {
+* //   args: [
+* //     { identifier: 'a', attributes: [], type: 'i32' },
+* //     { identifier: 'b', attributes: ['＠location(0)'], type: 'i32' },
+* //     { identifier: 'c', attributes: [], type: undefined }
+* //   ],
+* //   ret: { type: 'i32', attributes: [] },
+* //   range: { begin: 11, end: 51 }
+* // }
+*/
+function extractArgs(rawCode) {
+	const { strippedCode, argRange: range } = strip(rawCode);
+	const code = new ParsableString(strippedCode);
+	code.consume("(");
+	const args = [];
+	while (!code.isAt(")")) {
+		const attributes = [];
+		while (code.isAt("@")) {
+			code.parseUntil(closingParenthesis, parentheses);
+			code.consume(")");
+			attributes.push(code.lastParsed);
+		}
+		code.parseUntil(identifierEndSymbols);
+		const identifier = code.lastParsed;
+		let maybeType;
+		if (code.isAt(":")) {
+			code.consume(":");
+			code.parseUntil(typeEndSymbols, angleBrackets);
+			maybeType = code.lastParsed;
+		}
+		args.push({
+			identifier,
+			attributes,
+			type: maybeType
+		});
+		if (code.isAt(",")) code.consume(",");
+	}
+	code.consume(")");
+	let maybeRet;
+	if (code.isAt("->")) {
+		code.consume("->");
+		const attributes = [];
+		while (code.isAt("@")) {
+			code.parseUntil(closingParenthesis, parentheses);
+			code.consume(")");
+			attributes.push(code.lastParsed);
+		}
+		maybeRet = {
+			type: code.str.slice(code.pos),
+			attributes
+		};
+	}
+	return {
+		args,
+		ret: maybeRet,
+		range: {
+			begin: range[0],
+			end: range[1]
+		}
+	};
+}
+/**
+* Strips comments, whitespaces, the name and the body of the function.
+* @example
+* const code = `
+*    fn add( a,  // first argument
+*            ＠location(0) b : i32 ) -> i32   {
+*        return a + b; // returns the sum
+*  }`;
+*
+* strip(code); // "(a,@location(0)b:i32)->i32"
+*/
+function strip(rawCode) {
+	const code = new ParsableString(rawCode);
+	let strippedCode = "";
+	let argsStart;
+	while (!code.isFinished()) {
+		if (code.isAt(blankSpaces)) {
+			code.advanceBy(1);
+			continue;
+		}
+		if (code.isAt("//")) {
+			code.consume("//");
+			code.parseUntil(lineBreaks);
+			code.advanceBy(1);
+			continue;
+		}
+		if (code.isAt("/*")) {
+			code.parseUntil(openingCommentBlock, commentBlocks);
+			code.consume("*/");
+			continue;
+		}
+		if (code.isAt("{")) return {
+			strippedCode,
+			argRange: [argsStart, code.pos]
+		};
+		if (code.isAt("(") && argsStart === void 0) argsStart = code.pos;
+		if (argsStart !== void 0) strippedCode += code.str[code.pos];
+		code.advanceBy(1);
+	}
+	throw new Error("Invalid wgsl code!");
+}
+var ParsableString = class {
+	#parseStartPos;
+	#pos;
+	constructor(str) {
+		this.str = str;
+		this.#pos = 0;
+	}
+	get pos() {
+		return this.#pos;
+	}
+	/**
+	* This property is equivalent to the substring of `this.str`
+	* from the position of the last `parseUntil` call, to the current position.
+	*/
+	get lastParsed() {
+		if (this.#parseStartPos === void 0) throw new Error("Parse was not called yet!");
+		return this.str.slice(this.#parseStartPos, this.pos);
+	}
+	isFinished() {
+		return this.#pos >= this.str.length;
+	}
+	isAt(substr) {
+		if (typeof substr === "string") {
+			for (let i = 0; i < substr.length; i++) if (this.str[this.#pos + i] !== substr[i]) return false;
+			return true;
+		}
+		for (const elem of substr) if (this.isAt(elem)) return true;
+		return false;
+	}
+	/**
+	* @param toFind a set of strings either of which satisfy the search.
+	* @param brackets a pair of brackets that has to be closed for result to be valid. This includes the found character(s).
+	* @example
+	* // internal state:
+	* // '(@attribute(0) identifier: type)'
+	* //   ^
+	* this.parse(new Set(')'), ['(', ')']);
+	* // internal state:
+	* // '(@attribute(0) identifier: type)'
+	* //               ^
+	*/
+	parseUntil(toFind, brackets) {
+		this.#parseStartPos = this.#pos;
+		let openedBrackets = 0;
+		while (this.#pos < this.str.length) {
+			if (brackets && this.isAt(brackets[0])) openedBrackets += 1;
+			if (brackets && this.isAt(brackets[1])) openedBrackets -= 1;
+			if (openedBrackets === 0) {
+				if (this.isAt(toFind)) return this.#pos;
+			}
+			this.#pos += 1;
+		}
+		throw new Error("Reached the end of the string without finding a match!");
+	}
+	advanceBy(steps) {
+		this.#pos += steps;
+	}
+	consume(str) {
+		if (!this.isAt(str)) throw new Error(`Expected '${str}' at position ${this.#pos}, but found '${this.str.slice(this.#pos, this.#pos + str.length)}'`);
+		this.advanceBy(str.length);
+	}
+};
+const lineBreaks = new Set([
+	"\n",
+	"\v",
+	"\f",
+	"\r",
+	"…",
+	"\u2028",
+	"\u2029"
+]);
+const blankSpaces = new Set([
+	...lineBreaks,
+	" ",
+	"	",
+	"‎",
+	"‏"
+]);
+const closingParenthesis = new Set([")"]);
+const identifierEndSymbols = new Set([
+	":",
+	",",
+	")"
+]);
+const typeEndSymbols = new Set([",", ")"]);
+const openingCommentBlock = new Set(["*/"]);
+const parentheses = ["(", ")"];
+const angleBrackets = ["<", ">"];
+const commentBlocks = ["/*", "*/"];
+
+//#endregion
+export { extractArgs };

package/core/function/fnCore.js

@@ -0,0 +1,79 @@
+import { $getNameForward } from "../../shared/symbols.js";
+import { getMetaData, getName } from "../../shared/meta.js";
+import { Void, isWgslData, isWgslStruct } from "../../data/wgslTypes.js";
+import { undecorate } from "../../data/dataTypes.js";
+import { snip } from "../../data/snippet.js";
+import { MissingLinksError } from "../../errors.js";
+import { getAttributesString } from "../../data/attributes.js";
+import { applyExternals, replaceExternalsInWgsl } from "../resolve/externals.js";
+import { extractArgs } from "./extractArgs.js";
+
+//#region src/core/function/fnCore.ts
+function createFnCore(implementation, fnAttribute = "") {
+	/**
+	* External application has to be deferred until resolution because
+	* some externals can reference the owner function which has not been
+	* initialized yet (like when accessing the Output struct of a vertex
+	* entry fn).
+	*/
+	const externalsToApply = [];
+	return {
+		[$getNameForward]: typeof implementation === "function" ? implementation : void 0,
+		applyExternals(newExternals) {
+			externalsToApply.push(newExternals);
+		},
+		resolve(ctx, argTypes, returnType) {
+			const externalMap = {};
+			for (const externals of externalsToApply) applyExternals(externalMap, externals);
+			const id = ctx.getUniqueName(this);
+			if (typeof implementation === "string") {
+				if (!returnType) throw new Error("Explicit return type is required for string implementation");
+				const replacedImpl = replaceExternalsInWgsl(ctx, externalMap, implementation);
+				let header = "";
+				let body = "";
+				if (fnAttribute !== "") {
+					const input = isWgslStruct(argTypes[0]) ? `(in: ${ctx.resolve(argTypes[0]).value})` : "()";
+					const attributes = isWgslData(returnType) ? getAttributesString(returnType) : "";
+					header = `${input} ${returnType !== Void ? isWgslStruct(returnType) ? `-> ${ctx.resolve(returnType).value}` : `-> ${attributes !== "" ? attributes : "@location(0)"} ${ctx.resolve(returnType).value}` : ""} `;
+					body = replacedImpl;
+				} else {
+					const providedArgs = extractArgs(replacedImpl);
+					if (providedArgs.args.length !== argTypes.length) throw new Error(`WGSL implementation has ${providedArgs.args.length} arguments, while the shell has ${argTypes.length} arguments.`);
+					header = `(${providedArgs.args.map((argInfo, i) => `${argInfo.identifier}: ${checkAndReturnType(ctx, `parameter ${argInfo.identifier}`, argInfo.type, argTypes[i])}`).join(", ")}) ${returnType === Void ? "" : `-> ${checkAndReturnType(ctx, "return type", providedArgs.ret?.type, returnType)}`}`;
+					body = replacedImpl.slice(providedArgs.range.end);
+				}
+				ctx.addDeclaration(`${fnAttribute}fn ${id}${header}${body}`);
+				return snip(id, returnType, "runtime");
+			}
+			const pluginData = getMetaData(implementation);
+			const pluginExternals = typeof pluginData?.externals === "function" ? pluginData.externals() : pluginData?.externals;
+			if (pluginExternals) applyExternals(externalMap, Object.fromEntries(Object.entries(pluginExternals).filter(([name]) => !(name in externalMap))));
+			const ast = pluginData?.ast;
+			if (!ast) throw new Error("Missing metadata for tgpu.fn function body (either missing 'use gpu' directive, or misconfigured `unplugin-typegpu`)");
+			const missingExternals = ast.externalNames.filter((name) => !(name in externalMap));
+			if (missingExternals.length > 0) throw new MissingLinksError(getName(this), missingExternals);
+			const maybeSecondArg = ast.params[1];
+			if (maybeSecondArg && maybeSecondArg.type === "i" && fnAttribute !== "") applyExternals(externalMap, { [maybeSecondArg.name]: undecorate(returnType) });
+			const { head, body, returnType: actualReturnType } = ctx.fnToWgsl({
+				functionType: fnAttribute.includes("@compute") ? "compute" : fnAttribute.includes("@vertex") ? "vertex" : fnAttribute.includes("@fragment") ? "fragment" : "normal",
+				argTypes,
+				params: ast.params,
+				returnType,
+				body: ast.body,
+				externalMap
+			});
+			ctx.addDeclaration(`${fnAttribute}fn ${id}${ctx.resolve(head).value}${ctx.resolve(body).value}`);
+			return snip(id, actualReturnType, "runtime");
+		}
+	};
+}
+function checkAndReturnType(ctx, name, wgslType, jsType) {
+	const resolvedJsType = ctx.resolve(jsType).value.replace(/\s/g, "");
+	if (!wgslType) return resolvedJsType;
+	const resolvedWgslType = wgslType.replace(/\s/g, "");
+	if (resolvedWgslType !== resolvedJsType) throw new Error(`Type mismatch between TGPU shell and WGSL code string: ${name}, JS type "${resolvedJsType}", WGSL type "${resolvedWgslType}".`);
+	return wgslType;
+}
+
+//#endregion
+export { createFnCore };

package/core/function/fnTypes.d.ts

@@ -0,0 +1,34 @@
+import { BuiltinClipDistances } from "../../builtin.js";
+import { AnyAttribute } from "../../data/attributes.js";
+import { Bool, Decorated, F16, F32, I32, U32, Vec2f, Vec2h, Vec2i, Vec2u, Vec3f, Vec3h, Vec3i, Vec3u, Vec4f, Vec4h, Vec4i, Vec4u, Void } from "../../data/wgslTypes.js";
+import { Infer } from "../../shared/repr.js";
+import "tinyest";
+
+//#region src/core/function/fnTypes.d.ts
+type AnyFn = (...args: never[]) => unknown;
+type InferArgs<T extends unknown[]> = { [Idx in keyof T]: Infer<T[Idx]> };
+type InheritTupleValues<T, From> = { [K in keyof T]: K extends keyof From ? From[K] : never };
+/**
+ * Returns a type that has arg and return types of `T`, but argument
+ * names of `From`
+ *
+ * Wrapped in an object type with `result` prop just so that it's easier
+ * to remove InheritArgNames<...> from Intellisense with Prettify<T>['result']
+ */
+type InheritArgNames<T extends AnyFn, From extends AnyFn> = {
+  result: (...args: Parameters<((...args: InheritTupleValues<Parameters<From>, Parameters<T>>) => ReturnType<T>) & T>) => ReturnType<T>;
+};
+type InferImplSchema<ImplSchema extends AnyFn> = (...args: InferArgs<Parameters<ImplSchema>>) => Infer<ReturnType<ImplSchema>>;
+type Implementation<ImplSchema extends AnyFn = AnyFn> = string | InferImplSchema<ImplSchema>;
+type BaseIOData = Bool | F32 | F16 | I32 | U32 | Vec2f | Vec3f | Vec4f | Vec2h | Vec3h | Vec4h | Vec2i | Vec3i | Vec4i | Vec2u | Vec3u | Vec4u;
+type IOData = BaseIOData | Decorated<BaseIOData, AnyAttribute[]> | BuiltinClipDistances;
+type IORecord<TElementType extends IOData = IOData> = Record<string, TElementType>;
+/**
+ * Used for I/O definitions of entry functions.
+ */
+type IOLayout<TElementType extends IOData = IOData> = TElementType | IORecord<TElementType> | Void;
+type InferIO<T> = T extends {
+  type: string;
+} ? Infer<T> : T extends Record<string, unknown> ? { [K in keyof T]: Infer<T[K]> } : T;
+//#endregion
+export { AnyFn, BaseIOData, IOLayout, IORecord, Implementation, InferArgs, InferIO, InferImplSchema, InheritArgNames };

package/core/function/ioSchema.d.ts

@@ -0,0 +1,10 @@
+import { Decorate, HasCustomLocation, IsBuiltin } from "../../data/attributes.js";
+import { BaseData, Location, WgslStruct } from "../../data/wgslTypes.js";
+
+//#region src/core/function/ioSchema.d.ts
+type WithLocations<T extends Record<string, BaseData>> = { [Key in keyof T]: IsBuiltin<T[Key]> extends true ? T[Key] : HasCustomLocation<T[Key]> extends true ? T[Key] : Decorate<T[Key], Location> };
+type IOLayoutToSchema<T> = T extends BaseData ? HasCustomLocation<T> extends true ? T : Decorate<T, Location<0>> : T extends Record<string, BaseData> ? WgslStruct<WithLocations<T>> : T extends {
+  type: 'void';
+} ? void : never;
+//#endregion
+export { IOLayoutToSchema };

package/core/function/ioSchema.js

@@ -0,0 +1,30 @@
+import { isVoid } from "../../data/wgslTypes.js";
+import { getCustomLocation, isData } from "../../data/dataTypes.js";
+import { isBuiltin, location } from "../../data/attributes.js";
+import { INTERNAL_createStruct } from "../../data/struct.js";
+
+//#region src/core/function/ioSchema.ts
+function withLocations(members, locations = {}) {
+	let nextLocation = 0;
+	const usedCustomLocations = /* @__PURE__ */ new Set();
+	return Object.fromEntries(Object.entries(members ?? {}).map(([key, member]) => {
+		const customLocation = getCustomLocation(member);
+		if (customLocation !== void 0) {
+			if (usedCustomLocations.has(customLocation)) throw new Error("Duplicate custom location attributes found");
+			usedCustomLocations.add(customLocation);
+		}
+		return [key, member];
+	}).map(([key, member]) => {
+		if (isBuiltin(member)) return [key, member];
+		if (getCustomLocation(member) !== void 0) return [key, member];
+		if (locations[key]) return [key, location(locations[key], member)];
+		while (usedCustomLocations.has(nextLocation)) nextLocation++;
+		return [key, location(nextLocation++, member)];
+	}));
+}
+function createIoSchema(layout, locations = {}) {
+	return isData(layout) ? isVoid(layout) ? layout : isBuiltin(layout) ? layout : getCustomLocation(layout) !== void 0 ? layout : location(0, layout) : INTERNAL_createStruct(withLocations(layout, locations), false);
+}
+
+//#endregion
+export { createIoSchema };

package/core/function/shelllessImpl.d.ts

@@ -0,0 +1,28 @@
+import { $getNameForward } from "../../shared/symbols.js";
+import { SelfResolvable } from "../../types.js";
+import { BaseData } from "../../data/wgslTypes.js";
+
+//#region src/core/function/shelllessImpl.d.ts
+/**
+ * Shell-less functions are possible because we can infer the signature based solely on the context
+ * around the function.
+ *
+ * ## Arguments
+ * The snippets of the function's arguments are used to infer the types of the function's arguments.
+ * We only care that the arguments are of a concrete type (we concretize them if they're not). We
+ * cache these signatures based on the argument types, so that we can reuse them across calls.
+ *
+ * ## Return type
+ * In shelled functions, the return type is known when generating the body, but in the case of shell-less functions,
+ * we gather candidates for return types when visiting return statement nodes, and try to unify them into one type
+ * before generating the signature.
+ *
+ * TODO: This behavior can be refined by considering the "expected type" of the function call expression.
+ */
+interface ShelllessImpl extends SelfResolvable {
+  readonly resourceType: 'shellless-impl';
+  readonly argTypes: BaseData[];
+  readonly [$getNameForward]: unknown;
+}
+//#endregion
+export { ShelllessImpl };

package/core/function/shelllessImpl.js

@@ -0,0 +1,23 @@
+import { $getNameForward, $internal, $resolve } from "../../shared/symbols.js";
+import { getName } from "../../shared/meta.js";
+import { createFnCore } from "./fnCore.js";
+
+//#region src/core/function/shelllessImpl.ts
+function createShelllessImpl(argTypes, implementation) {
+	const core = createFnCore(implementation, "");
+	return {
+		[$internal]: true,
+		[$getNameForward]: core,
+		resourceType: "shellless-impl",
+		argTypes,
+		[$resolve](ctx) {
+			return core.resolve(ctx, argTypes, void 0);
+		},
+		toString() {
+			return `fn*:${getName(core) ?? "<unnamed>"}(${argTypes.map((t) => t.toString()).join(", ")})`;
+		}
+	};
+}
+
+//#endregion
+export { createShelllessImpl };

package/core/function/templateUtils.js

@@ -0,0 +1,13 @@
+//#region src/core/function/templateUtils.ts
+function stripTemplate(arg, ...values) {
+	return isTemplateStringsArray(arg) ? templateLiteralIdentity(arg, ...values) : arg;
+}
+function isTemplateStringsArray(value) {
+	return Array.isArray(value) && "raw" in value && Array.isArray(value.raw) && value.raw.every((item) => typeof item === "string");
+}
+function templateLiteralIdentity(strings, ...values) {
+	return strings.slice(1).reduce((acc, elem, index) => `${acc}${values[index]}${elem}`, strings[0]);
+}
+
+//#endregion
+export { stripTemplate };

package/core/function/tgpuComputeFn.d.ts

@@ -0,0 +1,49 @@
+import { TgpuNamable } from "../../shared/meta.js";
+import { $internal } from "../../shared/symbols.js";
+import { AnyComputeBuiltin } from "../../builtin.js";
+import { IORecord, InferIO } from "./fnTypes.js";
+import { IOLayoutToSchema } from "./ioSchema.js";
+import { Void } from "../../data/wgslTypes.js";
+
+//#region src/core/function/tgpuComputeFn.d.ts
+/**
+ * Describes a compute entry function signature (its arguments, return type and workgroup size)
+ */
+type TgpuComputeFnShellHeader<ComputeIn extends IORecord<AnyComputeBuiltin>> = {
+  readonly argTypes: [IOLayoutToSchema<ComputeIn>] | [];
+  readonly returnType: Void;
+  readonly workgroupSize: [number, number, number];
+  readonly entryPoint: 'compute';
+};
+/**
+ * Describes a compute entry function signature (its arguments, return type and workgroup size).
+ * Allows creating tgpu compute functions by calling this shell
+ * and passing the implementation (as WGSL string or JS function) as the argument.
+ */
+type TgpuComputeFnShell<ComputeIn extends IORecord<AnyComputeBuiltin>> = TgpuComputeFnShellHeader<ComputeIn> &
+/**
+ * Creates a type-safe implementation of this signature
+ */
+((implementation: (input: InferIO<ComputeIn>) => undefined) => TgpuComputeFn<ComputeIn>) &
+/**
+ * @param implementation
+ *   Raw WGSL function implementation with header and body
+ *   without `fn` keyword and function name
+ *   e.g. `"(x: f32) -> f32 { return x; }"`;
+ */
+((implementation: string) => TgpuComputeFn<ComputeIn>) & ((strings: TemplateStringsArray, ...values: unknown[]) => TgpuComputeFn<ComputeIn>);
+interface TgpuComputeFn<ComputeIn extends IORecord<AnyComputeBuiltin> = any> extends TgpuNamable {
+  readonly [$internal]: true;
+  readonly shell: TgpuComputeFnShellHeader<ComputeIn>;
+  $uses(dependencyMap: Record<string, unknown>): this;
+}
+declare function computeFn(options: {
+  workgroupSize: number[];
+}): TgpuComputeFnShell<{}>;
+declare function computeFn<ComputeIn extends IORecord<AnyComputeBuiltin>>(options: {
+  in: ComputeIn;
+  workgroupSize: number[];
+}): TgpuComputeFnShell<ComputeIn>;
+declare function isTgpuComputeFn<ComputeIn extends IORecord<AnyComputeBuiltin>>(value: unknown): value is TgpuComputeFn<ComputeIn>;
+//#endregion
+export { TgpuComputeFn, TgpuComputeFnShell, computeFn, isTgpuComputeFn };

package/core/function/tgpuComputeFn.js

@@ -0,0 +1,62 @@
+import { $getNameForward, $internal, $resolve } from "../../shared/symbols.js";
+import { getName, isNamable, setName } from "../../shared/meta.js";
+import { Void } from "../../data/wgslTypes.js";
+import { createIoSchema } from "./ioSchema.js";
+import { createFnCore } from "./fnCore.js";
+import { stripTemplate } from "./templateUtils.js";
+import { shaderStageSlot } from "../slot/internalSlots.js";
+
+//#region src/core/function/tgpuComputeFn.ts
+/**
+* Creates a shell of a typed entry function for the compute shader stage. Any function
+* that implements this shell can perform general-purpose computation.
+*
+* @param options.in
+*   Record with builtins used by the compute shader.
+* @param options.workgroupSize
+*   Size of blocks that the thread grid will be divided into (up to 3 dimensions).
+*/
+function computeFn(options) {
+	const shell = {
+		argTypes: options.in && Object.keys(options.in).length !== 0 ? [createIoSchema(options.in)] : [],
+		returnType: Void,
+		workgroupSize: [
+			options.workgroupSize[0] ?? 1,
+			options.workgroupSize[1] ?? 1,
+			options.workgroupSize[2] ?? 1
+		],
+		entryPoint: "compute"
+	};
+	const call = (arg, ...values) => createComputeFn(shell, options.workgroupSize, stripTemplate(arg, ...values));
+	return Object.assign(call, shell);
+}
+function isTgpuComputeFn(value) {
+	return value?.shell?.entryPoint === "compute";
+}
+function createComputeFn(shell, workgroupSize, implementation) {
+	const core = createFnCore(implementation, `@compute @workgroup_size(${workgroupSize.join(", ")}) `);
+	const inputType = shell.argTypes[0];
+	return {
+		shell,
+		$uses(newExternals) {
+			core.applyExternals(newExternals);
+			return this;
+		},
+		[$internal]: true,
+		[$getNameForward]: core,
+		$name(newLabel) {
+			setName(this, newLabel);
+			if (isNamable(inputType)) inputType.$name(`${newLabel}_Input`);
+			return this;
+		},
+		[$resolve](ctx) {
+			return ctx.withSlots([[shaderStageSlot, "compute"]], () => core.resolve(ctx, shell.argTypes, shell.returnType));
+		},
+		toString() {
+			return `computeFn:${getName(core) ?? "<unnamed>"}`;
+		}
+	};
+}
+
+//#endregion
+export { computeFn, isTgpuComputeFn };

package/core/function/tgpuFn.d.ts

@@ -0,0 +1,52 @@
+import { TgpuNamable } from "../../shared/meta.js";
+import { $internal, $providing } from "../../shared/symbols.js";
+import { Prettify } from "../../shared/utilityTypes.js";
+import { AnyFn, Implementation, InferArgs, InferImplSchema, InheritArgNames } from "./fnTypes.js";
+import { Providing } from "../slot/slotTypes.js";
+import { Withable } from "../root/rootTypes.js";
+import { DualFn } from "../../types.js";
+import { BaseData, Void } from "../../data/wgslTypes.js";
+import { Infer } from "../../shared/repr.js";
+
+//#region src/core/function/tgpuFn.d.ts
+/**
+ * Describes a function signature (its arguments and return type)
+ */
+type TgpuFnShellHeader<Args extends BaseData[], Return extends BaseData> = {
+  readonly [$internal]: true;
+  readonly argTypes: Args;
+  readonly returnType: Return;
+};
+/**
+ * Describes a function signature (its arguments and return type).
+ * Allows creating tgpu functions by calling this shell
+ * and passing the implementation (as WGSL string or JS function) as the argument.
+ */
+type TgpuFnShell<Args extends BaseData[], Return extends BaseData> = TgpuFnShellHeader<Args, Return> & (<T extends (...args: InferArgs<Args>) => Infer<Return>>(implementation: T) => TgpuFn<Prettify<InheritArgNames<(...args: Args) => Return, T>>['result']>) & ((implementation: string) => TgpuFn<(...args: Args) => Return>) & ((strings: TemplateStringsArray, ...values: unknown[]) => TgpuFn<(...args: Args) => Return>);
+interface TgpuFnBase<ImplSchema extends AnyFn> extends TgpuNamable, Withable<TgpuFn<ImplSchema>> {
+  [$internal]: {
+    implementation: Implementation<ImplSchema>;
+  };
+  readonly resourceType: 'function';
+  readonly shell: TgpuFnShellHeader<Parameters<ImplSchema>, Extract<ReturnType<ImplSchema>, BaseData>>;
+  readonly [$providing]?: Providing | undefined;
+  $uses(dependencyMap: Record<string, unknown>): this;
+}
+type TgpuFn<ImplSchema extends AnyFn = (...args: any[]) => any> = DualFn<InferImplSchema<ImplSchema>> & TgpuFnBase<ImplSchema>;
+/**
+ * A function wrapper that allows providing slot and accessor overrides for shellless functions
+ */
+interface TgpuGenericFn<T extends AnyFn> extends TgpuNamable, Withable<TgpuGenericFn<T>> {
+  readonly [$internal]: {
+    inner: T;
+  };
+  readonly [$providing]?: Providing | undefined;
+  readonly resourceType: 'generic-function';
+  (...args: Parameters<T>): ReturnType<T>;
+}
+declare function fn<Args extends BaseData[] | []>(argTypes: Args, returnType?: undefined): TgpuFnShell<Args, Void>;
+declare function fn<Args extends BaseData[] | [], Return extends BaseData>(argTypes: Args, returnType: Return): TgpuFnShell<Args, Return>;
+declare function fn<T extends AnyFn>(inner: T): TgpuGenericFn<T>;
+declare function isTgpuFn<Args extends BaseData[] | [], Return extends BaseData>(value: unknown): value is TgpuFn<(...args: Args) => Return>;
+//#endregion
+export { TgpuFn, TgpuFnShell, TgpuGenericFn, fn, isTgpuFn };