typegpu 0.10.1 → 0.11.0-rc.1

package/core/function/comptime.js

@@ -0,0 +1,49 @@
+import { $getNameForward, $gpuCallable, $internal } from "../../shared/symbols.js";
+import { setName } from "../../shared/meta.js";
+import { WgslTypeError } from "../../errors.js";
+import { isKnownAtComptime } from "../../types.js";
+import { coerceToSnippet } from "../../tgsl/generationHelpers.js";
+//#region src/core/function/comptime.ts
+/**
+* Creates a version of `func` that can called safely in a TypeGPU function to
+* precompute and inject a value into the final shader code.
+*
+* Note how the function passed into `comptime` doesn't have to be marked with
+* 'use gpu'. That's because the function doesn't execute on the GPU, it gets
+* executed before the shader code gets sent to the GPU.
+*
+* @example
+* ```ts
+* const color = tgpu.comptime((int: number) => {
+*   const r = (int >> 16) & 0xff;
+*   const g = (int >> 8) & 0xff;
+*   const b = int & 0xff;
+*   return d.vec3f(r / 255, g / 255, b / 255);
+* });
+*
+* const material = (diffuse: d.v3f): d.v3f => {
+*   'use gpu';
+*   const albedo = color(0xff00ff);
+*   return albedo.mul(diffuse);
+* };
+* ```
+*/
+function comptime(func) {
+	const impl = ((...args) => {
+		return func(...args);
+	});
+	impl.toString = () => "comptime";
+	impl[$getNameForward] = func;
+	impl[$gpuCallable] = { call(_ctx, args) {
+		if (!args.every((s) => isKnownAtComptime(s))) throw new WgslTypeError(`Called comptime function with runtime-known values: ${args.filter((s) => !isKnownAtComptime(s)).map((s) => `'${s.value}'`).join(", ")}`);
+		return coerceToSnippet(func(...args.map((s) => s.value)));
+	} };
+	impl.$name = (label) => {
+		setName(func, label);
+		return impl;
+	};
+	Object.defineProperty(impl, $internal, { value: { isComptime: true } });
+	return impl;
+}
+//#endregion
+export { comptime };

package/core/function/createCallableSchema.js

@@ -0,0 +1,40 @@
+import { $gpuCallable } from "../../shared/symbols.js";
+import { setName } from "../../shared/meta.js";
+import { isPtr } from "../../data/wgslTypes.js";
+import { snip } from "../../data/snippet.js";
+import { NormalState, isKnownAtComptime } from "../../types.js";
+import { tryConvertSnippet } from "../../tgsl/conversion.js";
+//#region src/core/function/createCallableSchema.ts
+function callableSchema(options) {
+	const impl = ((...args) => {
+		return options.normalImpl(...args);
+	});
+	setName(impl, options.name);
+	impl.toString = () => options.name;
+	impl[$gpuCallable] = {
+		get strictSignature() {},
+		call(ctx, args) {
+			const argTypes = options.argTypes(...args.map((s) => {
+				if (isPtr(s.dataType) && s.dataType.implicit) return s.dataType.inner;
+				return s.dataType;
+			}));
+			const converted = args.map((s, idx) => {
+				const argType = argTypes[idx];
+				if (!argType) throw new Error("Function called with invalid arguments");
+				return tryConvertSnippet(ctx, s, argType, false);
+			});
+			if (converted.every((s) => isKnownAtComptime(s))) {
+				ctx.pushMode(new NormalState());
+				try {
+					return snip(options.normalImpl(...converted.map((s) => s.value)), options.schema(), "constant");
+				} finally {
+					ctx.popMode("normal");
+				}
+			}
+			return options.codegenImpl(ctx, converted);
+		}
+	};
+	return impl;
+}
+//#endregion
+export { callableSchema };

package/core/function/dualImpl.js

@@ -0,0 +1,52 @@
+import { $gpuCallable } from "../../shared/symbols.js";
+import { setName } from "../../shared/meta.js";
+import { isPtr } from "../../data/wgslTypes.js";
+import { snip } from "../../data/snippet.js";
+import { NormalState, isKnownAtComptime } from "../../types.js";
+import { tryConvertSnippet } from "../../tgsl/conversion.js";
+import { concretize } from "../../tgsl/generationHelpers.js";
+//#region src/core/function/dualImpl.ts
+var MissingCpuImplError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = this.constructor.name;
+	}
+};
+function dualImpl(options) {
+	const impl = ((...args) => {
+		if (typeof options.normalImpl === "string") throw new MissingCpuImplError(options.normalImpl);
+		return options.normalImpl(...args);
+	});
+	setName(impl, options.name);
+	impl.toString = () => options.name ?? "<unknown>";
+	impl[$gpuCallable] = {
+		get strictSignature() {
+			return typeof options.signature !== "function" ? options.signature : void 0;
+		},
+		call(ctx, args) {
+			const { argTypes, returnType } = typeof options.signature === "function" ? options.signature(...args.map((s) => {
+				if (isPtr(s.dataType) && s.dataType.implicit) return s.dataType.inner;
+				return s.dataType;
+			})) : options.signature;
+			const converted = args.map((s, idx) => {
+				const argType = argTypes[idx];
+				if (!argType) throw new Error("Function called with invalid arguments");
+				return tryConvertSnippet(ctx, s, argType, !options.ignoreImplicitCastWarning);
+			});
+			if (!options.noComptime && converted.every((s) => isKnownAtComptime(s)) && typeof options.normalImpl === "function") {
+				ctx.pushMode(new NormalState());
+				try {
+					return snip(options.normalImpl(...converted.map((s) => s.value)), returnType, "constant");
+				} catch (e) {
+					if (!(e instanceof MissingCpuImplError)) throw e;
+				} finally {
+					ctx.popMode("normal");
+				}
+			}
+			return snip(options.codegenImpl(ctx, converted), concretize(returnType), "runtime");
+		}
+	};
+	return impl;
+}
+//#endregion
+export { MissingCpuImplError, dualImpl };

package/core/function/entryInputRouter.js

@@ -0,0 +1,39 @@
+import { $internal } from "../../shared/symbols.js";
+import { isWgslStruct } from "../../data/wgslTypes.js";
+import { undecorate } from "../../data/dataTypes.js";
+import { snip } from "../../data/snippet.js";
+//#region src/core/function/entryInputRouter.ts
+/**
+* Routes `(input) => { input.x }` style property access to the correct WGSL
+* expression: positional args get a direct snippet, struct fields get
+* `structArgName.fieldName`.
+*/
+var EntryInputRouter = class {
+	[$internal] = {};
+	type = "entry-input-router";
+	structArgName;
+	dataSchema;
+	/** Maps schemaKey → { WGSL arg name, type } */
+	positionalArgsMap;
+	constructor(structArgName, dataSchema, positionalArgs) {
+		this.structArgName = structArgName;
+		this.dataSchema = dataSchema;
+		this.positionalArgsMap = new Map(positionalArgs.map((a) => [a.schemaKey, {
+			argName: a.argName,
+			type: a.type
+		}]));
+	}
+	toString() {
+		return "entry-input-router";
+	}
+	accessProp(propName) {
+		const positionalEntry = this.positionalArgsMap.get(propName);
+		if (positionalEntry) return snip(positionalEntry.argName, positionalEntry.type, "argument");
+		if (this.dataSchema && isWgslStruct(this.dataSchema)) {
+			const propType = this.dataSchema.propTypes[propName];
+			if (propType) return snip(`${this.structArgName}.${propName}`, undecorate(propType), "argument");
+		}
+	}
+};
+//#endregion
+export { EntryInputRouter };

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 {
+	str;
+	#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,90 @@
+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, entryInput) {
+			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 validArgNames = entryInput ? Object.fromEntries(entryInput.positionalArgs.map((a) => [a.schemaKey, ctx.makeNameValid(a.schemaKey)])) : void 0;
+				if (validArgNames && Object.keys(validArgNames).length > 0) applyExternals(externalMap, { in: validArgNames });
+				const replacedImpl = replaceExternalsInWgsl(ctx, externalMap, implementation);
+				let header = "";
+				let body = "";
+				if (fnAttribute !== "" && entryInput && validArgNames) {
+					const { dataSchema, positionalArgs } = entryInput;
+					const parts = [];
+					if (dataSchema && isArgUsedInBody("in", replacedImpl)) parts.push(`in: ${ctx.resolve(dataSchema).value}`);
+					for (const a of positionalArgs) {
+						const argName = validArgNames[a.schemaKey] ?? "";
+						if (argName !== "" && isArgUsedInBody(argName, replacedImpl)) parts.push(`${getAttributesString(a.type)}${argName}: ${ctx.resolve(a.type).value}`);
+					}
+					const input = `(${parts.join(", ")})`;
+					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,
+				entryInput,
+				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 isArgUsedInBody(argName, body) {
+	return new RegExp(`\\b${argName}\\b`).test(body);
+}
+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,40 @@
+import { BuiltinClipDistances } from "../../builtin.js";
+import { AnyAttribute } from "../../data/attributes.js";
+import { BaseData, Bool, Decorated, F16, F32, I32, U32, Vec2f, Vec2h, Vec2i, Vec2u, Vec3f, Vec3h, Vec3i, Vec3u, Vec4f, Vec4h, Vec4i, Vec4u, Void } from "../../data/wgslTypes.js";
+import { InferGPU } from "../../shared/repr.js";
+//#region src/core/function/fnTypes.d.ts
+type AnyFn = (...args: never[]) => unknown;
+type InferArgs<T extends unknown[]> = { [Idx in keyof T]: InferGPU<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>>) => InferGPU<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;
+} ? InferGPU<T> : T extends Record<string, unknown> ? { [K in keyof T]: InferGPU<T[K]> } : T;
+interface PositionalArgInfo {
+  schemaKey: string;
+  type: BaseData;
+}
+interface SeparatedEntryArgs {
+  dataSchema: BaseData | undefined;
+  positionalArgs: PositionalArgInfo[];
+}
+//#endregion
+export { AnyFn, BaseIOData, IOLayout, IORecord, Implementation, InferArgs, InferIO, InferImplSchema, InheritArgNames, SeparatedEntryArgs };

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,51 @@
+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 separateBuiltins(schema, locations = {}) {
+	const positionalArgs = [];
+	const dataFields = {};
+	for (const [key, type] of Object.entries(schema)) if (isBuiltin(type)) positionalArgs.push({
+		schemaKey: key,
+		type
+	});
+	else dataFields[key] = type;
+	return {
+		dataSchema: Object.keys(dataFields).length > 0 ? INTERNAL_createStruct(withLocations(dataFields, locations), false) : void 0,
+		positionalArgs
+	};
+}
+function separateAllAsPositional(schema) {
+	const withLocs = withLocations(schema);
+	return {
+		dataSchema: void 0,
+		positionalArgs: Object.entries(withLocs).map(([key, type]) => ({
+			schemaKey: key,
+			type
+		}))
+	};
+}
+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, separateAllAsPositional, separateBuiltins };

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,21 @@
+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,12 @@
+//#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 };