@shivaedev/effect-trpc 0.3.4 → 0.4.1

package/src/adapter.ts

@@ -1,17 +1,12 @@
-import type {
-	inferProcedureBuilderResolverOptions,
-	TRPCProcedureBuilder,
-} from "@trpc/server";
+import type { TRPCProcedureBuilder } from "@trpc/server";
 import type { Context, Effect, Exit } from "effect";
-import { makeContextBridge } from "./internal/context-bridge.js";
-import { makeRuntimeBridge } from "./internal/runtime.js";
-import { EffectProcedureBuilder } from "./procedure.js";
-import type { EffectProcedureRequestServices } from "./request-services.js";
-import type {
-	EffectTRPCErrorMapper,
-	EffectTRPCInstrument,
-	EffectTRPCStreamInstrument,
-} from "./types.js";
+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;
@@ -21,10 +16,7 @@ export interface MakeEffectTRPCOptions<Requirements, RuntimeError> {
 }
 
 export interface EffectTRPCRuntime<Requirements, RuntimeError> {
-	readonly contextEffect: Effect.Effect<
-		Context.Context<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>,
@@ -34,66 +26,15 @@ export interface EffectTRPCRuntime<Requirements, RuntimeError> {
 		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;
+	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<
-			inferProcedureBuilderResolverOptions<
-				TRPCProcedureBuilder<
-					Context,
-					Meta,
-					ContextOverrides,
-					InputIn,
-					InputOut,
-					OutputIn,
-					OutputOut,
-					false
-				>
-			>["ctx"],
-			ProvidedServices,
-			LayerError
-		>,
-	) => EffectProcedureBuilder<
-		Context,
-		Meta,
-		ContextOverrides,
-		InputIn,
-		InputOut,
-		OutputIn,
-		OutputOut,
-		ProvidedServices,
-		LayerError,
-		Requirements
-	>;
-	readonly runWithServices: <Services, Value>(
-		services: Context.Context<Services>,
-		evaluate: () => Value,
-	) => Value;
+	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>(
@@ -103,8 +44,15 @@ export const makeEffectTRPC = <Requirements, RuntimeError = never>(
 	const runtime = makeRuntimeBridge(options.runtime, contextBridge, options);
 
 	return {
-		procedure: (builder, requestServices) =>
-			new EffectProcedureBuilder(builder, requestServices, runtime) as never,
+		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>,
+		) =>
+			new EffectProcedureBuilder<Context, Meta, ContextOverrides, InputIn, InputOut, OutputIn, OutputOut, ProvidedServices, LayerError, Requirements>(
+				looseBuilder(builder),
+				requestServices,
+				runtime,
+			),
 		runWithServices: contextBridge.run,
 	};
 };

package/src/client/rejection.ts

@@ -0,0 +1,19 @@
+import { Option, Schema } from "effect";
+
+export const EncodedRejection = Schema.StructWithRest(
+	Schema.Struct({ _tag: Schema.String, invalidInput: Schema.optionalKey(Schema.Literal(true)) }),
+	[Schema.Record(Schema.String, Schema.Unknown)],
+);
+
+export type EncodedRejection = typeof EncodedRejection.Type;
+
+const decodeCarrier = Schema.decodeUnknownOption(Schema.Struct({ data: Schema.Struct({ rejection: EncodedRejection }) }));
+
+export const rejectionOf = (error: unknown): Option.Option<EncodedRejection> => Option.map(decodeCarrier(error), ({ data }) => data.rejection);
+
+export const decodeRejection = <S extends Schema.ConstraintDecoder<{ readonly _tag: string }>>(
+	schema: S,
+): ((error: unknown) => Option.Option<S["Type"]>) => {
+	const decode = Schema.decodeUnknownOption(schema);
+	return (error) => Option.flatMap(rejectionOf(error), (rejection) => decode(rejection));
+};

package/src/client.ts

@@ -0,0 +1 @@
+export { decodeRejection, type EncodedRejection, rejectionOf } from "./client/rejection.ts";

package/src/errors.ts

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

package/src/index.ts

@@ -3,7 +3,8 @@ export {
 	type EffectTRPCRuntime,
 	type MakeEffectTRPCOptions,
 	makeEffectTRPC,
-} from "./adapter.js";
+} from "./adapter.ts";
+export type { EncodedRejection } from "./client/rejection.ts";
 export {
 	badRequest,
 	conflict,
@@ -13,14 +14,16 @@ export {
 	notFound,
 	preconditionFailed,
 	unauthorized,
-} from "./errors.js";
-export type { EffectProcedureBuilder } from "./procedure.js";
+} from "./errors.ts";
+export type { EffectProcedureBuilder } from "./procedure.ts";
+export { RejectionError, type RejectWithOptions, rejectionCode, rejectWith } from "./rejection.ts";
+export { type RejectionData, type RejectionErrorShape, rejectionFormatter, withRejection } from "./rejection-formatter.ts";
 export {
 	type EffectProcedureRequestServices,
 	extendRequestServices,
 	makeRequestServices,
-} from "./request-services.js";
-export { RequestSignal } from "./request-signal.js";
+} from "./request-services.ts";
+export { RequestSignal } from "./request-signal.ts";
 export type {
 	EffectTRPCErrorContext,
 	EffectTRPCErrorMapper,
@@ -28,4 +31,4 @@ export type {
 	EffectTRPCStreamInstrument,
 	ProcedureInfo,
 	ProcedureKind,
-} from "./types.js";
+} from "./types.ts";

package/src/internal/context-bridge.ts

@@ -3,20 +3,14 @@ import type { Context } from "effect";
 
 export interface ContextBridge {
 	readonly current: () => Context.Context<never> | undefined;
-	readonly run: <Services, Value>(
-		services: Context.Context<Services>,
-		evaluate: () => Value,
-	) => Value;
+	readonly run: <Services, Value>(services: Context.Context<Services>, evaluate: () => Value) => Value;
 }
 
 export const makeContextBridge = (shared?: {
 	readonly currentServices?: ContextBridge["current"];
 	readonly runWithServices?: ContextBridge["run"];
 }): ContextBridge => {
-	if (
-		shared?.currentServices !== undefined &&
-		shared.runWithServices !== undefined
-	) {
+	if (shared?.currentServices !== undefined && shared.runWithServices !== undefined) {
 		return {
 			current: shared.currentServices,
 			run: shared.runWithServices,
@@ -27,7 +21,6 @@ export const makeContextBridge = (shared?: {
 
 	return {
 		current: () => storage.getStore(),
-		run: (services, evaluate) =>
-			storage.run(services as Context.Context<never>, evaluate),
+		run: (services, evaluate) => storage.run(services, evaluate),
 	};
 };

package/src/internal/loose.ts

@@ -0,0 +1,14 @@
+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-handler.ts

@@ -1,45 +1,22 @@
 import { Effect } from "effect";
-import type { EffectProcedureRequestServices } from "../request-services.js";
-import type { ProcedureInfo } from "../types.js";
-import type { EffectProcedureResolver } from "./procedure-types.js";
-import type { RuntimeBridge } from "./runtime.js";
+import type { EffectProcedureRequestServices } from "../request-services.ts";
+import type { ProcedureInfo } from "../types.ts";
+import { acceptParsedInput } from "./loose.ts";
+import type { EffectProcedureResolver, ProcedureInvocation } from "./procedure-types.ts";
+import type { RuntimeBridge } from "./runtime.ts";
 
-interface ProcedureInvocation<Context, Input> {
-	readonly ctx: Context;
-	readonly input: Input;
-	readonly path: string;
-	readonly signal?: AbortSignal;
-}
-
-export const makeProcedureHandler = <
-	RuntimeRequirements,
-	Context,
-	Input,
-	ProvidedServices,
-	LayerError,
-	Output,
->(
+export const makeProcedureHandler = <RuntimeRequirements, Context, ProvidedServices, LayerError>(
 	runtime: RuntimeBridge<RuntimeRequirements>,
-	resolver: EffectProcedureResolver<
-		Input,
-		ProvidedServices | NoInfer<RuntimeRequirements>,
-		Output
-	>,
-	requestServices: EffectProcedureRequestServices<
-		Context,
-		ProvidedServices,
-		LayerError
-	>,
+	resolver: EffectProcedureResolver<never, ProvidedServices | NoInfer<RuntimeRequirements>, unknown>,
+	requestServices: EffectProcedureRequestServices<Context, ProvidedServices, LayerError>,
 	procedure: Omit<ProcedureInfo, "path">,
 ) => {
-	const tracedResolver = Effect.fnUntraced(resolver);
+	const tracedResolver = Effect.fnUntraced(acceptParsedInput(resolver));
 
-	return async (invocation: ProcedureInvocation<Context, Input>) => {
+	return async (invocation: ProcedureInvocation<Context>) => {
 		const info = { ...procedure, path: invocation.path };
 		const provided = Effect.suspend(() =>
-			runtime
-				.instrument(tracedResolver(invocation.input), info)
-				.pipe(Effect.provide(requestServices.layer(invocation.ctx))),
+			runtime.instrument(tracedResolver(invocation.input), info).pipe(Effect.provide(requestServices.layer(invocation.ctx))),
 		);
 		return await runtime.runEffect(provided, {
 			procedure: info,

package/src/internal/procedure-types.ts

@@ -1,57 +1,44 @@
-import type {
-	inferProcedureBuilderResolverOptions,
-	TRPCProcedureBuilder,
-	TRPCUnsetMarker,
-} from "@trpc/server";
-import type { Effect, Stream } from "effect";
-
-export type AnyProcedureBuilder = TRPCProcedureBuilder<
-	// biome-ignore lint/suspicious/noExplicitAny: tRPC phantom slot extraction
-	any,
-	// biome-ignore lint/suspicious/noExplicitAny: tRPC phantom slot extraction
-	any,
-	// biome-ignore lint/suspicious/noExplicitAny: tRPC phantom slot extraction
-	any,
-	// biome-ignore lint/suspicious/noExplicitAny: tRPC phantom slot extraction
-	any,
-	// biome-ignore lint/suspicious/noExplicitAny: tRPC phantom slot extraction
-	any,
-	// biome-ignore lint/suspicious/noExplicitAny: tRPC phantom slot extraction
-	any,
-	// biome-ignore lint/suspicious/noExplicitAny: tRPC phantom slot extraction
-	any,
+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<Builder extends AnyProcedureBuilder> =
-	inferProcedureBuilderResolverOptions<Builder>["ctx"];
-
-export type ProcedureEffect<Requirements> = Effect.Effect<
-	// biome-ignore lint/suspicious/noExplicitAny: success is inferred from each yielded Effect
-	any,
-	// biome-ignore lint/suspicious/noExplicitAny: errors are inferred from each yielded Effect
-	any,
-	Requirements
->;
+export type DefaultValue<Value, Fallback> = Value extends TRPCUnsetMarker ? Fallback : Value;
 
-export type EffectProcedureResolver<Input, Requirements, Output> = (
-	input: Input,
-) => Generator<ProcedureEffect<Requirements>, Output, never>;
+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
->;
+) => 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>;
+	output(schema: StandardSchema.StandardSchemaV1): ProcedureBuilderSurface<Context>;
+	query(resolver: (invocation: ProcedureInvocation<Context>) => Promise<unknown>): unknown;
+	mutation(resolver: (invocation: ProcedureInvocation<Context>) => Promise<unknown>): unknown;
+	subscription(resolver: (invocation: ProcedureInvocation<Context>) => Promise<AsyncIterable<unknown, void, unknown>>): unknown;
+}

package/src/internal/runtime.ts

@@ -1,12 +1,8 @@
 import { TRPCError } from "@trpc/server";
 import { Cause, Context, Effect, Exit, Option, Result, Stream } from "effect";
-import type { EffectTRPCRuntime } from "../adapter.js";
-import type {
-	EffectTRPCErrorMapper,
-	EffectTRPCInstrument,
-	ProcedureInfo,
-} from "../types.js";
-import type { ContextBridge } from "./context-bridge.js";
+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;
@@ -15,14 +11,8 @@ interface RunEffectOptions {
 
 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>>;
+	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 =>
@@ -43,19 +33,13 @@ const mapError = (
 	}
 
 	try {
-		return (
-			consumerMapper?.(error, { ...procedure, origin }) ?? internalError(error)
-		);
+		return consumerMapper?.(error, { ...procedure, origin }) ?? internalError(error);
 	} catch (mapperDefect) {
 		return internalError(mapperDefect);
 	}
 };
 
-const mapCause = (
-	cause: Cause.Cause<unknown>,
-	procedure: ProcedureInfo,
-	consumerMapper: EffectTRPCErrorMapper | undefined,
-): TRPCError => {
+const mapCause = (cause: Cause.Cause<unknown>, procedure: ProcedureInfo, consumerMapper: EffectTRPCErrorMapper | undefined): TRPCError => {
 	if (Cause.hasInterruptsOnly(cause)) {
 		return new TRPCError({
 			code: "CLIENT_CLOSED_REQUEST",
@@ -94,21 +78,14 @@ export const makeRuntimeBridge = <Requirements, RuntimeError>(
 	contextBridge: ContextBridge,
 	options: {
 		readonly instrument?: EffectTRPCInstrument;
-		readonly instrumentStream?: import("../types.js").EffectTRPCStreamInstrument;
+		readonly instrumentStream?: import("../types.ts").EffectTRPCStreamInstrument;
 		readonly mapError?: EffectTRPCErrorMapper;
 	},
 ): RuntimeBridge<Requirements> => ({
-	instrument: (effect, procedure) =>
-		Effect.suspend(() =>
-			options.instrument === undefined
-				? effect
-				: options.instrument(effect, procedure),
-		),
+	instrument: (effect, procedure) => Effect.suspend(() => (options.instrument === undefined ? effect : options.instrument(effect, procedure))),
 	runStream: async (stream, runOptions) => {
 		const instrumented = Stream.suspend(() =>
-			options.instrumentStream === undefined
-				? stream
-				: options.instrumentStream(stream, runOptions.procedure),
+			options.instrumentStream === undefined ? stream : options.instrumentStream(stream, runOptions.procedure),
 		).pipe(
 			Stream.withSpan(runOptions.procedure.path, {
 				attributes: {
@@ -119,14 +96,11 @@ export const makeRuntimeBridge = <Requirements, RuntimeError>(
 				captureStackTrace: runOptions.procedure.captureStackTrace,
 			}),
 			Stream.interruptWhen(interruptOn(runOptions.signal)),
-			Stream.catchCause((cause) =>
-				Stream.fail(mapCause(cause, runOptions.procedure, options.mapError)),
-			),
+			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);
+		const provided = ambient === undefined ? context : Context.merge(context, ambient);
 		return Stream.toAsyncIterableWith(instrumented, provided);
 	},
 	runEffect: async (effect, runOptions) => {
@@ -147,17 +121,8 @@ export const makeRuntimeBridge = <Requirements, RuntimeError>(
 		);
 		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 },
-		);
+			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;

package/src/internal/subscription-handler.ts

@@ -1,59 +1,27 @@
 import { Effect, Layer, Schema, Stream } from "effect";
-import type { EffectProcedureRequestServices } from "../request-services.js";
-import { RequestSignal } from "../request-signal.js";
-import type { ProcedureInfo } from "../types.js";
-import type { EffectSubscriptionResolver } from "./procedure-types.js";
-import type { RuntimeBridge } from "./runtime.js";
+import type { EffectProcedureRequestServices } from "../request-services.ts";
+import { RequestSignal } from "../request-signal.ts";
+import type { ProcedureInfo } from "../types.ts";
+import { acceptParsedInput } from "./loose.ts";
+import type { EffectSubscriptionResolver, ProcedureInvocation } from "./procedure-types.ts";
+import type { RuntimeBridge } from "./runtime.ts";
 
-interface SubscriptionInvocation<Context, Input> {
-	readonly ctx: Context;
-	readonly input: Input;
-	readonly path: string;
-	readonly signal?: AbortSignal;
-}
-
-export const makeSubscriptionHandler = <
-	RuntimeRequirements,
-	Context,
-	Input,
-	ProvidedServices,
-	LayerError,
-	Output,
->(
+export const makeSubscriptionHandler = <RuntimeRequirements, Context, ProvidedServices, LayerError>(
 	runtime: RuntimeBridge<RuntimeRequirements>,
-	resolver: EffectSubscriptionResolver<
-		Input,
-		ProvidedServices | NoInfer<RuntimeRequirements>,
-		Output
-	>,
-	requestServices: EffectProcedureRequestServices<
-		Context,
-		ProvidedServices,
-		LayerError
-	>,
+	resolver: EffectSubscriptionResolver<never, ProvidedServices | NoInfer<RuntimeRequirements>, unknown>,
+	requestServices: EffectProcedureRequestServices<Context, ProvidedServices, LayerError>,
 	procedure: Omit<ProcedureInfo, "path">,
 	outputSchema?: Schema.ConstraintDecoder<unknown>,
 ) => {
-	const tracedResolver = Effect.fnUntraced(resolver);
+	const tracedResolver = Effect.fnUntraced(acceptParsedInput(resolver));
 
-	return async (invocation: SubscriptionInvocation<Context, Input>) => {
+	return async (invocation: ProcedureInvocation<Context>) => {
 		const info = { ...procedure, path: invocation.path };
-		const requestLayer = Layer.merge(
-			requestServices.layer(invocation.ctx),
-			Layer.succeed(RequestSignal, invocation.signal),
-		);
-		let stream = Stream.unwrap(
-			Effect.suspend(() =>
-				runtime.instrument(tracedResolver(invocation.input), info),
-			),
-		).pipe(Stream.provide(requestLayer));
-		if (outputSchema !== undefined) {
-			stream = Stream.mapEffect(stream, (value) =>
-				Schema.decodeUnknownEffect(outputSchema)(value),
-			) as typeof stream;
-		}
+		const requestLayer = Layer.merge(requestServices.layer(invocation.ctx), Layer.succeed(RequestSignal, invocation.signal));
+		const stream = Stream.unwrap(Effect.suspend(() => runtime.instrument(tracedResolver(invocation.input), info))).pipe(Stream.provide(requestLayer));
+		const decoded = outputSchema === undefined ? stream : Stream.mapEffect(stream, (value) => Schema.decodeUnknownEffect(outputSchema)(value));
 
-		return await runtime.runStream(stream, {
+		return await runtime.runStream(decoded, {
 			procedure: info,
 			...(invocation.signal === undefined ? {} : { signal: invocation.signal }),
 		});