typegpu 0.11.9 → 0.12.1

package/core/function/fnCore.js

@@ -1,102 +1,157 @@
-import { $getNameForward } from "../../shared/symbols.js";
-import { Void, isWgslData, isWgslStruct } from "../../data/wgslTypes.js";
-import { getFunctionMetadata, getName } from "../../shared/meta.js";
+import { getAttributesString } from "../../data/attributes.js";
 import { undecorate } from "../../data/dataTypes.js";
 import { snip } from "../../data/snippet.js";
-import { getAttributesString } from "../../data/attributes.js";
+import { isWgslData, isWgslStruct, Void } from "../../data/wgslTypes.js";
 import { validateIdentifier } from "../../nameUtils.js";
-import { mergeFunctionExternals, replaceExternalsInWgsl } from "../resolve/externals.js";
+import { getFunctionMetadata, getName } from "../../shared/meta.js";
+import { $getNameForward } from "../../shared/symbols.js";
+import { replaceExternalsInWgsl, mergeFunctionExternals, } from "../resolve/externals.js";
+import { ResolvableString } from "../resolve/resolvableString.js";
 import { extractArgs } from "./extractArgs.js";
-
-//#region src/core/function/fnCore.ts
-function createFnCore(implementation, functionType, workgroupSize) {
-	/**
-	* 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 externals = {};
-	return {
-		[$getNameForward]: typeof implementation === "function" ? implementation : void 0,
-		setExternals(key, newExternal) {
-			if (key === "userProvided" && "userProvided" in externals) throw new Error("Cannot call '$uses' multiple times. If you wish to override dependencies, use slots or accessors instead.");
-			externals[key] = newExternal;
-			if (externals.userProvided && externals.pluginProvided) throw new Error("Cannot call '$uses' on functions whose metadata was provided by unplugin-typegpu.");
-		},
-		resolve(ctx, argTypes, returnType, entryInput) {
-			let attributes = "";
-			if (functionType === "compute") attributes = `@compute @workgroup_size(${workgroupSize?.join(", ")}) `;
-			else if (functionType === "vertex") attributes = `@vertex `;
-			else if (functionType === "fragment") attributes = `@fragment `;
-			const id = ctx.makeUniqueIdentifier(getName(this), "global");
-			if (typeof implementation === "string") {
-				if (!returnType) throw new Error("Explicit return type is required for string implementation");
-				if (entryInput) {
-					for (const arg of entryInput.positionalArgs) {
-						const result = /* @__PURE__ */ validateIdentifier(arg.schemaKey);
-						if (!result.success) throw new Error(`Invalid argument name "${arg.schemaKey}"${result.error ? `: ${result.error}` : ""}`);
-						if (ctx.isIdentifierBanned(arg.schemaKey)) throw new Error(`Invalid argument name "${arg.schemaKey}", the identifier is a reserved keyword.`);
-					}
-					this.setExternals("args", { in: Object.fromEntries(entryInput.positionalArgs.map((a) => [a.schemaKey, a.schemaKey])) });
-				}
-				const replacedImpl = replaceExternalsInWgsl(ctx, mergeFunctionExternals(externals), implementation);
-				let header = "";
-				let body = "";
-				if (functionType !== "normal" && entryInput) {
-					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 = a.schemaKey;
-						if (isArgUsedInBody(argName, replacedImpl)) parts.push(`${getAttributesString(a.type)}${argName}: ${ctx.resolve(a.type).value}`);
-					}
-					const input = `(${parts.join(", ")})`;
-					const attributes$1 = isWgslData(returnType) ? getAttributesString(returnType) : "";
-					header = `${input}${returnType !== Void ? isWgslStruct(returnType) ? ` -> ${ctx.resolve(returnType).value} ` : ` -> ${attributes$1 !== "" ? attributes$1 : "@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(`${attributes}fn ${id}${header}${body}`);
-				return snip(id, returnType, "runtime");
-			}
-			const pluginData = getFunctionMetadata(implementation);
-			const pluginExternals = pluginData?.externals();
-			if (pluginExternals) this.setExternals("pluginProvided", pluginExternals);
-			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 maybeSecondArg = ast.params[1];
-			if (maybeSecondArg && maybeSecondArg.type === "i" && functionType !== "normal") this.setExternals("out", { [maybeSecondArg.name]: undecorate(returnType) });
-			const { code, returnType: actualReturnType } = ctx.resolveFunction({
-				functionType,
-				name: id,
-				workgroupSize,
-				argTypes,
-				entryInput,
-				params: ast.params,
-				returnType,
-				body: ast.body,
-				externalMap: mergeFunctionExternals(externals)
-			});
-			ctx.addDeclaration(code);
-			return snip(id, actualReturnType, "runtime");
-		}
-	};
+export function createFnCore(implementation, functionType, workgroupSize) {
+    /**
+     * 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 externals = {};
+    const core = {
+        // Making the implementation the holder of the name, as long as it's
+        // a function (and not a string implementation)
+        [$getNameForward]: typeof implementation === 'function' ? implementation : undefined,
+        setExternals(key, newExternal) {
+            if (key === 'userProvided' && 'userProvided' in externals) {
+                throw new Error("Cannot call '$uses' multiple times. If you wish to override dependencies, use slots or accessors instead.");
+            }
+            externals[key] = newExternal;
+            if (externals.userProvided && externals.pluginProvided) {
+                throw new Error("Cannot call '$uses' on functions whose metadata was provided by unplugin-typegpu.");
+            }
+        },
+        resolve(ctx, argTypes, returnType, entryInput) {
+            let attributes = '';
+            if (functionType === 'compute') {
+                attributes = `@compute @workgroup_size(${workgroupSize?.join(', ')}) `;
+            }
+            else if (functionType === 'vertex') {
+                attributes = `@vertex `;
+            }
+            else if (functionType === 'fragment') {
+                attributes = `@fragment `;
+            }
+            const id = ctx.makeUniqueIdentifier(getName(this), 'global');
+            if (typeof implementation === 'string') {
+                if (!returnType) {
+                    throw new Error('Explicit return type is required for string implementation');
+                }
+                if (entryInput) {
+                    for (const arg of entryInput.positionalArgs) {
+                        const result = validateIdentifier(arg.schemaKey);
+                        if (!result.success) {
+                            throw new Error(`Invalid argument name "${arg.schemaKey}"${result.error ? `: ${result.error}` : ''}`);
+                        }
+                        if (ctx.isIdentifierBanned(arg.schemaKey)) {
+                            throw new Error(`Invalid argument name "${arg.schemaKey}", the identifier is a reserved keyword.`);
+                        }
+                    }
+                    this.setExternals('args', {
+                        in: Object.fromEntries(entryInput.positionalArgs.map((a) => [
+                            a.schemaKey,
+                            new ResolvableString(a.schemaKey),
+                        ])),
+                    });
+                }
+                const replacedImpl = replaceExternalsInWgsl(ctx, mergeFunctionExternals(externals), implementation);
+                let header = '';
+                let body = '';
+                if (functionType !== 'normal' && entryInput) {
+                    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 = a.schemaKey;
+                        if (isArgUsedInBody(argName, replacedImpl)) {
+                            parts.push(`${getAttributesString(a.type)}${argName}: ${ctx.resolve(a.type).value}`);
+                        }
+                    }
+                    const input = `(${parts.join(', ')})`;
+                    const attributes = isWgslData(returnType) ? getAttributesString(returnType) : '';
+                    const output = returnType !== Void
+                        ? isWgslStruct(returnType)
+                            ? ` -> ${ctx.resolve(returnType).value} `
+                            : ` -> ${attributes !== '' ? attributes : '@location(0)'} ${ctx.resolve(returnType).value} `
+                        : ' ';
+                    header = `${input}${output}`;
+                    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.`);
+                    }
+                    const input = providedArgs.args
+                        .map((argInfo, i) => `${argInfo.identifier}: ${checkAndReturnType(ctx, `parameter ${argInfo.identifier}`, argInfo.type, argTypes[i])}`)
+                        .join(', ');
+                    const output = returnType === Void
+                        ? ' '
+                        : ` -> ${checkAndReturnType(ctx, 'return type', providedArgs.ret?.type, returnType)} `;
+                    header = `(${input})${output}`;
+                    body = replacedImpl.slice(providedArgs.range.end);
+                }
+                ctx.addDeclaration(`${attributes}fn ${id}${header}${body}`, id);
+                return snip(id, returnType, /* origin */ 'runtime');
+            }
+            // get data generated by the plugin
+            const pluginData = getFunctionMetadata(implementation);
+            const pluginExternals = pluginData?.externals();
+            if (pluginExternals) {
+                this.setExternals('pluginProvided', pluginExternals);
+            }
+            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`)");
+            }
+            // If an entrypoint implementation has a second argument, it represents the output schema.
+            // We look at the identifier chosen by the user and add it to externals.
+            const maybeSecondArg = ast.params[1];
+            if (maybeSecondArg && maybeSecondArg.type === 'i' && functionType !== 'normal') {
+                this.setExternals('out', {
+                    // oxlint-disable-next-line typescript/no-non-null-assertion -- entry functions cannot be shellless
+                    [maybeSecondArg.name]: undecorate(returnType),
+                });
+            }
+            // generate wgsl string
+            const { code, returnType: actualReturnType } = ctx.resolveFunction({
+                functionType,
+                name: id,
+                workgroupSize,
+                argTypes,
+                entryInput,
+                params: ast.params,
+                returnType,
+                body: ast.body,
+                externalMap: mergeFunctionExternals(externals),
+            });
+            ctx.addDeclaration(code, id);
+            return snip(id, actualReturnType, /* origin */ 'runtime');
+        },
+    };
+    return core;
 }
 function isArgUsedInBody(argName, body) {
-	return (/* @__PURE__ */ new RegExp(`\\b${argName}\\b`)).test(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;
+    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

@@ -1,13 +1,14 @@
-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";
-import "tinyest";
-
-//#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 };
+import type { BuiltinClipDistances } from '../../builtin.ts';
+import type { AnyAttribute } from '../../data/attributes.ts';
+import type { BaseData, Bool, Decorated, F16, F32, I32, U32, Vec2f, Vec2h, Vec2i, Vec2u, Vec3f, Vec3h, Vec3i, Vec3u, Vec4f, Vec4h, Vec4i, Vec4u, Void } from '../../data/wgslTypes.ts';
+import type { InferGPU } from '../../shared/repr.ts';
+export type AnyFn = (...args: never[]) => unknown;
+export 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`
@@ -15,28 +16,29 @@ type InheritTupleValues<T, From> = { [K in keyof T]: K extends keyof From ? 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>;
+export 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>;
+export type InferImplSchema<ImplSchema extends AnyFn> = (...args: InferArgs<Parameters<ImplSchema>>) => InferGPU<ReturnType<ImplSchema>>;
+export type Implementation<ImplSchema extends AnyFn = AnyFn> = string | InferImplSchema<ImplSchema>;
+export type BaseIOData = Bool | F32 | F16 | I32 | U32 | Vec2f | Vec3f | Vec4f | Vec2h | Vec3h | Vec4h | Vec2i | Vec3i | Vec4i | Vec2u | Vec3u | Vec4u;
+export type IOData = BaseIOData | Decorated<BaseIOData, AnyAttribute[]> | BuiltinClipDistances;
+export 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;
+export type IOLayout<TElementType extends IOData = IOData> = TElementType | IORecord<TElementType> | Void;
+export type InferIO<T> = T extends {
+    type: string;
+} ? InferGPU<T> : T extends Record<string, unknown> ? {
+    [K in keyof T]: InferGPU<T[K]>;
+} : T;
+export interface PositionalArgInfo {
+    schemaKey: string;
+    type: BaseData;
 }
-interface SeparatedEntryArgs {
-  dataSchema: BaseData | undefined;
-  positionalArgs: PositionalArgInfo[];
+export interface SeparatedEntryArgs {
+    dataSchema: BaseData | undefined;
+    positionalArgs: PositionalArgInfo[];
 }
-//#endregion
-export { AnyFn, BaseIOData, IOLayout, IORecord, Implementation, InferArgs, InferIO, InferImplSchema, InheritArgNames, SeparatedEntryArgs };
+export {};

package/core/function/fnTypes.js

@@ -0,0 +1 @@
+export {};

package/core/function/ioSchema.d.ts

@@ -1,11 +1,13 @@
-import { Decorate, HasCustomLocation, IsBuiltin } from "../../data/attributes.js";
-import "./fnTypes.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';
+import { type Decorate, type HasCustomLocation, type IsBuiltin } from '../../data/attributes.ts';
+import { type BaseData, type Location, type WgslStruct } from '../../data/wgslTypes.ts';
+import type { SeparatedEntryArgs } from './fnTypes.ts';
+export 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>;
+};
+export 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 };
+export declare function withLocations<T extends BaseData>(members: Record<string, T> | undefined, locations?: Record<string, number>): Record<string, BaseData>;
+export declare function separateBuiltins(schema: Record<string, BaseData>, locations?: Record<string, number>): SeparatedEntryArgs;
+export declare function separateAllAsPositional(schema: Record<string, BaseData>): SeparatedEntryArgs;
+export declare function createIoSchema<T extends BaseData | Record<string, BaseData>>(layout: T, locations?: Record<string, number>): IOLayoutToSchema<T>;

package/core/function/ioSchema.js

@@ -1,53 +1,71 @@
-import { isVoid } from "../../data/wgslTypes.js";
+import { location, } from "../../data/attributes.js";
+import { isBuiltin } from "../../data/attributes.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)];
-	}));
+import { isVoid } from "../../data/wgslTypes.js";
+export function withLocations(members, locations = {}) {
+    let nextLocation = 0;
+    const usedCustomLocations = new Set();
+    return Object.fromEntries(Object.entries(members ?? {})
+        .map(([key, member]) => {
+        const customLocation = getCustomLocation(member);
+        if (customLocation !== undefined) {
+            if (usedCustomLocations.has(customLocation)) {
+                throw new Error('Duplicate custom location attributes found');
+            }
+            usedCustomLocations.add(customLocation);
+        }
+        return [key, member];
+    })
+        .map(([key, member]) => {
+        if (isBuiltin(member)) {
+            // skipping builtins
+            return [key, member];
+        }
+        if (getCustomLocation(member) !== undefined) {
+            // this member is already marked
+            return [key, member];
+        }
+        if (locations[key]) {
+            // location has been determined by a previous procedure
+            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
-	};
+export 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;
+        }
+    }
+    const dataSchema = Object.keys(dataFields).length > 0
+        ? INTERNAL_createStruct(withLocations(dataFields, locations), /* isAbstruct */ false)
+        : undefined;
+    return { dataSchema, positionalArgs };
 }
-function separateAllAsPositional(schema) {
-	const withLocs = withLocations(schema);
-	return {
-		dataSchema: void 0,
-		positionalArgs: Object.entries(withLocs).map(([key, type]) => ({
-			schemaKey: key,
-			type
-		}))
-	};
+export function separateAllAsPositional(schema) {
+    const withLocs = withLocations(schema);
+    const positionalArgs = Object.entries(withLocs).map(([key, type]) => ({ schemaKey: key, type }));
+    return { dataSchema: undefined, positionalArgs };
 }
-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);
+export function createIoSchema(layout, locations = {}) {
+    return (isData(layout)
+        ? isVoid(layout)
+            ? layout
+            : isBuiltin(layout)
+                ? layout
+                : getCustomLocation(layout) !== undefined
+                    ? layout
+                    : location(0, layout)
+        : INTERNAL_createStruct(withLocations(layout, locations), 
+        /* isAbstruct */ false));
 }
-
-//#endregion
-export { createIoSchema, separateAllAsPositional, separateBuiltins };

package/core/function/shelllessImpl.d.ts

@@ -1,9 +1,6 @@
-import { $getNameForward } from "../../shared/symbols.js";
-import { SelfResolvable } from "../../types.js";
-import { BaseData } from "../../data/wgslTypes.js";
-
-//#region src/core/function/shelllessImpl.d.ts
-
+import type { BaseData } from '../../data/wgslTypes.ts';
+import { $getNameForward } from '../../shared/symbols.ts';
+import type { SelfResolvable } from '../../types.ts';
 /**
  * Shell-less functions are possible because we can infer the signature based solely on the context
  * around the function.
@@ -20,10 +17,10 @@ import { BaseData } from "../../data/wgslTypes.js";
  *
  * 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;
+export interface ShelllessImpl extends SelfResolvable {
+    readonly resourceType: 'shellless-impl';
+    readonly argTypes: BaseData[];
+    readonly [$getNameForward]: unknown;
 }
-//#endregion
-export { ShelllessImpl };
+export declare function isShelllessImpl(value: unknown): value is ShelllessImpl;
+export declare function createShelllessImpl(argTypes: BaseData[], implementation: (...args: never[]) => unknown): ShelllessImpl;

package/core/function/shelllessImpl.js

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

package/core/function/templateUtils.d.ts

@@ -0,0 +1,2 @@
+import type { Implementation } from './fnTypes.ts';
+export declare function stripTemplate(arg: Implementation | TemplateStringsArray, ...values: unknown[]): Implementation;

package/core/function/templateUtils.js

@@ -1,13 +1,14 @@
-//#region src/core/function/templateUtils.ts
-function stripTemplate(arg, ...values) {
-	return isTemplateStringsArray(arg) ? templateLiteralIdentity(arg, ...values) : arg;
+export 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");
+    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]);
+    return strings
+        .slice(1)
+        .reduce((acc, elem, index) => `${acc}${values[index]}${elem}`, strings[0]);
 }
-
-//#endregion
-export { stripTemplate };