@shivaedev/platform 0.6.1 → 0.8.0

package/src/server/appHost.ts

@@ -1,23 +1,19 @@
-import { createServer } from "node:http";
-import { NodeHttpServer, NodeServices } from "@effect/platform-node";
-import * as PgClient from "@effect/sql-pg/PgClient";
-import { Config, Context, type Duration, Effect, Layer, Option, type Redacted } from "effect";
-import { HttpRouter, HttpServerRequest, HttpStaticServer } from "effect/unstable/http";
-import * as Reactivity from "effect/unstable/reactivity/Reactivity";
-import { type Rpc, type RpcGroup, RpcSerialization, RpcServer } from "effect/unstable/rpc";
-import type { Migrator } from "effect/unstable/sql";
-import { makeLiveServer } from "@shivaedev/effect-contract/makeLiveServer.ts";
-import { migratePostgres } from "@shivaedev/effect-sql/migrations.ts";
-import { type PostgresChangesOptions, postgresChanges } from "@shivaedev/effect-sql/postgresChanges.ts";
-import type { Authenticated, MaybeAuthenticated, RequestTracing } from "#rpc/middleware.ts";
-import { localRpcGuard } from "#rpc-server/local.ts";
-import { authenticatedLayer, maybeAuthenticatedLayer, type SessionPolicy, type SessionShape } from "#rpc-server/session.ts";
-import { requestTracingLayer } from "#rpc-server/tracing.ts";
+import { Context, type Duration, type Effect, type Redacted } from "effect";
+import type { Rpc } from "effect/rpc";
+import type { Migrator } from "effect/sql";
+import type { makeLiveServer } from "@shivaedev/effect-contract/makeLiveServer.ts";
+import type { PostgresChangesOptions } from "@shivaedev/effect-sql/postgresChanges.ts";
+import type { SessionPolicy, SessionShape } from "#rpc-server/session.ts";
+import { appHostHttp, migratedHost } from "./appHostHttp.ts";
+import { databaseLayer } from "./databaseLayer.ts";
+import type { HostOptions, HostPolicy } from "./hostOptions.ts";
+
 export class AppChanges extends Context.Service<AppChanges, Effect.Success<typeof makeLiveServer>>()("@shivaedev/platform/AppChanges") {}
 export interface AppDatabaseOptions<R = never> {
 	readonly config?: {
 		readonly databaseUrl?: Redacted.Redacted<string>;
 		readonly applicationName?: string;
+		readonly maxConnections?: number;
 		readonly changes?: Omit<PostgresChangesOptions, "client" | "resync">;
 	};
 	readonly migrations: {
@@ -26,33 +22,11 @@ export interface AppDatabaseOptions<R = never> {
 		readonly lockTimeout?: Duration.Input;
 	};
 }
+
 export function appDatabase<R>(options: AppDatabaseOptions<R>) {
-	const pool = Layer.unwrap(
-		Effect.gen(function* () {
-			const url = options.config?.databaseUrl ?? (yield* Config.redacted("DATABASE_URL"));
-			return PgClient.layer({
-				url,
-				...(options.config?.applicationName === undefined ? {} : { applicationName: options.config.applicationName }),
-			});
-		}),
-	);
-	const migrated = Layer.effectDiscard(migratePostgres({ ...options.migrations, lockTimeout: options.migrations.lockTimeout ?? "5 seconds" })).pipe(
-		Layer.provideMerge(pool),
-	);
-	const live = Layer.effect(AppChanges, makeLiveServer).pipe(Layer.provideMerge(Reactivity.layer));
-	const base = Layer.merge(migrated, live);
-	const changes = options.config?.changes;
-	if (changes === undefined) {
-		return base;
-	}
-	return Layer.unwrap(
-		Effect.gen(function* () {
-			const client = yield* PgClient.PgClient;
-			const hints = yield* AppChanges;
-			return postgresChanges({ ...changes, client, resync: hints.resync });
-		}),
-	).pipe(Layer.provideMerge(base));
+	return databaseLayer(options, AppChanges);
 }
+
 export interface AppHostOptions<
 	TRpcs extends Rpc.Any,
 	THandlers,
@@ -63,18 +37,77 @@ export interface AppHostOptions<
 	TServiceRequirements,
 	TMigrations,
 	TSession extends SessionShape,
-> extends AppDatabaseOptions<TMigrations> {
-	readonly assets?: string;
-	readonly config?: AppDatabaseOptions<TMigrations>["config"] & {
-		readonly port?: number;
-		readonly host?: string;
-		readonly trustedProxy?: string;
-	};
-	readonly group: RpcGroup.RpcGroup<TRpcs>;
-	readonly handlers: Layer.Layer<THandlers, THandlerError, THandlerRequirements>;
-	readonly services: Layer.Layer<TServices, TServiceError, TServiceRequirements>;
+> extends HostOptions<TRpcs, THandlers, THandlerError, THandlerRequirements, TServices, TServiceError, TServiceRequirements> {
+	readonly migrations: AppDatabaseOptions<TMigrations>["migrations"];
+	readonly policy?: undefined;
 	readonly sessions: SessionPolicy<TSession>;
 }
+
+export type AppLocalHostOptions<
+	TRpcs extends Rpc.Any,
+	THandlers,
+	THandlerError,
+	THandlerRequirements,
+	TServices,
+	TServiceError,
+	TServiceRequirements,
+	TMigrations,
+> = HostOptions<TRpcs, THandlers, THandlerError, THandlerRequirements, TServices, TServiceError, TServiceRequirements> & {
+	readonly migrations: AppDatabaseOptions<TMigrations>["migrations"];
+	readonly policy: "loopback";
+	readonly sessions?: never;
+};
+
+export type AppHttpHostOptions<
+	TRpcs extends Rpc.Any,
+	THandlers,
+	THandlerError,
+	THandlerRequirements,
+	TServices,
+	TServiceError,
+	TServiceRequirements,
+	TSession extends SessionShape,
+> = HostOptions<TRpcs, THandlers, THandlerError, THandlerRequirements, TServices, TServiceError, TServiceRequirements> &
+	HostPolicy<TSession> & { readonly migrations?: undefined };
+
+export function appHost<
+	TRpcs extends Rpc.Any,
+	THandlers,
+	THandlerError,
+	THandlerRequirements,
+	TServices,
+	TServiceError,
+	TServiceRequirements,
+	TMigrations,
+	TSession extends SessionShape,
+>(
+	options:
+		| AppHostOptions<TRpcs, THandlers, THandlerError, THandlerRequirements, TServices, TServiceError, TServiceRequirements, TMigrations, TSession>
+		| AppLocalHostOptions<TRpcs, THandlers, THandlerError, THandlerRequirements, TServices, TServiceError, TServiceRequirements, TMigrations>,
+): ReturnType<
+	typeof migratedHost<TRpcs, THandlers, THandlerError, THandlerRequirements, TServices, TServiceError, TServiceRequirements, TMigrations, TSession>
+>;
+export function appHost<TRpcs extends Rpc.Any, THandlers, THandlerError, THandlerRequirements, TServices, TServiceError, TServiceRequirements>(
+	options: HostOptions<TRpcs, THandlers, THandlerError, THandlerRequirements, TServices, TServiceError, TServiceRequirements> & {
+		readonly policy: "loopback";
+		readonly sessions?: never;
+		readonly migrations?: undefined;
+	},
+): ReturnType<
+	typeof appHostHttp<TRpcs, THandlers, THandlerError, THandlerRequirements, TServices, TServiceError, TServiceRequirements, SessionShape>
+>;
+export function appHost<
+	TRpcs extends Rpc.Any,
+	THandlers,
+	THandlerError,
+	THandlerRequirements,
+	TServices,
+	TServiceError,
+	TServiceRequirements,
+	TSession extends SessionShape,
+>(
+	options: AppHttpHostOptions<TRpcs, THandlers, THandlerError, THandlerRequirements, TServices, TServiceError, TServiceRequirements, TSession>,
+): ReturnType<typeof appHostHttp<TRpcs, THandlers, THandlerError, THandlerRequirements, TServices, TServiceError, TServiceRequirements, TSession>>;
 export function appHost<
 	TRpcs extends Rpc.Any,
 	THandlers,
@@ -86,49 +119,12 @@ export function appHost<
 	TMigrations,
 	TSession extends SessionShape,
 >(
-	options: AppHostOptions<
-		TRpcs,
-		THandlers,
-		THandlerError,
-		THandlerRequirements,
-		TServices,
-		TServiceError,
-		TServiceRequirements,
-		TMigrations,
-		TSession
-	>,
+	options:
+		| AppHostOptions<TRpcs, THandlers, THandlerError, THandlerRequirements, TServices, TServiceError, TServiceRequirements, TMigrations, TSession>
+		| AppLocalHostOptions<TRpcs, THandlers, THandlerError, THandlerRequirements, TServices, TServiceError, TServiceRequirements, TMigrations>
+		| AppHttpHostOptions<TRpcs, THandlers, THandlerError, THandlerRequirements, TServices, TServiceError, TServiceRequirements, TSession>,
 ) {
-	// Named middleware types keep NodeNext declarations on the package aliases.
-	const middleware: Layer.Layer<Authenticated | MaybeAuthenticated | RequestTracing> = Layer.mergeAll(
-		authenticatedLayer(options.sessions),
-		maybeAuthenticatedLayer(options.sessions),
-		requestTracingLayer(),
-	);
-	const routes = HttpRouter.use((router) =>
-		Effect.gen(function* () {
-			const trustedProxy = options.config?.trustedProxy ?? Option.getOrUndefined(yield* Config.string("TRUSTED_PROXY").pipe(Config.option));
-			const wire = yield* RpcSerialization.RpcSerialization;
-			const handler = yield* RpcServer.toHttpEffect(options.group);
-			yield* router.add("POST", "/rpc", (request) =>
-				localRpcGuard(handler, trustedProxy).pipe(
-					Effect.provideService(HttpServerRequest.HttpServerRequest, request),
-					Effect.provideService(RpcSerialization.RpcSerialization, wire),
-				),
-			);
-		}),
-	).pipe(Layer.provide(Layer.merge(options.handlers, middleware)), Layer.provide(RpcSerialization.layerNdjson));
-	const assets = options.assets === undefined ? Layer.empty : HttpStaticServer.layer({ root: options.assets });
-	const application = options.services.pipe(Layer.provideMerge(appDatabase(options)));
-	const server = Layer.unwrap(
-		Effect.gen(function* () {
-			const port = options.config?.port ?? (yield* Config.int("PORT").pipe(Config.withDefault(3000)));
-			const host = options.config?.host ?? (yield* Config.string("HOST").pipe(Config.withDefault("127.0.0.1")));
-			return NodeHttpServer.layer(createServer, { host, port });
-		}),
-	);
-	return HttpRouter.serve(Layer.merge(routes, assets), { disableLogger: true }).pipe(
-		Layer.provideMerge(application),
-		Layer.provideMerge(server),
-		Layer.provide(NodeServices.layer),
-	);
+	return options.migrations === undefined
+		? appHostHttp(options)
+		: migratedHost({ ...options, migrations: options.migrations }, appDatabase({ ...options, migrations: options.migrations }));
 }

package/src/server/appHostHttp.ts

@@ -0,0 +1,101 @@
+import { createServer } from "node:http";
+import { NodeHttpServer, NodeServices } from "@effect/platform-node";
+import { ByteSize, Config, Effect, Layer, Option, Schema } from "effect";
+import { HttpIncomingMessage, HttpRouter, HttpServerRequest, HttpStaticServer } from "effect/http";
+import { type Rpc, RpcSerialization, RpcServer } from "effect/rpc";
+import { localRpcGuard } from "#rpc-server/local.ts";
+import { authenticatedLayer, maybeAuthenticatedLayer, type SessionShape } from "#rpc-server/session.ts";
+import { requestTracingLayer } from "#rpc-server/tracing.ts";
+import { TrustedProxy } from "#rpc-server/trustedProxy.ts";
+import type { AppHostOptions, AppLocalHostOptions } from "./appHost.ts";
+import { boundedRpcRequest } from "./boundedRpcRequest.ts";
+import type { databaseLayer } from "./databaseLayer.ts";
+import type { HostOptions, HostPolicy } from "./hostOptions.ts";
+export function appHostHttp<
+	TRpcs extends Rpc.Any,
+	THandlers,
+	THandlerError,
+	THandlerRequirements,
+	TServices,
+	TServiceError,
+	TServiceRequirements,
+	TSession extends SessionShape,
+>(
+	options: HostOptions<TRpcs, THandlers, THandlerError, THandlerRequirements, TServices, TServiceError, TServiceRequirements> & HostPolicy<TSession>,
+) {
+	return Layer.unwrap(
+		Effect.gen(function* () {
+			const maxBodySize = options.config?.maxBodySize ?? (yield* Config.Int("MAX_BODY_SIZE").pipe(Config.withDefault(1024 * 1024)));
+			const bodySize = yield* Schema.decodeUnknownEffect(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)))(maxBodySize).pipe(
+				Effect.mapError((cause) => new Config.ConfigError(cause)),
+			);
+			const trustedProxy =
+				options.policy === "loopback"
+					? undefined
+					: (options.config?.trustedProxy ?? Option.getOrUndefined(yield* Config.String("TRUSTED_PROXY").pipe(Config.option)));
+			if (trustedProxy !== undefined) {
+				yield* Schema.decodeUnknownEffect(TrustedProxy)(trustedProxy).pipe(Effect.mapError((cause) => new Config.ConfigError(cause)));
+			}
+			const middleware =
+				options.policy === "loopback"
+					? requestTracingLayer()
+					: Layer.mergeAll(authenticatedLayer(options.sessions), maybeAuthenticatedLayer(options.sessions), requestTracingLayer());
+			const routes = HttpRouter.use((router) =>
+				Effect.gen(function* () {
+					const wire = yield* RpcSerialization.RpcSerialization;
+					const handler = yield* RpcServer.toHttpEffect(options.group);
+					const guarded = localRpcGuard(handler, trustedProxy);
+					yield* router.add("POST", options.rpcPath ?? "/rpc", (request) =>
+						guarded.pipe(
+							Effect.provideService(HttpIncomingMessage.MaxBodySize, ByteSize.bytes(bodySize)),
+							Effect.provideService(HttpServerRequest.HttpServerRequest, boundedRpcRequest(request)),
+							Effect.provideService(RpcSerialization.RpcSerialization, wire),
+						),
+					);
+				}),
+			).pipe(Layer.provide(Layer.merge(options.handlers, middleware)), Layer.provide(RpcSerialization.layerNdjson));
+			const assets =
+				options.assets === undefined
+					? Layer.empty
+					: HttpStaticServer.layer(typeof options.assets === "string" ? { root: options.assets } : options.assets);
+			const application = options.services;
+			const server = Layer.unwrap(
+				Effect.gen(function* () {
+					const port = options.config?.port ?? (yield* Config.Int("PORT").pipe(Config.withDefault(3000)));
+					const host = options.config?.host ?? (yield* Config.String("HOST").pipe(Config.withDefault("127.0.0.1")));
+					return NodeHttpServer.layer(createServer, {
+						host,
+						port,
+						...(options.config?.disablePreemptiveShutdown === undefined
+							? {}
+							: { disablePreemptiveShutdown: options.config.disablePreemptiveShutdown }),
+					});
+				}),
+			);
+			return HttpRouter.serve(Layer.mergeAll(routes, assets, options.routes ?? Layer.empty), { disableLogger: true }).pipe(
+				Layer.provideMerge(application),
+				Layer.provideMerge(server),
+				Layer.provide(NodeServices.layer),
+			);
+		}),
+	);
+}
+
+export function migratedHost<
+	TRpcs extends Rpc.Any,
+	THandlers,
+	THandlerError,
+	THandlerRequirements,
+	TServices,
+	TServiceError,
+	TServiceRequirements,
+	TMigrations,
+	TSession extends SessionShape,
+>(
+	options:
+		| AppHostOptions<TRpcs, THandlers, THandlerError, THandlerRequirements, TServices, TServiceError, TServiceRequirements, TMigrations, TSession>
+		| AppLocalHostOptions<TRpcs, THandlers, THandlerError, THandlerRequirements, TServices, TServiceError, TServiceRequirements, TMigrations>,
+	database: ReturnType<typeof databaseLayer<TMigrations>>,
+) {
+	return appHostHttp({ ...options, services: options.services.pipe(Layer.provideMerge(database)) });
+}

package/src/server/better-auth/rowAdapter.ts

@@ -27,7 +27,7 @@ function rowTyped(adapter: unknown): unknown {
 }
 function rejectJoin(join: unknown): void {
 	if (join !== undefined) {
-		throw new TypeError("The Effect Prisma Better Auth adapter does not support experimental native joins");
+		throw new TypeError("The Effect Prisma Better Auth adapter does not support native joins");
 	}
 }
 function namesId(condition: CleanedWhere): boolean {

package/src/server/boundedRpcRequest.ts

@@ -0,0 +1,47 @@
+import { NodeHttpServerRequest, NodeStream } from "@effect/platform-node";
+import { Effect, Stream } from "effect";
+import { HttpIncomingMessage, HttpServerError, type HttpServerRequest } from "effect/http";
+
+export function boundedRpcRequest(request: HttpServerRequest.HttpServerRequest): HttpServerRequest.HttpServerRequest {
+	const incoming = NodeHttpServerRequest.toIncomingMessage(request);
+	function error(cause: unknown) {
+		return new HttpServerError.HttpServerError({ reason: new HttpServerError.RequestParseError({ cause, request }) });
+	}
+	const text = Effect.gen(function* () {
+		const limit = yield* HttpIncomingMessage.MaxBodySize;
+		const chunks: Uint8Array[] = [];
+		let size = 0n;
+		yield* NodeStream.fromReadable<Uint8Array, HttpServerError.HttpServerError>({
+			closeOnDone: false,
+			evaluate: () => incoming,
+			onError: error,
+		}).pipe(
+			Stream.runForEach((chunk) => {
+				size += BigInt(chunk.byteLength);
+				if (limit !== undefined && size > limit) {
+					return Effect.fail(error(new Error("RPC body exceeds MAX_BODY_SIZE")));
+				}
+				chunks.push(chunk);
+				return Effect.void;
+			}),
+		);
+		return Buffer.concat(chunks).toString("utf8");
+	}).pipe(
+		Effect.onError(() => Effect.sync(() => incoming.resume())),
+		Effect.cached,
+		Effect.runSync,
+	);
+	const arrayBuffer = Effect.map(text, (body) => new TextEncoder().encode(body).buffer);
+	// The native text reader destroys the HTTP socket on overflow, preventing a 4xx response.
+	return new Proxy(request, {
+		get: (target, key, receiver) => {
+			if (key === "text") {
+				return text;
+			}
+			if (key === "arrayBuffer") {
+				return arrayBuffer;
+			}
+			return Reflect.get(target, key, receiver);
+		},
+	});
+}

package/src/server/databaseLayer.ts

@@ -0,0 +1,36 @@
+import * as PgClient from "@effect/sql-pg/PgClient";
+import { Config, Effect, Layer } from "effect";
+import * as Reactivity from "effect/reactivity/Reactivity";
+import { makeLiveServer } from "@shivaedev/effect-contract/makeLiveServer.ts";
+import { migratePostgres } from "@shivaedev/effect-sql/migrations.ts";
+import { postgresChanges } from "@shivaedev/effect-sql/postgresChanges.ts";
+import type { AppChanges, AppDatabaseOptions } from "./appHost.ts";
+
+export function databaseLayer<R>(options: AppDatabaseOptions<R>, changesService: typeof AppChanges) {
+	const pool = Layer.unwrap(
+		Effect.gen(function* () {
+			const url = options.config?.databaseUrl ?? (yield* Config.Redacted("DATABASE_URL"));
+			return PgClient.layer({
+				url,
+				...(options.config?.maxConnections === undefined ? {} : { maxConnections: options.config.maxConnections }),
+				...(options.config?.applicationName === undefined ? {} : { applicationName: options.config.applicationName }),
+			});
+		}),
+	);
+	const migrated = Layer.effectDiscard(migratePostgres({ ...options.migrations, lockTimeout: options.migrations.lockTimeout ?? "5 seconds" })).pipe(
+		Layer.provideMerge(pool),
+	);
+	const live = Layer.effect(changesService, makeLiveServer).pipe(Layer.provideMerge(Reactivity.layer));
+	const base = Layer.merge(migrated, live);
+	const changes = options.config?.changes;
+	if (changes === undefined) {
+		return base;
+	}
+	return Layer.unwrap(
+		Effect.gen(function* () {
+			const client = yield* PgClient.PgClient;
+			const hints = yield* changesService;
+			return postgresChanges({ ...changes, client, resync: hints.resync });
+		}),
+	).pipe(Layer.provideMerge(base));
+}

package/src/server/hostOptions.ts

@@ -0,0 +1,25 @@
+import type { Layer } from "effect";
+import type { HttpRouter, HttpStaticServer } from "effect/http";
+import type { Rpc, RpcGroup } from "effect/rpc";
+import type { SessionPolicy, SessionShape } from "#rpc-server/session.ts";
+import type { AppDatabaseOptions } from "./appHost.ts";
+
+export interface HostOptions<TRpcs extends Rpc.Any, THandlers, THandlerError, THandlerRequirements, TServices, TServiceError, TServiceRequirements> {
+	readonly assets?: string | Parameters<typeof HttpStaticServer.layer>[0];
+	readonly config?: AppDatabaseOptions["config"] & {
+		readonly port?: number;
+		readonly host?: string;
+		readonly trustedProxy?: string;
+		readonly maxBodySize?: number;
+		readonly disablePreemptiveShutdown?: boolean;
+	};
+	readonly group: RpcGroup.RpcGroup<TRpcs>;
+	readonly handlers: Layer.Layer<THandlers, THandlerError, THandlerRequirements>;
+	readonly routes?: Layer.Layer<never, never, HttpRouter.HttpRouter | HttpRouter.Request<"Error", unknown>>;
+	readonly rpcPath?: HttpRouter.PathInput;
+	readonly services: Layer.Layer<TServices, TServiceError, TServiceRequirements>;
+}
+
+export type HostPolicy<TSession extends SessionShape> =
+	| { readonly policy?: undefined; readonly sessions: SessionPolicy<TSession> }
+	| { readonly policy: "loopback"; readonly sessions?: never };

package/src/server/rpc-server/adapters/betterAuthSessions.ts

@@ -1,5 +1,5 @@
 import { Effect, Option } from "effect";
-import type { Headers } from "effect/unstable/http";
+import type { Headers } from "effect/http";
 import { AuthUnavailable } from "#errors/taxonomy.ts";
 import { redact } from "#rpc-server/redact.ts";
 import type { SessionProvider, SessionShape } from "#rpc-server/session.ts";

package/src/server/rpc-server/local.ts

@@ -1,6 +1,8 @@
+import type { BlockList } from "node:net";
 import { Effect, Option } from "effect";
-import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
-import { RpcSerialization } from "effect/unstable/rpc";
+import { HttpServerRequest, HttpServerResponse } from "effect/http";
+import { RpcSerialization } from "effect/rpc";
+import { proxyAddresses, proxyMatches } from "./trustedProxy.ts";
 
 function loopbackAddress(address: string): boolean {
 	const unmapped = unmapAddress(address);
@@ -40,8 +42,8 @@ export function loopbackOnly<E, R>(
 			? handler(request)
 			: Effect.succeed(HttpServerResponse.text("Only loopback hosts are served", { status: 403 }));
 }
-function proxyOrigin(request: HttpServerRequest.HttpServerRequest, trustedProxy: string | undefined): boolean {
-	if (trustedProxy === undefined || !Option.exists(request.remoteAddress, (address) => unmapAddress(address) === unmapAddress(trustedProxy))) {
+function proxyOrigin(request: HttpServerRequest.HttpServerRequest, trustedProxy: BlockList | undefined): boolean {
+	if (trustedProxy === undefined || !Option.exists(request.remoteAddress, (address) => proxyMatches(trustedProxy, address))) {
 		return false;
 	}
 	const host = request.headers["x-forwarded-host"];
@@ -56,15 +58,15 @@ function proxyOrigin(request: HttpServerRequest.HttpServerRequest, trustedProxy:
 		return false;
 	}
 }
-export const localRpcGuard = Effect.fnUntraced(function* <E, R>(
-	effect: Effect.Effect<HttpServerResponse.HttpServerResponse, E, R>,
-	trustedProxy?: string,
-) {
-	const request = yield* HttpServerRequest.HttpServerRequest;
-	const serialization = yield* RpcSerialization.RpcSerialization;
-	const local = loopbackHost(request.headers.host) && Option.exists(request.remoteAddress, loopbackAddress);
-	const contentType = request.headers["content-type"]?.split(";")[0]?.trim().toLowerCase();
-	return ((local && sameOrigin(request)) || proxyOrigin(request, trustedProxy)) && contentType === serialization.contentType
-		? yield* effect
-		: HttpServerResponse.text("Local same-origin requests only", { status: 403 });
-});
+export function localRpcGuard<E, R>(effect: Effect.Effect<HttpServerResponse.HttpServerResponse, E, R>, trustedProxy?: string) {
+	const addresses = trustedProxy === undefined ? undefined : proxyAddresses(trustedProxy);
+	return Effect.gen(function* () {
+		const request = yield* HttpServerRequest.HttpServerRequest;
+		const serialization = yield* RpcSerialization.RpcSerialization;
+		const local = loopbackHost(request.headers.host) && Option.exists(request.remoteAddress, loopbackAddress);
+		const contentType = request.headers["content-type"]?.split(";")[0]?.trim().toLowerCase();
+		return ((local && sameOrigin(request)) || proxyOrigin(request, addresses)) && contentType === serialization.contentType
+			? yield* effect
+			: HttpServerResponse.text("Local same-origin requests only", { status: 403 });
+	});
+}

package/src/server/rpc-server/origin.ts

@@ -1,5 +1,5 @@
 import { Option } from "effect";
-import { Headers } from "effect/unstable/http";
+import { Headers } from "effect/http";
 export interface OriginRequest {
 	readonly headers: Headers.Headers;
 	readonly origin: Option.Option<string>;

package/src/server/rpc-server/session.ts

@@ -1,5 +1,5 @@
 import { Effect, Layer, Option } from "effect";
-import type { Headers } from "effect/unstable/http";
+import type { Headers } from "effect/http";
 import { type AuthUnavailable, Forbidden, Unauthorized } from "#errors/taxonomy.ts";
 import { Identity, OptionalIdentity } from "#rpc/identity.ts";
 import { Authenticated, MaybeAuthenticated } from "#rpc/middleware.ts";

package/src/server/rpc-server/tracing.ts

@@ -1,5 +1,5 @@
 import { Cause, Effect, Layer, Option, Predicate, Random } from "effect";
-import { Headers } from "effect/unstable/http";
+import { Headers } from "effect/http";
 import { RequestId } from "#rpc/identity.ts";
 import { RequestTracing } from "#rpc/middleware.ts";
 import { redact } from "./redact.ts";

package/src/server/rpc-server/transportHeaders.ts

@@ -1,5 +1,5 @@
 import { Effect, Option } from "effect";
-import { type Headers, HttpServerRequest } from "effect/unstable/http";
+import { type Headers, HttpServerRequest } from "effect/http";
 export function transportHeaders(rpcHeaders: Headers.Headers): Effect.Effect<Headers.Headers> {
 	return Effect.map(
 		Effect.serviceOption(HttpServerRequest.HttpServerRequest),

package/src/server/rpc-server/trustedProxy.ts

@@ -0,0 +1,36 @@
+import { BlockList, isIP } from "node:net";
+import { Schema } from "effect";
+
+function addProxyAddress(addresses: BlockList, entry: string): boolean {
+	const parts = entry.trim().split("/");
+	const address = parts[0] ?? "";
+	const family = isIP(address);
+	if (family === 0 || address.includes("%") || parts.length > 2) {
+		return false;
+	}
+	const type = family === 4 ? "ipv4" : "ipv6";
+	const prefix = parts[1];
+	if (prefix === undefined) {
+		addresses.addAddress(address, type);
+	} else {
+		if (!/^\d+$/u.test(prefix) || Number(prefix) > (family === 4 ? 32 : 128)) {
+			return false;
+		}
+		addresses.addSubnet(address, Number(prefix), type);
+	}
+	return true;
+}
+export function proxyAddresses(value: string): BlockList | undefined {
+	const addresses = new BlockList();
+	return value.split(",").every((entry) => addProxyAddress(addresses, entry)) ? addresses : undefined;
+}
+export const TrustedProxy = Schema.String.check(
+	Schema.makeFilter((value) => proxyAddresses(value) !== undefined, {
+		message: "Expected a comma-separated list of IPv4 or IPv6 addresses or CIDR ranges",
+	}),
+);
+export function proxyMatches(addresses: BlockList, address: string): boolean {
+	const unmapped = address.replace(/^::ffff:(?=\d+\.)/iu, "");
+	const family = isIP(unmapped);
+	return family !== 0 && !unmapped.includes("%") && addresses.check(unmapped, family === 4 ? "ipv4" : "ipv6");
+}

package/src/server/runtime/makePlatform.ts

@@ -47,7 +47,7 @@ function make<TServices, TBuildError>(layer: Layer.Layer<TServices, TBuildError>
 	};
 	return runtime;
 }
-const production = Effect.map(Effect.orDie(Config.string("NODE_ENV").pipe(Config.withDefault(""))), (environment) => environment === "production");
+const production = Effect.map(Effect.orDie(Config.String("NODE_ENV").pipe(Config.withDefault(""))), (environment) => environment === "production");
 export function makePlatformRuntime<TServices, TBuildError>(
 	layer: Layer.Layer<TServices, TBuildError>,
 	options: PlatformRuntimeOptions = {},