@shivaedev/effect-trpc 0.6.0 → 0.7.0

package/dist/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/src/adapter.ts

@@ -1,72 +0,0 @@
-import type { TRPCProcedureBuilder } from "@trpc/server";
-import type { Context, Effect, Exit } from "effect";
-import { makeContextBridge } from "#internal/context-bridge.ts";
-import { looseBuilder } from "#internal/loose.ts";
-import type { ResolverContext } from "#internal/procedure-types.ts";
-import { makeRuntimeBridge } from "#internal/runtime.ts";
-import { EffectProcedureBuilder } from "./procedure.ts";
-import type { EffectProcedureRequestServices } from "./request-services.ts";
-import type { EffectTRPCErrorMapper, EffectTRPCInstrument, EffectTRPCStreamInstrument } from "./types.ts";
-
-export interface MakeEffectTRPCOptions<Requirements, RuntimeError> {
-	readonly instrument?: EffectTRPCInstrument;
-	readonly instrumentStream?: EffectTRPCStreamInstrument;
-	readonly mapError?: EffectTRPCErrorMapper;
-	readonly runtime: EffectTRPCRuntime<Requirements, RuntimeError>;
-}
-
-export interface EffectTRPCRuntime<Requirements, RuntimeError> {
-	readonly contextEffect: Effect.Effect<Context.Context<Requirements>, RuntimeError>;
-	readonly currentServices?: () => Context.Context<never> | undefined;
-	readonly runPromise: <Value, Error>(
-		effect: Effect.Effect<Value, Error, Requirements>,
-		options?: { readonly signal?: AbortSignal },
-	) => Promise<Value>;
-	readonly runPromiseExit: <Value, Error>(
-		effect: Effect.Effect<Value, Error, Requirements>,
-		options?: { readonly signal?: AbortSignal },
-	) => Promise<Exit.Exit<Value, Error | RuntimeError>>;
-	readonly runWithServices?: <Services, Value>(services: Context.Context<Services>, evaluate: () => Value) => Value;
-}
-
-export interface EffectTRPCAdapter<Requirements> {
-	readonly procedure: <Context, Meta, ContextOverrides, InputIn, InputOut, OutputIn, OutputOut, ProvidedServices, LayerError>(
-		builder: TRPCProcedureBuilder<Context, Meta, ContextOverrides, InputIn, InputOut, OutputIn, OutputOut, false>,
-		requestServices: EffectProcedureRequestServices<ResolverContext<Context, Meta, ContextOverrides>, ProvidedServices, LayerError>,
-	) => EffectProcedureBuilder<Context, Meta, ContextOverrides, InputIn, InputOut, OutputIn, OutputOut, ProvidedServices, LayerError, Requirements>;
-	readonly runWithServices: <Services, Value>(services: Context.Context<Services>, evaluate: () => Value) => Value;
-}
-
-export const makeEffectTRPC = <Requirements, RuntimeError = never>(
-	options: MakeEffectTRPCOptions<Requirements, RuntimeError>,
-): EffectTRPCAdapter<Requirements> => {
-	const contextBridge = makeContextBridge(options.runtime);
-	const runtime = makeRuntimeBridge(options.runtime, contextBridge, options);
-
-	return {
-		procedure: <Context, Meta, ContextOverrides, InputIn, InputOut, OutputIn, OutputOut, ProvidedServices, LayerError>(
-			builder: TRPCProcedureBuilder<Context, Meta, ContextOverrides, InputIn, InputOut, OutputIn, OutputOut, false>,
-			requestServices: EffectProcedureRequestServices<ResolverContext<Context, Meta, ContextOverrides>, ProvidedServices, LayerError>,
-		) => {
-			const loose = looseBuilder(builder);
-			return new EffectProcedureBuilder<
-				Context,
-				Meta,
-				ContextOverrides,
-				InputIn,
-				InputOut,
-				OutputIn,
-				OutputOut,
-				ProvidedServices,
-				LayerError,
-				Requirements
-			>({
-				builder: loose,
-				requestServices,
-				runtime,
-				subscriptionBuilder: loose,
-			});
-		},
-		runWithServices: contextBridge.run,
-	};
-};

package/src/errors.ts

@@ -1,19 +0,0 @@
-import { TRPCError } from "@trpc/server";
-import { Effect } from "effect";
-
-export const fail = (code: TRPCError["code"], message: string, cause?: unknown): Effect.Effect<never, TRPCError> =>
-	Effect.fail(new TRPCError({ cause, code, message }));
-
-export const badRequest = (message: string, cause?: unknown) => fail("BAD_REQUEST", message, cause);
-
-export const unauthorized = (message: string, cause?: unknown) => fail("UNAUTHORIZED", message, cause);
-
-export const forbidden = (message: string, cause?: unknown) => fail("FORBIDDEN", message, cause);
-
-export const notFound = (message: string, cause?: unknown) => fail("NOT_FOUND", message, cause);
-
-export const conflict = (message: string, cause?: unknown) => fail("CONFLICT", message, cause);
-
-export const preconditionFailed = (message: string, cause?: unknown) => fail("PRECONDITION_FAILED", message, cause);
-
-export const internalServerError = (message: string, cause?: unknown) => fail("INTERNAL_SERVER_ERROR", message, cause);

package/src/internal/loose.ts

@@ -1,14 +0,0 @@
-import type { ProcedureBuilderOf, ProcedureBuilderSurface, ResolverContext } from "./procedure-types.ts";
-
-export function looseBuilder<Context, Meta, ContextOverrides, InputIn, InputOut, OutputIn, OutputOut>(
-	builder: ProcedureBuilderOf<Context, Meta, ContextOverrides, InputIn, InputOut, OutputIn, OutputOut>,
-): ProcedureBuilderSurface<ResolverContext<Context, Meta, ContextOverrides>>;
-export function looseBuilder(builder: unknown): unknown {
-	return builder;
-}
-
-// tRPC runs the procedure's input parsers before the resolver, so the resolver receives the input it declared.
-export function acceptParsedInput<Result>(resolver: (input: never) => Result): (input: unknown) => Result;
-export function acceptParsedInput(resolver: unknown): unknown {
-	return resolver;
-}

package/src/internal/procedure-types.ts

@@ -1,44 +0,0 @@
-import type { inferProcedureBuilderResolverOptions, TRPCProcedureBuilder, TRPCUnsetMarker } from "@trpc/server";
-import type { Effect, StandardSchema, Stream } from "effect";
-
-export type ProcedureBuilderOf<Context, Meta, ContextOverrides, InputIn, InputOut, OutputIn, OutputOut> = TRPCProcedureBuilder<
-	Context,
-	Meta,
-	ContextOverrides,
-	InputIn,
-	InputOut,
-	OutputIn,
-	OutputOut,
-	false
->;
-
-export type DefaultValue<Value, Fallback> = Value extends TRPCUnsetMarker ? Fallback : Value;
-
-export type IntersectIfDefined<Value, With> = Value extends TRPCUnsetMarker ? With : With extends TRPCUnsetMarker ? Value : Value & With;
-
-export type ResolverContext<Context, Meta, ContextOverrides> = inferProcedureBuilderResolverOptions<
-	ProcedureBuilderOf<Context, Meta, ContextOverrides, TRPCUnsetMarker, TRPCUnsetMarker, TRPCUnsetMarker, TRPCUnsetMarker>
->["ctx"];
-
-export type ProcedureEffect<Requirements> = Effect.Effect<unknown, unknown, Requirements>;
-
-export type EffectProcedureResolver<Input, Requirements, Output> = (input: Input) => Generator<ProcedureEffect<Requirements>, Output, never>;
-
-export type EffectSubscriptionResolver<Input, Requirements, Output> = (
-	input: Input,
-) => Generator<ProcedureEffect<Requirements>, Stream.Stream<Output, unknown, Requirements>, never>;
-
-export interface ProcedureInvocation<Context> {
-	readonly ctx: Context;
-	readonly input: unknown;
-	readonly path: string;
-	readonly signal: AbortSignal | undefined;
-}
-
-export interface ProcedureBuilderSurface<Context> {
-	input: (schema: StandardSchema.StandardSchemaV1) => ProcedureBuilderSurface<Context>;
-	mutation: (resolver: (invocation: ProcedureInvocation<Context>) => Promise<unknown>) => unknown;
-	output: (schema: StandardSchema.StandardSchemaV1) => ProcedureBuilderSurface<Context>;
-	query: (resolver: (invocation: ProcedureInvocation<Context>) => Promise<unknown>) => unknown;
-	subscription: (resolver: (invocation: ProcedureInvocation<Context>) => Promise<AsyncIterable<unknown, void, unknown>>) => unknown;
-}

package/src/internal/runtime.ts

@@ -1,134 +0,0 @@
-import { TRPCError } from "@trpc/server";
-import { Cause, Context, Effect, Exit, Option, Result, Stream } from "effect";
-import type { EffectTRPCRuntime } from "#adapter.ts";
-import type { EffectTRPCErrorMapper, EffectTRPCInstrument, ProcedureInfo } from "#types.ts";
-import type { ContextBridge } from "./context-bridge.ts";
-
-interface RunEffectOptions {
-	readonly procedure: ProcedureInfo;
-	readonly signal?: AbortSignal;
-}
-
-export interface RuntimeBridge<Requirements> {
-	readonly instrument: EffectTRPCInstrument;
-	readonly runEffect: <Value>(effect: Effect.Effect<Value, unknown, Requirements>, options: RunEffectOptions) => Promise<Value>;
-	readonly runStream: <Value>(stream: Stream.Stream<Value, unknown, Requirements>, options: RunEffectOptions) => Promise<AsyncIterable<Value>>;
-}
-
-const internalError = (cause?: unknown): TRPCError =>
-	new TRPCError({
-		cause,
-		code: "INTERNAL_SERVER_ERROR",
-		message: "Internal server error",
-	});
-
-const mapError = (
-	error: unknown,
-	origin: "defect" | "failure",
-	procedure: ProcedureInfo,
-	consumerMapper: EffectTRPCErrorMapper | undefined,
-): TRPCError => {
-	if (error instanceof TRPCError) {
-		return error;
-	}
-
-	try {
-		return consumerMapper?.(error, { ...procedure, origin }) ?? internalError(error);
-	} catch (mapperDefect) {
-		return internalError(mapperDefect);
-	}
-};
-
-const mapCause = (cause: Cause.Cause<unknown>, procedure: ProcedureInfo, consumerMapper: EffectTRPCErrorMapper | undefined): TRPCError => {
-	if (Cause.hasInterruptsOnly(cause)) {
-		return new TRPCError({
-			code: "CLIENT_CLOSED_REQUEST",
-			message: "Request cancelled",
-		});
-	}
-
-	const failure = Cause.findErrorOption(cause);
-	if (Option.isSome(failure)) {
-		return mapError(failure.value, "failure", procedure, consumerMapper);
-	}
-
-	const defect = Cause.findDefect(cause);
-	if (Result.isSuccess(defect)) {
-		return mapError(defect.success, "defect", procedure, consumerMapper);
-	}
-
-	return internalError();
-};
-
-const interruptOn = (signal: AbortSignal | undefined): Effect.Effect<void> => {
-	if (signal === undefined) {
-		return Effect.never;
-	}
-	return Effect.callback<void>((resume) => {
-		if (signal.aborted) {
-			resume(Effect.void);
-			return;
-		}
-		const abort = () => resume(Effect.void);
-		signal.addEventListener("abort", abort, { once: true });
-		return Effect.sync(() => signal.removeEventListener("abort", abort));
-	});
-};
-
-export const makeRuntimeBridge = <Requirements, RuntimeError>(
-	runtime: EffectTRPCRuntime<Requirements, RuntimeError>,
-	contextBridge: ContextBridge,
-	options: {
-		readonly instrument?: EffectTRPCInstrument;
-		readonly instrumentStream?: import("#types.ts").EffectTRPCStreamInstrument;
-		readonly mapError?: EffectTRPCErrorMapper;
-	},
-): RuntimeBridge<Requirements> => ({
-	instrument: (effect, procedure) => Effect.suspend(() => (options.instrument === undefined ? effect : options.instrument(effect, procedure))),
-	runEffect: async (effect, runOptions) => {
-		const traced = effect.pipe(
-			Effect.withSpan(
-				runOptions.procedure.path,
-				{
-					attributes: {
-						"rpc.method": runOptions.procedure.path,
-						"rpc.system": "trpc",
-						"trpc.type": runOptions.procedure.type,
-					},
-				},
-				{
-					captureStackTrace: runOptions.procedure.captureStackTrace,
-				},
-			),
-		);
-		const ambient = contextBridge.current();
-		const runnable =
-			ambient === undefined ? traced : Effect.flatMap(runtime.contextEffect, (base) => Effect.provideContext(traced, Context.merge(base, ambient)));
-		const exit = await runtime.runPromiseExit(runnable, runOptions.signal === undefined ? undefined : { signal: runOptions.signal });
-
-		if (Exit.isSuccess(exit)) {
-			return exit.value;
-		}
-		throw mapCause(exit.cause, runOptions.procedure, options.mapError);
-	},
-	runStream: async (stream, runOptions) => {
-		const instrumented = Stream.suspend(() =>
-			options.instrumentStream === undefined ? stream : options.instrumentStream(stream, runOptions.procedure),
-		).pipe(
-			Stream.withSpan(runOptions.procedure.path, {
-				attributes: {
-					"rpc.method": runOptions.procedure.path,
-					"rpc.system": "trpc",
-					"trpc.type": runOptions.procedure.type,
-				},
-				captureStackTrace: runOptions.procedure.captureStackTrace,
-			}),
-			Stream.interruptWhen(interruptOn(runOptions.signal)),
-			Stream.catchCause((cause) => Stream.fail(mapCause(cause, runOptions.procedure, options.mapError))),
-		);
-		const context = await runtime.runPromise(Effect.context<Requirements>());
-		const ambient = contextBridge.current();
-		const provided = ambient === undefined ? context : Context.merge(context, ambient);
-		return Stream.toAsyncIterableWith(instrumented, provided);
-	},
-});

package/src/procedure.ts

@@ -1,142 +0,0 @@
-import type { TRPCMutationProcedure, TRPCQueryProcedure, TRPCSubscriptionProcedure } from "@trpc/server";
-import { Schema } from "effect";
-import { makeProcedureHandler } from "#internal/procedure-handler.ts";
-import type {
-	DefaultValue,
-	EffectProcedureResolver,
-	EffectSubscriptionResolver,
-	IntersectIfDefined,
-	ProcedureBuilderSurface,
-	ResolverContext,
-} from "#internal/procedure-types.ts";
-import type { RuntimeBridge } from "#internal/runtime.ts";
-import { captureStackTrace } from "#internal/stack-trace.ts";
-import { makeSubscriptionHandler } from "#internal/subscription-handler.ts";
-import type { EffectProcedureRequestServices } from "./request-services.ts";
-
-interface ProcedureParts<Context, Meta, ContextOverrides, ProvidedServices, LayerError, RuntimeRequirements> {
-	readonly builder: ProcedureBuilderSurface<ResolverContext<Context, Meta, ContextOverrides>>;
-	readonly requestServices: EffectProcedureRequestServices<ResolverContext<Context, Meta, ContextOverrides>, ProvidedServices, LayerError>;
-	readonly runtime: RuntimeBridge<RuntimeRequirements>;
-	readonly subscriptionBuilder: ProcedureBuilderSurface<ResolverContext<Context, Meta, ContextOverrides>>;
-	readonly subscriptionOutput?: Schema.ConstraintDecoder<unknown> | undefined;
-}
-
-export class EffectProcedureBuilder<
-	Context,
-	Meta,
-	ContextOverrides,
-	InputIn,
-	InputOut,
-	OutputIn,
-	OutputOut,
-	ProvidedServices,
-	LayerError,
-	RuntimeRequirements,
-> {
-	private readonly parts: ProcedureParts<Context, Meta, ContextOverrides, ProvidedServices, LayerError, RuntimeRequirements>;
-
-	constructor(parts: ProcedureParts<Context, Meta, ContextOverrides, ProvidedServices, LayerError, RuntimeRequirements>) {
-		this.parts = parts;
-	}
-
-	input<SchemaValue extends Schema.ConstraintDecoder<unknown>>(
-		schema: SchemaValue,
-	): EffectProcedureBuilder<
-		Context,
-		Meta,
-		ContextOverrides,
-		IntersectIfDefined<InputIn, SchemaValue["Encoded"]>,
-		IntersectIfDefined<InputOut, SchemaValue["Type"]>,
-		OutputIn,
-		OutputOut,
-		ProvidedServices,
-		LayerError,
-		RuntimeRequirements
-	> {
-		const parser = Schema.toStandardSchemaV1(schema);
-		return new EffectProcedureBuilder({
-			...this.parts,
-			builder: this.parts.builder.input(parser),
-			subscriptionBuilder: this.parts.subscriptionBuilder.input(parser),
-		});
-	}
-
-	output<SchemaValue extends Schema.ConstraintDecoder<unknown>>(
-		schema: SchemaValue,
-	): EffectProcedureBuilder<
-		Context,
-		Meta,
-		ContextOverrides,
-		InputIn,
-		InputOut,
-		IntersectIfDefined<OutputIn, SchemaValue["Encoded"]>,
-		IntersectIfDefined<OutputOut, SchemaValue["Type"]>,
-		ProvidedServices,
-		LayerError,
-		RuntimeRequirements
-	> {
-		return new EffectProcedureBuilder({
-			...this.parts,
-			builder: this.parts.builder.output(Schema.toStandardSchemaV1(schema)),
-			subscriptionOutput: schema,
-		});
-	}
-
-	query<Output>(
-		resolver: EffectProcedureResolver<
-			DefaultValue<InputOut, undefined>,
-			ProvidedServices | NoInfer<RuntimeRequirements>,
-			DefaultValue<OutputIn, Output>
-		>,
-	): TRPCQueryProcedure<{
-		input: DefaultValue<InputIn, void>;
-		output: DefaultValue<OutputOut, Output>;
-		meta: Meta;
-	}>;
-	query(resolver: EffectProcedureResolver<never, ProvidedServices | RuntimeRequirements, unknown>): unknown {
-		return this.parts.builder.query(this.handler("query", resolver));
-	}
-
-	mutation<Output>(
-		resolver: EffectProcedureResolver<
-			DefaultValue<InputOut, undefined>,
-			ProvidedServices | NoInfer<RuntimeRequirements>,
-			DefaultValue<OutputIn, Output>
-		>,
-	): TRPCMutationProcedure<{
-		input: DefaultValue<InputIn, void>;
-		output: DefaultValue<OutputOut, Output>;
-		meta: Meta;
-	}>;
-	mutation(resolver: EffectProcedureResolver<never, ProvidedServices | RuntimeRequirements, unknown>): unknown {
-		return this.parts.builder.mutation(this.handler("mutation", resolver));
-	}
-
-	subscription<Output>(
-		resolver: EffectSubscriptionResolver<
-			DefaultValue<InputOut, undefined>,
-			ProvidedServices | NoInfer<RuntimeRequirements>,
-			DefaultValue<OutputIn, Output>
-		>,
-	): TRPCSubscriptionProcedure<{
-		input: DefaultValue<InputIn, void>;
-		output: AsyncIterable<DefaultValue<OutputOut, Output>, void, unknown>;
-		meta: Meta;
-	}>;
-	subscription(resolver: EffectSubscriptionResolver<never, ProvidedServices | RuntimeRequirements, unknown>): unknown {
-		return this.parts.subscriptionBuilder.subscription(
-			makeSubscriptionHandler(
-				this.parts.runtime,
-				resolver,
-				this.parts.requestServices,
-				{ captureStackTrace: captureStackTrace(), type: "subscription" },
-				this.parts.subscriptionOutput,
-			),
-		);
-	}
-
-	private handler(type: "mutation" | "query", resolver: EffectProcedureResolver<never, ProvidedServices | RuntimeRequirements, unknown>) {
-		return makeProcedureHandler(this.parts.runtime, resolver, this.parts.requestServices, { captureStackTrace: captureStackTrace(), type });
-	}
-}

package/src/request-services.ts

@@ -1,23 +0,0 @@
-import { type Layer as EffectLayer, Layer } from "effect";
-
-export interface EffectProcedureRequestServices<Context, Requirements, Error = never> {
-	readonly layer: (context: Context) => EffectLayer.Layer<Requirements, Error>;
-}
-
-export const makeRequestServices = <Context, Requirements, Error = never>(
-	layer: (context: Context) => EffectLayer.Layer<Requirements, Error>,
-): EffectProcedureRequestServices<Context, Requirements, Error> => ({ layer });
-
-export const extendRequestServices = <
-	BaseContext,
-	Context extends BaseContext,
-	BaseRequirements,
-	BaseError,
-	AdditionalRequirements,
-	AdditionalError,
-	AdditionalDependencies extends BaseRequirements = BaseRequirements,
->(
-	base: EffectProcedureRequestServices<BaseContext, BaseRequirements, BaseError>,
-	additional: (context: Context) => EffectLayer.Layer<AdditionalRequirements, AdditionalError, AdditionalDependencies>,
-): EffectProcedureRequestServices<Context, BaseRequirements | AdditionalRequirements, BaseError | AdditionalError> =>
-	makeRequestServices((context: Context) => Layer.provideMerge(additional(context), base.layer(context)));

package/src/testing/types.ts

@@ -1,63 +0,0 @@
-import type { TestContext, Vitest } from "@effect/vitest";
-import type { Effect, Layer } from "effect";
-import type { EffectClock, EffectTestOptions } from "@shivaedev/effect-test/types.ts";
-import type { EffectTRPCAdapter } from "#adapter.ts";
-import type { AnyTestLayer } from "./any-test-layer.ts";
-import type { EffectCallerFactory } from "./caller.ts";
-
-export type TrpcHarnessTest<Harness, Provided> = <A, Eff extends Effect.Effect<unknown, unknown, Provided>>(
-	name: string,
-	body: (harness: Harness, context: TestContext) => Generator<Eff, A, never>,
-	options?: number | EffectTestOptions,
-) => void;
-
-export interface TrpcHarnessTester<Harness, Provided> extends TrpcHarnessTest<Harness, Provided> {
-	readonly each: <Item>(
-		cases: readonly Item[],
-	) => <A, Eff extends Effect.Effect<unknown, unknown, Provided>>(
-		name: string,
-		body: (item: Item, harness: Harness, context: TestContext) => Generator<Eff, A, never>,
-		options?: number | EffectTestOptions,
-	) => void;
-	readonly fails: TrpcHarnessTest<Harness, Provided>;
-	readonly only: TrpcHarnessTest<Harness, Provided>;
-	readonly runIf: (condition: unknown) => TrpcHarnessTest<Harness, Provided>;
-	readonly skip: TrpcHarnessTest<Harness, Provided>;
-	readonly skipIf: (condition: unknown) => TrpcHarnessTest<Harness, Provided>;
-}
-
-export type TrpcTest<Options, Caller, Provided> = TrpcHarnessTest<EffectCallerFactory<Options, Caller>, Provided>;
-
-export type TrpcTester<Options, Caller, Provided> = TrpcHarnessTester<EffectCallerFactory<Options, Caller>, Provided>;
-
-export type TrpcIt<Options, Caller, Provided> = Vitest.Methods & {
-	readonly effectTRPC: TrpcTester<Options, Caller, Provided>;
-};
-
-export type TrpcHarnessIt<Harness, Provided> = Vitest.Methods & {
-	readonly effectTRPC: TrpcHarnessTester<Harness, Provided>;
-};
-
-export interface MakeTrpcItOptions<CreateCaller extends (...arguments_: never[]) => object, TestLayer extends AnyTestLayer> {
-	readonly adapter: Pick<EffectTRPCAdapter<never>, "runWithServices">;
-	readonly around?: <A, E>(effect: Effect.Effect<A, E, Layer.Success<TestLayer>>) => Effect.Effect<A, unknown, Layer.Success<TestLayer>>;
-	readonly clock?: EffectClock;
-	readonly createCaller: CreateCaller;
-	readonly layer: TestLayer;
-}
-
-export interface MakeTrpcHarnessItOptions<CreateCaller extends (...arguments_: never[]) => object, TestLayer extends AnyTestLayer, Harness>
-	extends MakeTrpcItOptions<CreateCaller, TestLayer> {
-	readonly makeHarness: (
-		trpc: EffectCallerFactory<CallerOptions<CreateCaller>, CallerResult<CreateCaller>>,
-		context: TestContext,
-	) => Effect.Effect<Harness, unknown, Layer.Success<TestLayer>>;
-}
-
-export type CallerOptions<CreateCaller> = CreateCaller extends (...arguments_: infer Arguments) => object ? Arguments[0] : never;
-
-export type CallerResult<CreateCaller> = CreateCaller extends (...arguments_: infer _Arguments) => infer Caller
-	? Caller extends object
-		? Caller
-		: never
-	: never;