typegpu 0.11.8 → 0.12.0

package/core/function/tgpuComputeFn.d.ts

@@ -1,49 +1,47 @@
-import { TgpuNamable } from "../../shared/meta.js";
-import { $internal } from "../../shared/symbols.js";
-import { AnyComputeBuiltin } from "../../builtin.js";
-import { IORecord, InferIO } from "./fnTypes.js";
-import { Void } from "../../data/wgslTypes.js";
-
-//#region src/core/function/tgpuComputeFn.d.ts
-
+import type { AnyComputeBuiltin } from '../../builtin.ts';
+import { Void } from '../../data/wgslTypes.ts';
+import { type TgpuNamable } from '../../shared/meta.ts';
+import { $internal } from '../../shared/symbols.ts';
+import type { InferIO, IORecord } from './fnTypes.ts';
 /**
  * Describes a compute entry function signature (its arguments, return type and workgroup size)
  */
 type TgpuComputeFnShellHeader<ComputeIn extends IORecord<AnyComputeBuiltin>> = {
-  readonly argTypes: ComputeIn[keyof ComputeIn][];
-  readonly returnType: Void;
-  readonly workgroupSize: number[];
-  readonly entryPoint: 'compute';
+    readonly argTypes: ComputeIn[keyof ComputeIn][];
+    readonly returnType: Void;
+    readonly workgroupSize: 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> &
+export type TgpuComputeFnShell<ComputeIn extends IORecord<AnyComputeBuiltin>> = TgpuComputeFnShellHeader<ComputeIn> & 
 /**
  * Creates a type-safe implementation of this signature
  */
-((implementation: (input: InferIO<ComputeIn>) => undefined) => TgpuComputeFn<ComputeIn>) &
+((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;
+ */ ((implementation: string) => TgpuComputeFn<ComputeIn>) & ((strings: TemplateStringsArray, ...values: unknown[]) => TgpuComputeFn<ComputeIn>);
+export interface TgpuComputeFn<ComputeIn extends IORecord<AnyComputeBuiltin> = any> extends TgpuNamable {
+    readonly [$internal]: true;
+    readonly shell: TgpuComputeFnShellHeader<ComputeIn>;
+    $uses(dependencyMap: Record<string, unknown>): this;
+}
+export interface ComputeFnOptions {
+    workgroupSize: number[];
 }
-declare function computeFn(options: {
-  workgroupSize: number[];
+export declare function computeFn(options: {
+    workgroupSize: number[];
 }): TgpuComputeFnShell<{}>;
-declare function computeFn<ComputeIn extends IORecord<AnyComputeBuiltin>>(options: {
-  in: ComputeIn;
-  workgroupSize: number[];
+export 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 };
+export declare function isTgpuComputeFn<ComputeIn extends IORecord<AnyComputeBuiltin>>(value: unknown): value is TgpuComputeFn<ComputeIn>;
+export {};

package/core/function/tgpuComputeFn.js

@@ -1,57 +1,56 @@
-import { $getNameForward, $internal, $resolve } from "../../shared/symbols.js";
 import { Void } from "../../data/wgslTypes.js";
 import { getName, setName } from "../../shared/meta.js";
-import { separateBuiltins } from "./ioSchema.js";
+import { $getNameForward, $internal, $resolve } from "../../shared/symbols.js";
+import { shaderStageSlot } from "../slot/internalSlots.js";
 import { createFnCore } from "./fnCore.js";
+import { separateBuiltins } from "./ioSchema.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: Object.values(options.in ?? {}),
-		returnType: Void,
-		workgroupSize: options.workgroupSize,
-		entryPoint: "compute"
-	};
-	const entryInput = separateBuiltins(options.in ?? {});
-	const call = (arg, ...values) => createComputeFn(shell, options.workgroupSize, stripTemplate(arg, ...values), entryInput);
-	return Object.assign(call, shell);
+ * 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).
+ */
+export function computeFn(options) {
+    const shell = {
+        argTypes: Object.values(options.in ?? {}),
+        returnType: Void,
+        workgroupSize: options.workgroupSize,
+        entryPoint: 'compute',
+    };
+    const entryInput = separateBuiltins(options.in ?? {});
+    const call = (arg, ...values) => createComputeFn(shell, options.workgroupSize, stripTemplate(arg, ...values), entryInput);
+    return Object.assign(call, shell);
 }
-function isTgpuComputeFn(value) {
-	return value?.shell?.entryPoint === "compute";
+export function isTgpuComputeFn(value) {
+    return value?.shell?.entryPoint === 'compute';
 }
+// --------------
+// Implementation
+// --------------
 function createComputeFn(shell, workgroupSize, implementation, entryInput) {
-	const core = createFnCore(implementation, "compute", workgroupSize);
-	return {
-		shell,
-		$uses(newExternals) {
-			core.applyExternals(newExternals);
-			return this;
-		},
-		[$internal]: true,
-		[$getNameForward]: core,
-		$name(newLabel) {
-			setName(this, newLabel);
-			return this;
-		},
-		[$resolve](ctx) {
-			return ctx.withSlots([[shaderStageSlot, "compute"]], () => core.resolve(ctx, [], shell.returnType, entryInput));
-		},
-		toString() {
-			return `computeFn:${getName(core) ?? "<unnamed>"}`;
-		}
-	};
+    const core = createFnCore(implementation, 'compute', workgroupSize);
+    const result = {
+        shell,
+        $uses(newExternals) {
+            core.setExternals('userProvided', newExternals);
+            return this;
+        },
+        [$internal]: true,
+        [$getNameForward]: core,
+        $name(newLabel) {
+            setName(this, newLabel);
+            return this;
+        },
+        [$resolve](ctx) {
+            return ctx.withSlots([[shaderStageSlot, 'compute']], () => core.resolve(ctx, [], shell.returnType, entryInput));
+        },
+        toString() {
+            return `computeFn:${getName(core) ?? '<unnamed>'}`;
+        },
+    };
+    return result;
 }
-
-//#endregion
-export { computeFn, isTgpuComputeFn };

package/core/function/tgpuFn.d.ts

@@ -1,53 +1,50 @@
-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 { InferGPU } from "../../shared/repr.js";
-
-//#region src/core/function/tgpuFn.d.ts
-
+import { type BaseData, Void } from '../../data/wgslTypes.ts';
+import type { TgpuNamable } from '../../shared/meta.ts';
+import type { InferGPU } from '../../shared/repr.ts';
+import { $internal, $providing } from '../../shared/symbols.ts';
+import type { Prettify } from '../../shared/utilityTypes.ts';
+import type { DualFn } from '../../types.ts';
+import { type Providing } from '../slot/slotTypes.ts';
+import type { AnyFn, Implementation, InferArgs, InferImplSchema, InheritArgNames } from './fnTypes.ts';
+import type { Withable } from '../root/rootTypes.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;
+    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>) => InferGPU<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>);
+export type TgpuFnShell<Args extends BaseData[], Return extends BaseData> = TgpuFnShellHeader<Args, Return> & (<T extends (...args: InferArgs<Args>) => InferGPU<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;
+    [$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>;
+export 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>;
+export 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 };
+export declare function fn<Args extends BaseData[] | []>(argTypes: Args, returnType?: undefined): TgpuFnShell<Args, Void>;
+export declare function fn<Args extends BaseData[] | [], Return extends BaseData>(argTypes: Args, returnType: Return): TgpuFnShell<Args, Return>;
+export declare function fn<T extends AnyFn>(inner: T): TgpuGenericFn<T>;
+export declare function isTgpuFn<Args extends BaseData[] | [], Return extends BaseData>(value: unknown): value is TgpuFn<(...args: Args) => Return>;
+export declare function isGenericFn<Callback extends AnyFn>(value: unknown): value is TgpuGenericFn<Callback>;
+export {};

package/core/function/tgpuFn.js

@@ -1,171 +1,197 @@
-import { $getNameForward, $internal, $providing, $resolve, isMarkedInternal } from "../../shared/symbols.js";
+import { schemaCallWrapper } from "../../data/schemaCallWrapper.js";
 import { Void } from "../../data/wgslTypes.js";
-import { getName, setName } from "../../shared/meta.js";
 import { ExecutionError } from "../../errors.js";
-import { isAccessor, isMutableAccessor } from "../slot/slotTypes.js";
 import { provideInsideTgpuFn } from "../../execMode.js";
+import { getName, setName } from "../../shared/meta.js";
+import { isMarkedInternal } from "../../shared/symbols.js";
+import { $getNameForward, $internal, $providing, $resolve } from "../../shared/symbols.js";
+import { addArgTypesToExternals, addReturnTypeToExternals } from "../resolve/externals.js";
 import { stitch } from "../resolve/stitch.js";
-import { schemaCallWrapper } from "../../data/schemaCallWrapper.js";
+import { isAccessor, isMutableAccessor, } from "../slot/slotTypes.js";
 import { dualImpl } from "./dualImpl.js";
-import { comptime } from "./comptime.js";
-import { addArgTypesToExternals, addReturnTypeToExternals } from "../resolve/externals.js";
 import { createFnCore } from "./fnCore.js";
 import { stripTemplate } from "./templateUtils.js";
-
-//#region src/core/function/tgpuFn.ts
-function fn(argTypesOrCallback, returnType) {
-	if (typeof argTypesOrCallback === "function") return createGenericFn(argTypesOrCallback, []);
-	const argTypes = argTypesOrCallback;
-	const shell = {
-		[$internal]: true,
-		argTypes,
-		returnType: returnType ?? Void
-	};
-	const call = (arg, ...values) => createFn(shell, stripTemplate(arg, ...values));
-	return Object.assign(call, shell);
+import { comptime } from "./comptime.js";
+export function fn(argTypesOrCallback, returnType) {
+    if (typeof argTypesOrCallback === 'function') {
+        return createGenericFn(argTypesOrCallback, []);
+    }
+    const argTypes = argTypesOrCallback;
+    const shell = {
+        [$internal]: true,
+        argTypes,
+        returnType: returnType ?? Void,
+    };
+    const call = (arg, ...values) => createFn(shell, stripTemplate(arg, ...values));
+    return Object.assign(call, shell);
 }
-function isTgpuFn(value) {
-	return isMarkedInternal(value) && value?.resourceType === "function";
+export function isTgpuFn(value) {
+    return (isMarkedInternal(value) &&
+        value?.resourceType === 'function');
 }
-function isGenericFn(value) {
-	return isMarkedInternal(value) && value?.resourceType === "generic-function";
+export function isGenericFn(value) {
+    return (isMarkedInternal(value) &&
+        value?.resourceType === 'generic-function');
 }
+// --------------
+// Implementation
+// --------------
 function stringifyPair([slot, value]) {
-	return `${getName(slot) ?? "<unnamed>"}=${value}`;
+    return `${getName(slot) ?? '<unnamed>'}=${value}`;
 }
 function createFn(shell, _implementation) {
-	let pairs = [];
-	let implementation;
-	if (isGenericFn(_implementation)) {
-		pairs = _implementation[$providing]?.pairs ?? [];
-		implementation = _implementation[$internal].inner;
-	} else implementation = _implementation;
-	const core = createFnCore(implementation, "normal");
-	const fnBase = {
-		shell,
-		resourceType: "function",
-		[$internal]: { implementation },
-		$uses(newExternals) {
-			core.applyExternals(newExternals);
-			return this;
-		},
-		[$getNameForward]: core,
-		$name(label) {
-			setName(this, label);
-			return this;
-		},
-		with: comptime((slot, value) => {
-			return createBoundFunction(fn$1, [[isAccessor(slot) || isMutableAccessor(slot) ? slot.slot : slot, value]]);
-		}),
-		[$resolve](ctx) {
-			if (typeof implementation === "string") {
-				addArgTypesToExternals(implementation, shell.argTypes, core.applyExternals);
-				addReturnTypeToExternals(implementation, shell.returnType, core.applyExternals);
-			}
-			return core.resolve(ctx, shell.argTypes, shell.returnType);
-		}
-	};
-	const call = dualImpl({
-		name: void 0,
-		noComptime: true,
-		signature: {
-			argTypes: shell.argTypes,
-			returnType: shell.returnType
-		},
-		normalImpl: (...args) => provideInsideTgpuFn(() => {
-			try {
-				if (typeof implementation === "string") throw new Error("Cannot execute on the CPU functions constructed with raw WGSL");
-				const castAndCopiedArgs = args.map((arg, index) => schemaCallWrapper(shell.argTypes[index], arg));
-				const result = implementation(...castAndCopiedArgs);
-				return schemaCallWrapper(shell.returnType, result);
-			} catch (err) {
-				if (err instanceof ExecutionError) throw err.appendToTrace(fn$1);
-				throw new ExecutionError(err, [fn$1]);
-			}
-		}),
-		codegenImpl: (ctx, args) => ctx.withResetIndentLevel(() => stitch`${ctx.resolve(fn$1).value}(${args})`)
-	});
-	const fn$1 = Object.assign(call, fnBase);
-	Object.defineProperty(fn$1, "toString", { value() {
-		return `fn:${getName(core) ?? "<unnamed>"}`;
-	} });
-	if (pairs.length > 0) return createBoundFunction(fn$1, pairs);
-	return fn$1;
+    let pairs = [];
+    // Unwrapping generic functions
+    let implementation;
+    if (isGenericFn(_implementation)) {
+        pairs = _implementation[$providing]?.pairs ?? [];
+        implementation = _implementation[$internal].inner;
+    }
+    else {
+        implementation = _implementation;
+    }
+    const core = createFnCore(implementation, 'normal');
+    const fnBase = {
+        shell,
+        resourceType: 'function',
+        [$internal]: { implementation },
+        $uses(newExternals) {
+            core.setExternals('userProvided', newExternals);
+            return this;
+        },
+        [$getNameForward]: core,
+        $name(label) {
+            setName(this, label);
+            return this;
+        },
+        with: comptime((slot, value) => {
+            const s = isAccessor(slot) || isMutableAccessor(slot) ? slot.slot : slot;
+            return createBoundFunction(fn, [[s, value]]);
+        }),
+        [$resolve](ctx) {
+            if (typeof implementation === 'string') {
+                addArgTypesToExternals(implementation, shell.argTypes, core);
+                addReturnTypeToExternals(implementation, shell.returnType, core);
+            }
+            return core.resolve(ctx, shell.argTypes, shell.returnType);
+        },
+    };
+    const call = dualImpl({
+        name: undefined, // the name is forwarded to the core anyway
+        noComptime: true,
+        signature: { argTypes: shell.argTypes, returnType: shell.returnType },
+        normalImpl: (...args) => provideInsideTgpuFn(() => {
+            try {
+                if (typeof implementation === 'string') {
+                    throw new Error('Cannot execute on the CPU functions constructed with raw WGSL');
+                }
+                const castAndCopiedArgs = args.map((arg, index) => schemaCallWrapper(shell.argTypes[index], arg));
+                const result = implementation(...castAndCopiedArgs);
+                // Casting the result to the appropriate schema
+                return schemaCallWrapper(shell.returnType, result);
+            }
+            catch (err) {
+                if (err instanceof ExecutionError) {
+                    throw err.appendToTrace(fn);
+                }
+                throw new ExecutionError(err, [fn]);
+            }
+        }),
+        codegenImpl: (ctx, args) => ctx.withResetIndentLevel(() => stitch `${ctx.resolve(fn).value}(${args})`),
+        sideEffects: true,
+    });
+    const fn = Object.assign(call, fnBase);
+    Object.defineProperty(fn, 'toString', {
+        value() {
+            return `fn:${getName(core) ?? '<unnamed>'}`;
+        },
+    });
+    if (pairs.length > 0) {
+        return createBoundFunction(fn, pairs);
+    }
+    return fn;
 }
 function createBoundFunction(innerFn, pairs) {
-	const fnBase = {
-		resourceType: "function",
-		shell: innerFn.shell,
-		[$internal]: { implementation: innerFn[$internal].implementation },
-		[$providing]: {
-			inner: innerFn,
-			pairs
-		},
-		$uses(newExternals) {
-			innerFn.$uses(newExternals);
-			return this;
-		},
-		$name(label) {
-			setName(this, label);
-			return this;
-		},
-		with: comptime((slot, value) => {
-			const s = isAccessor(slot) || isMutableAccessor(slot) ? slot.slot : slot;
-			return createBoundFunction(innerFn, [...pairs, [s, value]]);
-		})
-	};
-	const call = dualImpl({
-		name: void 0,
-		noComptime: true,
-		signature: {
-			argTypes: innerFn.shell.argTypes,
-			returnType: innerFn.shell.returnType
-		},
-		normalImpl: innerFn,
-		codegenImpl: (ctx, args) => ctx.withResetIndentLevel(() => stitch`${ctx.resolve(fn$1).value}(${args})`)
-	});
-	const fn$1 = Object.assign(call, fnBase);
-	Object.defineProperty(fn$1, "toString", { value() {
-		return `fn:${getName(this) ?? "<unnamed>"}[${pairs.map(stringifyPair).join(", ")}]`;
-	} });
-	const innerName = getName(innerFn);
-	if (innerName) setName(fn$1, innerName);
-	return fn$1;
+    const fnBase = {
+        resourceType: 'function',
+        shell: innerFn.shell,
+        [$internal]: { implementation: innerFn[$internal].implementation },
+        [$providing]: { inner: innerFn, pairs },
+        $uses(newExternals) {
+            innerFn.$uses(newExternals);
+            return this;
+        },
+        $name(label) {
+            setName(this, label);
+            return this;
+        },
+        with: comptime((slot, value) => {
+            const s = isAccessor(slot) || isMutableAccessor(slot) ? slot.slot : slot;
+            return createBoundFunction(innerFn, [...pairs, [s, value]]);
+        }),
+    };
+    const call = dualImpl({
+        name: undefined, // setting name here would override autonaming
+        noComptime: true,
+        signature: {
+            argTypes: innerFn.shell.argTypes,
+            returnType: innerFn.shell.returnType,
+        },
+        normalImpl: innerFn,
+        codegenImpl: (ctx, args) => ctx.withResetIndentLevel(() => stitch `${ctx.resolve(fn).value}(${args})`),
+        sideEffects: true,
+    });
+    const fn = Object.assign(call, fnBase);
+    Object.defineProperty(fn, 'toString', {
+        value() {
+            const fnLabel = getName(this) ?? '<unnamed>';
+            return `fn:${fnLabel}[${pairs.map(stringifyPair).join(', ')}]`;
+        },
+    });
+    const innerName = getName(innerFn);
+    if (innerName) {
+        setName(fn, innerName);
+    }
+    return fn;
 }
 function createGenericFn(inner, pairs) {
-	const fnBase = {
-		[$internal]: { inner },
-		resourceType: "generic-function",
-		[$providing]: pairs.length > 0 ? {
-			inner,
-			pairs
-		} : void 0,
-		$name(label) {
-			setName(this, label);
-			if (!getName(inner)) setName(inner, label);
-			return this;
-		},
-		[$resolve](ctx) {
-			return ctx.resolve(inner);
-		},
-		with(slot, value) {
-			const s = isAccessor(slot) || isMutableAccessor(slot) ? slot.slot : slot;
-			return createGenericFn(inner, [...pairs, [s, value]]);
-		}
-	};
-	const call = (...args) => {
-		return inner(...args);
-	};
-	const genericFn = Object.assign(call, fnBase);
-	const innerName = getName(inner);
-	if (innerName) setName(genericFn, innerName);
-	Object.defineProperty(genericFn, "toString", { value() {
-		const fnLabel = getName(genericFn) ?? "<unnamed>";
-		if (pairs.length > 0) return `fn*:${fnLabel}[${pairs.map(stringifyPair).join(", ")}]`;
-		return `fn*:${fnLabel}`;
-	} });
-	return genericFn;
+    const fnBase = {
+        [$internal]: { inner },
+        resourceType: 'generic-function',
+        [$providing]: pairs.length > 0 ? { inner, pairs } : undefined,
+        $name(label) {
+            setName(this, label);
+            // Giving `inner` a name if it doesn't have one
+            if (!getName(inner)) {
+                setName(inner, label);
+            }
+            return this;
+        },
+        [$resolve](ctx) {
+            return ctx.resolve(inner);
+        },
+        with(slot, value) {
+            const s = isAccessor(slot) || isMutableAccessor(slot) ? slot.slot : slot;
+            return createGenericFn(inner, [...pairs, [s, value]]);
+        },
+    };
+    const call = (...args) => {
+        return inner(...args);
+    };
+    const genericFn = Object.assign(call, fnBase);
+    // Inheriting name from `inner`, if it exists
+    const innerName = getName(inner);
+    if (innerName) {
+        setName(genericFn, innerName);
+    }
+    Object.defineProperty(genericFn, 'toString', {
+        value() {
+            const fnLabel = getName(genericFn) ?? '<unnamed>';
+            if (pairs.length > 0) {
+                return `fn*:${fnLabel}[${pairs.map(stringifyPair).join(', ')}]`;
+            }
+            return `fn*:${fnLabel}`;
+        },
+    });
+    return genericFn;
 }
-
-//#endregion
-export { fn, isGenericFn, isTgpuFn };