@shivaedev/effect-trpc 0.6.0 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shivaedev/effect-trpc",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Effect-native procedures and testing for tRPC",
   "homepage": "https://github.com/ShivaeDev/platform/tree/main/packages/effect-trpc#readme",
   "bugs": {
@@ -15,49 +15,225 @@
   "sideEffects": false,
   "type": "module",
   "imports": {
-    "#test/*": "./test/*",
+    "#test/*": "./src/test-support/*",
     "#*.ts": {
       "source": "./src/*.ts",
       "types": "./dist/*.d.ts",
       "default": "./dist/*.js"
+    },
+    "#adapter.ts": {
+      "source": "./src/server/adapter.ts",
+      "types": "./dist/server/adapter.d.ts",
+      "default": "./dist/server/adapter.js"
+    },
+    "#errors.ts": {
+      "source": "./src/server/errors.ts",
+      "types": "./dist/server/errors.d.ts",
+      "default": "./dist/server/errors.js"
+    },
+    "#internal/context-bridge.ts": {
+      "source": "./src/server/internal/contextBridge.ts",
+      "types": "./dist/server/internal/contextBridge.d.ts",
+      "default": "./dist/server/internal/contextBridge.js"
+    },
+    "#internal/loose.ts": {
+      "source": "./src/server/internal/loose.ts",
+      "types": "./dist/server/internal/loose.d.ts",
+      "default": "./dist/server/internal/loose.js"
+    },
+    "#internal/procedure-handler.ts": {
+      "source": "./src/server/internal/makeProcedureHandler.ts",
+      "types": "./dist/server/internal/makeProcedureHandler.d.ts",
+      "default": "./dist/server/internal/makeProcedureHandler.js"
+    },
+    "#internal/procedure-types.ts": {
+      "source": "./src/server/internal/procedureTypes.ts",
+      "types": "./dist/server/internal/procedureTypes.d.ts",
+      "default": "./dist/server/internal/procedureTypes.js"
+    },
+    "#internal/runtime.ts": {
+      "source": "./src/server/internal/runtime.ts",
+      "types": "./dist/server/internal/runtime.d.ts",
+      "default": "./dist/server/internal/runtime.js"
+    },
+    "#internal/stack-trace.ts": {
+      "source": "./src/server/internal/captureStackTrace.ts",
+      "types": "./dist/server/internal/captureStackTrace.d.ts",
+      "default": "./dist/server/internal/captureStackTrace.js"
+    },
+    "#internal/subscription-handler.ts": {
+      "source": "./src/server/internal/makeSubscriptionHandler.ts",
+      "types": "./dist/server/internal/makeSubscriptionHandler.d.ts",
+      "default": "./dist/server/internal/makeSubscriptionHandler.js"
+    },
+    "#procedure.ts": {
+      "source": "./src/server/EffectProcedureBuilder.ts",
+      "types": "./dist/server/EffectProcedureBuilder.d.ts",
+      "default": "./dist/server/EffectProcedureBuilder.js"
+    },
+    "#rejection-formatter.ts": {
+      "source": "./src/server/rejectionFormatter.ts",
+      "types": "./dist/server/rejectionFormatter.d.ts",
+      "default": "./dist/server/rejectionFormatter.js"
+    },
+    "#rejection.ts": {
+      "source": "./src/server/rejection.ts",
+      "types": "./dist/server/rejection.d.ts",
+      "default": "./dist/server/rejection.js"
+    },
+    "#request-services.ts": {
+      "source": "./src/server/requestServices.ts",
+      "types": "./dist/server/requestServices.d.ts",
+      "default": "./dist/server/requestServices.js"
+    },
+    "#request-signal.ts": {
+      "source": "./src/server/RequestSignal.ts",
+      "types": "./dist/server/RequestSignal.d.ts",
+      "default": "./dist/server/RequestSignal.js"
+    },
+    "#testing/any-test-layer.ts": {
+      "source": "./src/server/testing/AnyTestLayer.ts",
+      "types": "./dist/server/testing/AnyTestLayer.d.ts",
+      "default": "./dist/server/testing/AnyTestLayer.js"
+    },
+    "#testing/caller.ts": {
+      "source": "./src/server/testing/caller.ts",
+      "types": "./dist/server/testing/caller.d.ts",
+      "default": "./dist/server/testing/caller.js"
+    },
+    "#testing/types.ts": {
+      "source": "./src/server/testing/types.ts",
+      "types": "./dist/server/testing/types.d.ts",
+      "default": "./dist/server/testing/types.js"
+    },
+    "#testing/vitest.ts": {
+      "source": "./src/server/testing/vitest.ts",
+      "types": "./dist/server/testing/vitest.d.ts",
+      "default": "./dist/server/testing/vitest.js"
+    },
+    "#types.ts": {
+      "source": "./src/server/types.ts",
+      "types": "./dist/server/types.d.ts",
+      "default": "./dist/server/types.js"
     }
   },
   "exports": {
-    "./*.ts": {
-      "types": "./dist/*.d.ts",
-      "source": "./src/*.ts",
-      "import": "./dist/*.js",
-      "default": "./dist/*.js"
+    "./package.json": "./package.json",
+    "./client/rejection.ts": {
+      "types": "./dist/rejectionDecoding.d.ts",
+      "source": "./src/rejectionDecoding.ts",
+      "import": "./dist/rejectionDecoding.js",
+      "default": "./dist/rejectionDecoding.js"
+    },
+    "./adapter.ts": {
+      "types": "./dist/server/adapter.d.ts",
+      "source": "./src/server/adapter.ts",
+      "import": "./dist/server/adapter.js",
+      "default": "./dist/server/adapter.js"
+    },
+    "./errors.ts": {
+      "types": "./dist/server/errors.d.ts",
+      "source": "./src/server/errors.ts",
+      "import": "./dist/server/errors.js",
+      "default": "./dist/server/errors.js"
+    },
+    "./procedure.ts": {
+      "types": "./dist/server/EffectProcedureBuilder.d.ts",
+      "source": "./src/server/EffectProcedureBuilder.ts",
+      "import": "./dist/server/EffectProcedureBuilder.js",
+      "default": "./dist/server/EffectProcedureBuilder.js"
+    },
+    "./rejection-formatter.ts": {
+      "types": "./dist/server/rejectionFormatter.d.ts",
+      "source": "./src/server/rejectionFormatter.ts",
+      "import": "./dist/server/rejectionFormatter.js",
+      "default": "./dist/server/rejectionFormatter.js"
+    },
+    "./rejection.ts": {
+      "types": "./dist/server/rejection.d.ts",
+      "source": "./src/server/rejection.ts",
+      "import": "./dist/server/rejection.js",
+      "default": "./dist/server/rejection.js"
     },
-    "./internal/*": null,
-    "./package.json": "./package.json"
+    "./rejectionDecoding.ts": {
+      "types": "./dist/rejectionDecoding.d.ts",
+      "source": "./src/rejectionDecoding.ts",
+      "import": "./dist/rejectionDecoding.js",
+      "default": "./dist/rejectionDecoding.js"
+    },
+    "./request-services.ts": {
+      "types": "./dist/server/requestServices.d.ts",
+      "source": "./src/server/requestServices.ts",
+      "import": "./dist/server/requestServices.js",
+      "default": "./dist/server/requestServices.js"
+    },
+    "./request-signal.ts": {
+      "types": "./dist/server/RequestSignal.d.ts",
+      "source": "./src/server/RequestSignal.ts",
+      "import": "./dist/server/RequestSignal.js",
+      "default": "./dist/server/RequestSignal.js"
+    },
+    "./testing/any-test-layer.ts": {
+      "types": "./dist/server/testing/AnyTestLayer.d.ts",
+      "source": "./src/server/testing/AnyTestLayer.ts",
+      "import": "./dist/server/testing/AnyTestLayer.js",
+      "default": "./dist/server/testing/AnyTestLayer.js"
+    },
+    "./testing/caller.ts": {
+      "types": "./dist/server/testing/caller.d.ts",
+      "source": "./src/server/testing/caller.ts",
+      "import": "./dist/server/testing/caller.js",
+      "default": "./dist/server/testing/caller.js"
+    },
+    "./testing/types.ts": {
+      "types": "./dist/server/testing/types.d.ts",
+      "source": "./src/server/testing/types.ts",
+      "import": "./dist/server/testing/types.js",
+      "default": "./dist/server/testing/types.js"
+    },
+    "./testing/vitest.ts": {
+      "types": "./dist/server/testing/vitest.d.ts",
+      "source": "./src/server/testing/vitest.ts",
+      "import": "./dist/server/testing/vitest.js",
+      "default": "./dist/server/testing/vitest.js"
+    },
+    "./types.ts": {
+      "types": "./dist/server/types.d.ts",
+      "source": "./src/server/types.ts",
+      "import": "./dist/server/types.js",
+      "default": "./dist/server/types.js"
+    }
   },
   "files": [
     "dist",
     "src",
+    "!src/**/*.test.ts",
+    "!src/**/*.spec.ts",
+    "!src/**/test-support",
     "CHANGELOG.md",
+    "docs",
     "README.md"
   ],
   "dependencies": {
-    "@shivaedev/effect-test": "0.2.0"
+    "@shivaedev/effect-test": "0.4.0"
   },
   "devDependencies": {
-    "@effect/vitest": "4.0.0-rc.112",
-    "@shivaedev/effect-contract": "0.3.0",
-    "@shivaedev/quality": "0.9.0",
-    "@trpc/client": "11.18.0",
-    "@trpc/server": "11.18.0",
-    "@types/node": "24.10.1",
+    "@effect/vitest": "4.0.4",
+    "@shivaedev/effect-contract": "0.5.0",
+    "@shivaedev/quality": "0.20.0",
+    "@trpc/client": "11.19.0",
+    "@trpc/server": "11.19.0",
+    "@types/node": "24.19.1",
     "@typescript/native": "npm:typescript@7.0.2",
-    "effect": "4.0.0-rc.112",
+    "effect": "4.0.4",
     "superjson": "2.2.6",
     "typescript": "npm:@typescript/typescript6@6.0.2",
-    "vitest": "4.1.9"
+    "vitest": "5.0.3"
   },
   "peerDependencies": {
-    "@effect/vitest": "4.0.0-rc.112",
-    "@trpc/server": "11.18.0",
-    "effect": "4.0.0-rc.112"
+    "@effect/vitest": "4.0.4",
+    "@trpc/server": "11.19.0",
+    "effect": "4.0.4"
   },
   "peerDependenciesMeta": {
     "@effect/vitest": {
@@ -72,7 +248,7 @@
     "provenance": true
   },
   "scripts": {
-    "build": "node --eval \"import('node:fs').then(({ rmSync }) => rmSync('dist', { force: true, recursive: true }))\" && tsc6 --project tsconfig.build.json",
+    "build": "node --eval \"import('node:fs').then(({ rmSync }) => rmSync('dist', { force: true, recursive: true }))\" && tsc --project tsconfig.build.json",
     "ready": "pnpm typecheck && pnpm test && pnpm build",
     "test": "vitest run",
     "typecheck": "tsc --noEmit"

package/src/{client/rejection.ts → rejectionDecoding.ts}

@@ -9,11 +9,13 @@ 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 function rejectionOf(error: unknown): Option.Option<EncodedRejection> {
+	return 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"]>) => {
+export function decodeRejection<TSchema extends Schema.ConstraintDecoder<{ readonly _tag: string }>>(
+	schema: TSchema,
+): (error: unknown) => Option.Option<TSchema["Type"]> {
 	const decode = Schema.decodeUnknownOption(schema);
 	return (error) => Option.flatMap(rejectionOf(error), (rejection) => decode(rejection));
-};
+}

package/src/server/EffectProcedureBuilder.ts

@@ -0,0 +1,134 @@
+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 "./requestServices.ts";
+
+interface ProcedureParts<TContext, TMeta, TContextOverrides, TProvidedServices, TLayerError, TRuntimeRequirements> {
+	readonly builder: ProcedureBuilderSurface<ResolverContext<TContext, TMeta, TContextOverrides>>;
+	readonly requestServices: EffectProcedureRequestServices<ResolverContext<TContext, TMeta, TContextOverrides>, TProvidedServices, TLayerError>;
+	readonly runtime: RuntimeBridge<TRuntimeRequirements>;
+	readonly subscriptionBuilder: ProcedureBuilderSurface<ResolverContext<TContext, TMeta, TContextOverrides>>;
+	readonly subscriptionOutput?: Schema.ConstraintDecoder<unknown> | undefined;
+}
+export class EffectProcedureBuilder<
+	TContext,
+	TMeta,
+	TContextOverrides,
+	TInputIn,
+	TInputOut,
+	TOutputIn,
+	TOutputOut,
+	TProvidedServices,
+	TLayerError,
+	TRuntimeRequirements,
+> {
+	readonly #parts: ProcedureParts<TContext, TMeta, TContextOverrides, TProvidedServices, TLayerError, TRuntimeRequirements>;
+	constructor(parts: ProcedureParts<TContext, TMeta, TContextOverrides, TProvidedServices, TLayerError, TRuntimeRequirements>) {
+		this.#parts = parts;
+	}
+	input<TSchemaValue extends Schema.ConstraintDecoder<unknown>>(
+		schema: TSchemaValue,
+	): EffectProcedureBuilder<
+		TContext,
+		TMeta,
+		TContextOverrides,
+		IntersectIfDefined<TInputIn, TSchemaValue["Encoded"]>,
+		IntersectIfDefined<TInputOut, TSchemaValue["Type"]>,
+		TOutputIn,
+		TOutputOut,
+		TProvidedServices,
+		TLayerError,
+		TRuntimeRequirements
+	> {
+		const parser = Schema.toStandardSchemaV1(schema);
+		return new EffectProcedureBuilder({
+			...this.#parts,
+			builder: this.#parts.builder.input(parser),
+			subscriptionBuilder: this.#parts.subscriptionBuilder.input(parser),
+		});
+	}
+	output<TSchemaValue extends Schema.ConstraintDecoder<unknown>>(
+		schema: TSchemaValue,
+	): EffectProcedureBuilder<
+		TContext,
+		TMeta,
+		TContextOverrides,
+		TInputIn,
+		TInputOut,
+		IntersectIfDefined<TOutputIn, TSchemaValue["Encoded"]>,
+		IntersectIfDefined<TOutputOut, TSchemaValue["Type"]>,
+		TProvidedServices,
+		TLayerError,
+		TRuntimeRequirements
+	> {
+		return new EffectProcedureBuilder({
+			...this.#parts,
+			builder: this.#parts.builder.output(Schema.toStandardSchemaV1(schema)),
+			subscriptionOutput: schema,
+		});
+	}
+	query<TOutput>(
+		resolver: EffectProcedureResolver<
+			DefaultValue<TInputOut, undefined>,
+			TProvidedServices | NoInfer<TRuntimeRequirements>,
+			DefaultValue<TOutputIn, TOutput>
+		>,
+	): TRPCQueryProcedure<{
+		input: DefaultValue<TInputIn, void>;
+		output: DefaultValue<TOutputOut, TOutput>;
+		meta: TMeta;
+	}>;
+	query(resolver: EffectProcedureResolver<never, TProvidedServices | TRuntimeRequirements, unknown>): unknown {
+		return this.#parts.builder.query(this.#handler("query", resolver));
+	}
+	mutation<TOutput>(
+		resolver: EffectProcedureResolver<
+			DefaultValue<TInputOut, undefined>,
+			TProvidedServices | NoInfer<TRuntimeRequirements>,
+			DefaultValue<TOutputIn, TOutput>
+		>,
+	): TRPCMutationProcedure<{
+		input: DefaultValue<TInputIn, void>;
+		output: DefaultValue<TOutputOut, TOutput>;
+		meta: TMeta;
+	}>;
+	mutation(resolver: EffectProcedureResolver<never, TProvidedServices | TRuntimeRequirements, unknown>): unknown {
+		return this.#parts.builder.mutation(this.#handler("mutation", resolver));
+	}
+	subscription<TOutput>(
+		resolver: EffectSubscriptionResolver<
+			DefaultValue<TInputOut, undefined>,
+			TProvidedServices | NoInfer<TRuntimeRequirements>,
+			DefaultValue<TOutputIn, TOutput>
+		>,
+	): TRPCSubscriptionProcedure<{
+		input: DefaultValue<TInputIn, void>;
+		output: AsyncIterable<DefaultValue<TOutputOut, TOutput>, void, unknown>;
+		meta: TMeta;
+	}>;
+	subscription(resolver: EffectSubscriptionResolver<never, TProvidedServices | TRuntimeRequirements, unknown>): unknown {
+		return this.#parts.subscriptionBuilder.subscription(
+			makeSubscriptionHandler(
+				this.#parts.runtime,
+				resolver,
+				this.#parts.requestServices,
+				{ captureStackTrace: captureStackTrace(), type: "subscription" },
+				this.#parts.subscriptionOutput,
+			),
+		);
+	}
+	#handler(type: "mutation" | "query", resolver: EffectProcedureResolver<never, TProvidedServices | TRuntimeRequirements, unknown>) {
+		return makeProcedureHandler(this.#parts.runtime, resolver, this.#parts.requestServices, { captureStackTrace: captureStackTrace(), type });
+	}
+}

package/src/{request-signal.ts → server/RequestSignal.ts}

@@ -1,3 +1,2 @@
 import { Context } from "effect";
-
 export const RequestSignal = Context.Reference<AbortSignal | undefined>("@shivaedev/effect-trpc/RequestSignal", { defaultValue: () => undefined });

package/src/server/adapter.ts

@@ -0,0 +1,83 @@
+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 "./EffectProcedureBuilder.ts";
+import type { EffectProcedureRequestServices } from "./requestServices.ts";
+import type { EffectTRPCErrorMapper, EffectTRPCInstrument, EffectTRPCStreamInstrument } from "./types.ts";
+
+export interface MakeEffectTRPCOptions<TRequirements, TRuntimeError> {
+	readonly instrument?: EffectTRPCInstrument;
+	readonly instrumentStream?: EffectTRPCStreamInstrument;
+	readonly mapError?: EffectTRPCErrorMapper;
+	readonly runtime: EffectTRPCRuntime<TRequirements, TRuntimeError>;
+}
+export interface EffectTRPCRuntime<TRequirements, TRuntimeError> {
+	readonly contextEffect: Effect.Effect<Context.Context<TRequirements>, TRuntimeError>;
+	readonly currentServices?: () => Context.Context<never> | undefined;
+	readonly runPromise: <TValue, TError>(
+		effect: Effect.Effect<TValue, TError, TRequirements>,
+		options?: {
+			readonly signal?: AbortSignal;
+		},
+	) => Promise<TValue>;
+	readonly runPromiseExit: <TValue, TError>(
+		effect: Effect.Effect<TValue, TError, TRequirements>,
+		options?: {
+			readonly signal?: AbortSignal;
+		},
+	) => Promise<Exit.Exit<TValue, TError | TRuntimeError>>;
+	readonly runWithServices?: <TServices, TValue>(services: Context.Context<TServices>, evaluate: () => TValue) => TValue;
+}
+export interface EffectTRPCAdapter<TRequirements> {
+	readonly procedure: <TContext, TMeta, TContextOverrides, TInputIn, TInputOut, TOutputIn, TOutputOut, TProvidedServices, TLayerError>(
+		builder: TRPCProcedureBuilder<TContext, TMeta, TContextOverrides, TInputIn, TInputOut, TOutputIn, TOutputOut, false>,
+		requestServices: EffectProcedureRequestServices<ResolverContext<TContext, TMeta, TContextOverrides>, TProvidedServices, TLayerError>,
+	) => EffectProcedureBuilder<
+		TContext,
+		TMeta,
+		TContextOverrides,
+		TInputIn,
+		TInputOut,
+		TOutputIn,
+		TOutputOut,
+		TProvidedServices,
+		TLayerError,
+		TRequirements
+	>;
+	readonly runWithServices: <TServices, TValue>(services: Context.Context<TServices>, evaluate: () => TValue) => TValue;
+}
+export function makeEffectTRPC<TRequirements, TRuntimeError = never>(
+	options: MakeEffectTRPCOptions<TRequirements, TRuntimeError>,
+): EffectTRPCAdapter<TRequirements> {
+	const contextBridge = makeContextBridge(options.runtime);
+	const runtime = makeRuntimeBridge(options.runtime, contextBridge, options);
+	return {
+		procedure: <TContext, TMeta, TContextOverrides, TInputIn, TInputOut, TOutputIn, TOutputOut, TProvidedServices, TLayerError>(
+			builder: TRPCProcedureBuilder<TContext, TMeta, TContextOverrides, TInputIn, TInputOut, TOutputIn, TOutputOut, false>,
+			requestServices: EffectProcedureRequestServices<ResolverContext<TContext, TMeta, TContextOverrides>, TProvidedServices, TLayerError>,
+		) => {
+			const loose = looseBuilder(builder);
+			return new EffectProcedureBuilder<
+				TContext,
+				TMeta,
+				TContextOverrides,
+				TInputIn,
+				TInputOut,
+				TOutputIn,
+				TOutputOut,
+				TProvidedServices,
+				TLayerError,
+				TRequirements
+			>({
+				builder: loose,
+				requestServices,
+				runtime,
+				subscriptionBuilder: loose,
+			});
+		},
+		runWithServices: contextBridge.run,
+	};
+}

package/src/server/errors.ts

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

package/src/{internal/stack-trace.ts → server/internal/captureStackTrace.ts}

@@ -1,9 +1,8 @@
-export const captureStackTrace = (): (() => string | undefined) => {
+export function captureStackTrace(): () => string | undefined {
 	const limit = Error.stackTraceLimit;
 	Error.stackTraceLimit = 3;
-	const traceError = new Error();
+	const traceError = new Error("Procedure definition");
 	Error.stackTraceLimit = limit;
-
 	let cache: false | string = false;
 	return () => {
 		if (cache !== false) {
@@ -16,4 +15,4 @@ export const captureStackTrace = (): (() => string | undefined) => {
 		}
 		return undefined;
 	};
-};
+}

package/src/{internal/context-bridge.ts → server/internal/contextBridge.ts}

@@ -1,26 +1,22 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 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: <TServices, TValue>(services: Context.Context<TServices>, evaluate: () => TValue) => TValue;
 }
-
-export const makeContextBridge = (shared?: {
+export function makeContextBridge(shared?: {
 	readonly currentServices?: ContextBridge["current"];
 	readonly runWithServices?: ContextBridge["run"];
-}): ContextBridge => {
+}): ContextBridge {
 	if (shared?.currentServices !== undefined && shared.runWithServices !== undefined) {
 		return {
 			current: shared.currentServices,
 			run: shared.runWithServices,
 		};
 	}
-
 	const storage = new AsyncLocalStorage<Context.Context<never>>();
-
 	return {
 		current: () => storage.getStore(),
 		run: (services, evaluate) => storage.run(services, evaluate),
 	};
-};
+}

package/src/server/internal/loose.ts

@@ -0,0 +1,12 @@
+import type { ProcedureBuilderOf, ProcedureBuilderSurface, ResolverContext } from "./procedureTypes.ts";
+export function looseBuilder<TContext, TMeta, TContextOverrides, TInputIn, TInputOut, TOutputIn, TOutputOut>(
+	builder: ProcedureBuilderOf<TContext, TMeta, TContextOverrides, TInputIn, TInputOut, TOutputIn, TOutputOut>,
+): ProcedureBuilderSurface<ResolverContext<TContext, TMeta, TContextOverrides>>;
+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<TResult>(resolver: (input: never) => TResult): (input: unknown) => TResult;
+export function acceptParsedInput(resolver: unknown): unknown {
+	return resolver;
+}

package/src/{internal/procedure-handler.ts → server/internal/makeProcedureHandler.ts}

@@ -2,18 +2,16 @@ import { Effect } from "effect";
 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 { EffectProcedureResolver, ProcedureInvocation } from "./procedureTypes.ts";
 import type { RuntimeBridge } from "./runtime.ts";
-
-export const makeProcedureHandler = <RuntimeRequirements, Context, ProvidedServices, LayerError>(
-	runtime: RuntimeBridge<RuntimeRequirements>,
-	resolver: EffectProcedureResolver<never, ProvidedServices | NoInfer<RuntimeRequirements>, unknown>,
-	requestServices: EffectProcedureRequestServices<Context, ProvidedServices, LayerError>,
+export function makeProcedureHandler<TRuntimeRequirements, TContext, TProvidedServices, TLayerError>(
+	runtime: RuntimeBridge<TRuntimeRequirements>,
+	resolver: EffectProcedureResolver<never, TProvidedServices | NoInfer<TRuntimeRequirements>, unknown>,
+	requestServices: EffectProcedureRequestServices<TContext, TProvidedServices, TLayerError>,
 	procedure: Omit<ProcedureInfo, "path">,
-) => {
+) {
 	const tracedResolver = Effect.fnUntraced(acceptParsedInput(resolver));
-
-	return async (invocation: ProcedureInvocation<Context>) => {
+	return async (invocation: ProcedureInvocation<TContext>) => {
 		const info = { ...procedure, path: invocation.path };
 		const provided = Effect.suspend(() =>
 			runtime.instrument(tracedResolver(invocation.input), info).pipe(Effect.provide(requestServices.layer(invocation.ctx))),
@@ -23,4 +21,4 @@ export const makeProcedureHandler = <RuntimeRequirements, Context, ProvidedServi
 			...(invocation.signal === undefined ? {} : { signal: invocation.signal }),
 		});
 	};
-};
+}