@shivaedev/platform 0.5.2 → 0.6.1

package/src/{better-auth → server/better-auth}/adapter.ts

@@ -1,41 +1,40 @@
 import type { BetterAuthOptions, DBAdapterInstance } from "better-auth";
 import { createAdapterFactory } from "better-auth/adapters";
 import { Effect } from "effect";
-import type { AnyDatabase } from "@shivaedev/effect-prisma";
+import type { AnyDatabase } from "@shivaedev/effect-prisma/databaseTypes.ts";
 import type { PlatformRuntime } from "#runtime/types.ts";
 import { type DynamicRelation, refineRelation } from "./relation.ts";
-import { makeRowAdapter, type RelationQuery } from "./row-adapter.ts";
-
+import { makeRowAdapter, type RelationQuery } from "./rowAdapter.ts";
 export interface EffectPrismaAdapterOptions {
 	readonly debugLogs?: boolean;
 	readonly modelName?: (model: string) => string;
 	readonly usePlural?: boolean;
 }
-
 interface DynamicDatabase {
 	readonly transaction: <A, E, R>(program: Effect.Effect<A, E, R>) => Effect.Effect<A, unknown, unknown>;
 }
-
-const isFunction = (value: unknown, key: string): boolean =>
-	((typeof value === "object" && value !== null) || typeof value === "function") && typeof Reflect.get(value, key) === "function";
-
-const isDynamicDatabase = (value: unknown): value is DynamicDatabase => isFunction(value, "transaction");
-
-const isDynamicRelation = (value: unknown): value is DynamicRelation<unknown> => isFunction(value, "where") && isFunction(value, "select");
-
-const modelRelation = (database: DynamicDatabase, model: string): DynamicRelation<unknown> => {
+function isFunction(value: unknown, key: string): boolean {
+	return ((typeof value === "object" && value !== null) || typeof value === "function") && typeof Reflect.get(value, key) === "function";
+}
+function isDynamicDatabase(value: unknown): value is DynamicDatabase {
+	return isFunction(value, "transaction");
+}
+function isDynamicRelation(value: unknown): value is DynamicRelation<unknown> {
+	return isFunction(value, "where") && isFunction(value, "select");
+}
+function modelRelation(database: DynamicDatabase, model: string): DynamicRelation<unknown> {
 	const relation: unknown = Reflect.get(database, model);
 	if (!isDynamicRelation(relation)) {
 		throw new TypeError(`Unknown database model: ${model}`);
 	}
 	return relation;
-};
-
-const defaultModelName = (model: string): string => (model.length === 0 ? model : `${model[0]?.toUpperCase()}${model.slice(1)}`);
-
-export function effectPrismaAdapter<Database extends AnyDatabase, Services, BuildError>(
-	databaseTag: Database,
-	runtime: PlatformRuntime<Services, BuildError>,
+}
+function defaultModelName(model: string): string {
+	return model.length === 0 ? model : `${model[0]?.toUpperCase()}${model.slice(1)}`;
+}
+export function effectPrismaAdapter<TDatabase extends AnyDatabase, TServices, TBuildError>(
+	databaseTag: TDatabase,
+	runtime: PlatformRuntime<TServices, TBuildError>,
 	adapterOptions?: EffectPrismaAdapterOptions,
 ): DBAdapterInstance;
 export function effectPrismaAdapter(
@@ -48,21 +47,19 @@ export function effectPrismaAdapter(
 		const databaseEffect = Effect.flatMap(databaseTag, (database) =>
 			isDynamicDatabase(database) ? Effect.succeed(database) : Effect.die(new TypeError("The database service has no transaction")),
 		);
-
-		const run = <Value>(operation: (database: DynamicDatabase) => Effect.Effect<Value, unknown, unknown>): Promise<Value> =>
-			runtime.runPromise(Effect.flatMap(databaseEffect, operation));
-
+		function run<TValue>(operation: (database: DynamicDatabase) => Effect.Effect<TValue, unknown, unknown>): Promise<TValue> {
+			return runtime.runPromise(Effect.flatMap(databaseEffect, operation));
+		}
 		const query: RelationQuery = (model, refinement, use) =>
 			run((database) => use(refineRelation(modelRelation(database, mapModelName(model)), refinement)));
-
-		const inTransaction = <Value>(callback: () => Promise<Value>): Effect.Effect<Value, unknown, unknown> =>
-			Effect.flatMap(Effect.context<unknown>(), (services) =>
+		function inTransaction<TValue>(callback: () => Promise<TValue>): Effect.Effect<TValue, unknown, unknown> {
+			return Effect.flatMap(Effect.context<unknown>(), (services) =>
 				Effect.tryPromise({
 					catch: (error) => error,
 					try: () => runtime.runWithServices(services, callback),
 				}),
 			);
-
+		}
 		let factory: ReturnType<typeof createAdapterFactory>;
 		factory = createAdapterFactory({
 			adapter: makeRowAdapter(query, adapterOptions.usePlural ?? false),
@@ -73,13 +70,12 @@ export function effectPrismaAdapter(
 				supportsArrays: true,
 				supportsBooleans: true,
 				supportsDates: true,
-				supportsJSON: true,
+				"supportsJSON": true,
 				supportsNumericIds: true,
-				supportsUUIDs: true,
+				"supportsUUIDs": true,
 				transaction: (callback) => run((database) => database.transaction(inTransaction(() => callback(factory(authOptions))))),
 			},
 		});
-
 		return factory(authOptions);
 	};
 }

package/src/{better-auth → server/better-auth}/relation.ts

@@ -1,24 +1,22 @@
+import { all } from "@prisma-next/sql-orm-client";
 import type { Effect, Option } from "effect";
-import { all } from "@shivaedev/effect-prisma";
 import { type CleanedWhere, type DynamicField, type Expression, whereExpression } from "./where.ts";
-
-export interface DynamicRelation<Requirements> extends Effect.Effect<readonly Record<string, unknown>[], unknown, Requirements> {
-	count: () => Effect.Effect<number, unknown, Requirements>;
-	create: (data: Record<string, unknown>) => Effect.Effect<Record<string, unknown>, unknown, Requirements>;
-	delete: () => Effect.Effect<Record<string, unknown> | null, unknown, Requirements>;
-	deleteAll: () => Effect.Effect<readonly Record<string, unknown>[], unknown, Requirements>;
-	first: () => Effect.Effect<Option.Option<Record<string, unknown>>, unknown, Requirements>;
-	orderBy: (ordering: (fields: Record<string, DynamicField>) => unknown) => DynamicRelation<Requirements>;
-	select: (...fields: readonly string[]) => DynamicRelation<Requirements>;
-	skip: (count: number) => DynamicRelation<Requirements>;
-	take: (count: number) => DynamicRelation<Requirements>;
-	update: (data: Record<string, unknown>) => Effect.Effect<Record<string, unknown> | null, unknown, Requirements>;
-	updateAll: (data: Record<string, unknown>) => Effect.Effect<readonly Record<string, unknown>[], unknown, Requirements>;
-	where: (predicate: (fields: Record<string, DynamicField>) => Expression) => DynamicRelation<Requirements>;
+export interface DynamicRelation<TRequirements> extends Effect.Effect<readonly Record<string, unknown>[], unknown, TRequirements> {
+	count: () => Effect.Effect<number, unknown, TRequirements>;
+	create: (data: Record<string, unknown>) => Effect.Effect<Record<string, unknown>, unknown, TRequirements>;
+	delete: () => Effect.Effect<Record<string, unknown> | null, unknown, TRequirements>;
+	deleteAll: () => Effect.Effect<readonly Record<string, unknown>[], unknown, TRequirements>;
+	first: () => Effect.Effect<Option.Option<Record<string, unknown>>, unknown, TRequirements>;
+	orderBy: (ordering: (fields: Record<string, DynamicField>) => unknown) => DynamicRelation<TRequirements>;
+	select: (...fields: readonly string[]) => DynamicRelation<TRequirements>;
+	skip: (count: number) => DynamicRelation<TRequirements>;
+	take: (count: number) => DynamicRelation<TRequirements>;
+	update: (data: Record<string, unknown>) => Effect.Effect<Record<string, unknown> | null, unknown, TRequirements>;
+	updateAll: (data: Record<string, unknown>) => Effect.Effect<readonly Record<string, unknown>[], unknown, TRequirements>;
+	where: (predicate: (fields: Record<string, DynamicField>) => Expression) => DynamicRelation<TRequirements>;
 }
-
-export const refineRelation = <Requirements>(
-	relation: DynamicRelation<Requirements>,
+export function refineRelation<TRequirements>(
+	relation: DynamicRelation<TRequirements>,
 	options: {
 		readonly where?: readonly CleanedWhere[] | undefined;
 		readonly select?: readonly string[] | undefined;
@@ -31,7 +29,7 @@ export const refineRelation = <Requirements>(
 			  }
 			| undefined;
 	},
-): DynamicRelation<Requirements> => {
+): DynamicRelation<TRequirements> {
 	let refined = relation;
 	if (options.where !== undefined) {
 		refined = refined.where((fields) => {
@@ -58,4 +56,4 @@ export const refineRelation = <Requirements>(
 		refined = refined.select(...options.select);
 	}
 	return refined;
-};
+}

package/src/{better-auth/row-adapter.ts → server/better-auth/rowAdapter.ts}

@@ -9,43 +9,40 @@ type FindManyInput = Parameters<CustomAdapter["findMany"]>[0];
 type Row = Record<string, unknown>;
 type RowMethod = "create" | "findMany" | "findOne" | "update";
 type Refinement = Parameters<typeof refineRelation>[1];
-
 interface RowMethods {
 	readonly create: (input: { readonly data: Row; readonly model: string; readonly select?: string[] | undefined }) => Promise<Row>;
 	readonly findMany: (input: FindManyInput) => Promise<readonly Row[]>;
 	readonly findOne: (input: FindOneInput) => Promise<Row | null>;
 	readonly update: (input: { readonly model: string; readonly update: Row; readonly where: CleanedWhere[] }) => Promise<Row | null>;
 }
-
-export type RelationQuery = <Value>(
+export type RelationQuery = <TValue>(
 	model: string,
 	refinement: Refinement,
-	use: (relation: DynamicRelation<unknown>) => Effect.Effect<Value, unknown, unknown>,
-) => Promise<Value>;
-
+	use: (relation: DynamicRelation<unknown>) => Effect.Effect<TValue, unknown, unknown>,
+) => Promise<TValue>;
 // Better Auth lets each call declare its row type; the rows are whatever its generated schema stored.
 function rowTyped(adapter: Omit<CustomAdapter, RowMethod> & RowMethods): CustomAdapter;
 function rowTyped(adapter: unknown): unknown {
 	return adapter;
 }
-
-const rejectJoin = (join: unknown): void => {
+function rejectJoin(join: unknown): void {
 	if (join !== undefined) {
 		throw new TypeError("The Effect Prisma Better Auth adapter does not support experimental native joins");
 	}
-};
-
-const namesId = (condition: CleanedWhere): boolean => condition.connector !== "OR" && condition.field === "id" && condition.operator === "eq";
-
-export const makeRowAdapter =
-	(query: RelationQuery, usePlural: boolean): AdapterFactoryCustomizeAdapterCreator =>
-	({ debugLog, getFieldAttributes }) => {
-		const isUnique = (model: string, condition: CleanedWhere): boolean =>
-			condition.connector !== "OR"
-			&& condition.operator === "eq"
-			&& condition.mode !== "insensitive"
-			&& (condition.field === "id" || getFieldAttributes({ field: condition.field, model }).unique === true);
-
+}
+function namesId(condition: CleanedWhere): boolean {
+	return condition.connector !== "OR" && condition.field === "id" && condition.operator === "eq";
+}
+export function makeRowAdapter(query: RelationQuery, usePlural: boolean): AdapterFactoryCustomizeAdapterCreator {
+	return ({ debugLog, getFieldAttributes }) => {
+		function isUnique(model: string, condition: CleanedWhere): boolean {
+			return (
+				condition.connector !== "OR"
+				&& condition.operator === "eq"
+				&& condition.mode !== "insensitive"
+				&& (condition.field === "id" || getFieldAttributes({ field: condition.field, model }).unique === true)
+			);
+		}
 		return rowTyped({
 			count: ({ model, where }) => query(model, { where }, (relation) => relation.count()),
 			create: ({ data, model, select }) => {
@@ -78,3 +75,4 @@ export const makeRowAdapter =
 			updateMany: ({ model, update, where }) => query(model, { where }, (relation) => Effect.map(relation.updateAll(update), (rows) => rows.length)),
 		});
 	};
+}

package/src/{better-auth → server/better-auth}/where.ts

@@ -1,9 +1,7 @@
+import { all, and, not, or } from "@prisma-next/sql-orm-client";
 import type { Where } from "better-auth";
-import { all, and, not, or } from "@shivaedev/effect-prisma";
-
 export type CleanedWhere = Required<Where>;
 export type Expression = Parameters<typeof and>[number];
-
 export interface DynamicField {
 	asc: () => unknown;
 	desc: () => unknown;
@@ -20,53 +18,49 @@ export interface DynamicField {
 	neq: (value: unknown) => Expression;
 	notIn: (value: readonly unknown[]) => Expression;
 }
-
-const escapeLike = (value: string): string => value.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_");
-
-const nonNullValues = (value: unknown): readonly unknown[] => (Array.isArray(value) ? value : [value]).filter((item) => item !== null);
-
-const insensitiveStrings = (field: DynamicField, where: CleanedWhere, values: readonly unknown[]) => {
+function escapeLike(value: string): string {
+	return value.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_");
+}
+function nonNullValues(value: unknown): readonly unknown[] {
+	return (Array.isArray(value) ? value : [value]).filter((item) => item !== null);
+}
+function insensitiveStrings(field: DynamicField, where: CleanedWhere, values: readonly unknown[]) {
 	const ilike = field.ilike;
 	if (where.mode !== "insensitive" || ilike === undefined || !values.every((item) => typeof item === "string")) {
 		return undefined;
 	}
 	return values.map((item) => ilike(escapeLike(String(item))));
-};
-
-const membership = (field: DynamicField, where: CleanedWhere): Expression => {
+}
+function membership(field: DynamicField, where: CleanedWhere): Expression {
 	const values = nonNullValues(where.value);
 	if (values.length === 0) {
 		return and(field.isNull(), field.isNotNull());
 	}
 	const matches = insensitiveStrings(field, where, values);
 	return matches === undefined ? field.in(values) : or(...matches);
-};
-
-const exclusion = (field: DynamicField, where: CleanedWhere): Expression | undefined => {
+}
+function exclusion(field: DynamicField, where: CleanedWhere): Expression | undefined {
 	const values = nonNullValues(where.value);
 	if (values.length === 0) {
 		return undefined;
 	}
 	const matches = insensitiveStrings(field, where, values);
 	return matches === undefined ? field.notIn(values) : and(...matches.map((match) => not(match)));
-};
-
-const likePattern = (operator: CleanedWhere["operator"], escaped: string): string => {
+}
+function likePattern(operator: CleanedWhere["operator"], escaped: string): string {
 	if (operator === "contains") {
 		return `%${escaped}%`;
 	}
 	return operator === "starts_with" ? `${escaped}%` : `%${escaped}`;
-};
-
-const pattern = (field: DynamicField, where: CleanedWhere): Expression => {
+}
+function pattern(field: DynamicField, where: CleanedWhere): Expression {
 	if (typeof where.value !== "string") {
 		throw new TypeError(`${where.operator} requires a string value`);
 	}
 	const text = likePattern(where.operator, escapeLike(where.value));
 	return where.mode === "insensitive" && field.ilike !== undefined ? field.ilike(text) : field.like(text);
-};
-
-const insensitiveEquality = (field: DynamicField, where: CleanedWhere): Expression | undefined => {
+}
+function insensitiveEquality(field: DynamicField, where: CleanedWhere): Expression | undefined {
 	const value = where.value;
 	const operator = where.operator ?? "eq";
 	if (where.mode !== "insensitive" || typeof value !== "string" || field.ilike === undefined) {
@@ -79,9 +73,8 @@ const insensitiveEquality = (field: DynamicField, where: CleanedWhere): Expressi
 		return not(field.ilike(escapeLike(value)));
 	}
 	return undefined;
-};
-
-const comparison = (field: DynamicField, where: CleanedWhere): Expression | undefined => {
+}
+function comparison(field: DynamicField, where: CleanedWhere): Expression | undefined {
 	const value = where.value;
 	switch (where.operator ?? "eq") {
 		case "eq":
@@ -105,12 +98,10 @@ const comparison = (field: DynamicField, where: CleanedWhere): Expression | unde
 		case "ends_with":
 			return pattern(field, where);
 	}
-};
-
-export const whereExpression = (fields: Record<string, DynamicField>, where: readonly CleanedWhere[]): Expression | undefined => {
+}
+export function whereExpression(fields: Record<string, DynamicField>, where: readonly CleanedWhere[]): Expression | undefined {
 	const conjunctions: Expression[] = [];
 	const disjunctions: Expression[] = [];
-
 	for (const condition of where) {
 		const field = fields[condition.field];
 		if (field === undefined) {
@@ -122,7 +113,6 @@ export const whereExpression = (fields: Record<string, DynamicField>, where: rea
 		}
 		(condition.connector === "OR" ? disjunctions : conjunctions).push(expression);
 	}
-
 	if (disjunctions.length > 0) {
 		conjunctions.push(or(...disjunctions));
 	}
@@ -130,4 +120,4 @@ export const whereExpression = (fields: Record<string, DynamicField>, where: rea
 		return all();
 	}
 	return conjunctions.length === 1 ? conjunctions[0] : and(...conjunctions);
-};
+}

package/src/{node-http/subscription-signal.ts → server/node-http/subscriptionSignal.ts}

@@ -1,28 +1,25 @@
 import type { IncomingMessage } from "node:http";
-
 export interface NodeSubscriptionSignalOptions {
 	readonly nodeRequest?: IncomingMessage | undefined;
 	readonly request?: Request | undefined;
 	readonly signals?: Iterable<AbortSignal | undefined>;
 }
-
 export interface NodeSubscriptionSignal {
 	readonly dispose: () => void;
 	readonly signal: AbortSignal;
 }
-
-const property = (value: unknown, key: string): unknown => (typeof value === "object" && value !== null ? Reflect.get(value, key) : undefined);
-
-const isIncomingMessage = (value: unknown): value is IncomingMessage =>
-	typeof property(value, "socket") === "object" && typeof property(value, "once") === "function";
-
-const nodeRequestFrom = (request: Request | undefined): IncomingMessage | undefined => {
+function property(value: unknown, key: string): unknown {
+	return typeof value === "object" && value !== null ? Reflect.get(value, key) : undefined;
+}
+function isIncomingMessage(value: unknown): value is IncomingMessage {
+	return typeof property(value, "socket") === "object" && typeof property(value, "once") === "function";
+}
+function nodeRequestFrom(request: Request | undefined): IncomingMessage | undefined {
 	const req = property(property(property(request, "runtime"), "node"), "req");
 	return isIncomingMessage(req) ? req : undefined;
-};
-
+}
 // Under Bun's node:http compatibility layer a Web request signal may miss an abandoned socket, so node close events cover long-lived responses.
-export const nodeSubscriptionSignal = (options: NodeSubscriptionSignalOptions): NodeSubscriptionSignal => {
+export function nodeSubscriptionSignal(options: NodeSubscriptionSignalOptions): NodeSubscriptionSignal {
 	const controller = new AbortController();
 	const signals: AbortSignal[] = [controller.signal];
 	if (options.request !== undefined) {
@@ -33,25 +30,25 @@ export const nodeSubscriptionSignal = (options: NodeSubscriptionSignalOptions):
 			signals.push(signal);
 		}
 	}
-
 	const nodeRequest = options.nodeRequest ?? nodeRequestFrom(options.request);
 	if (nodeRequest === undefined) {
-		return { dispose: () => {}, signal: AbortSignal.any(signals) };
+		return { dispose: (): void => undefined, signal: AbortSignal.any(signals) };
 	}
-
-	const socket = nodeRequest.socket;
-	const onRequestClose = () => {
-		if (!nodeRequest.complete) {
+	const request = nodeRequest;
+	const socket = request.socket;
+	function onRequestClose() {
+		if (!request.complete) {
 			controller.abort();
 		}
-	};
-	const onSocketClose = () => controller.abort();
+	}
+	function onSocketClose() {
+		return controller.abort();
+	}
 	nodeRequest.once("close", onRequestClose);
 	socket.once("close", onSocketClose);
 	if (nodeRequest.destroyed || socket.destroyed) {
 		controller.abort();
 	}
-
 	let disposed = false;
 	return {
 		dispose: () => {
@@ -64,4 +61,4 @@ export const nodeSubscriptionSignal = (options: NodeSubscriptionSignalOptions):
 		},
 		signal: AbortSignal.any(signals),
 	};
-};
+}

package/src/{rpc-server/adapters/better-auth-sessions.ts → server/rpc-server/adapters/betterAuthSessions.ts}

@@ -3,20 +3,19 @@ import type { Headers } from "effect/unstable/http";
 import { AuthUnavailable } from "#errors/taxonomy.ts";
 import { redact } from "#rpc-server/redact.ts";
 import type { SessionProvider, SessionShape } from "#rpc-server/session.ts";
-
-export type GetSession<Session extends SessionShape> = (headers: globalThis.Headers) => Promise<Session | null>;
-
-const unavailable = (cause: unknown) =>
-	Effect.andThen(
+export type GetSession<TSession extends SessionShape> = (headers: globalThis.Headers) => Promise<TSession | null>;
+function unavailable(cause: unknown) {
+	return Effect.andThen(
 		Effect.logError("Authentication provider failed", redact(cause)),
 		Effect.fail(new AuthUnavailable({ message: "Authentication is temporarily unavailable" })),
 	);
-
-export const betterAuthSessions = <Session extends SessionShape>(getSession: GetSession<Session>): SessionProvider<Session> => ({
-	get: Effect.fn("PlatformRpc.betterAuthSession")(function* (headers: Headers.Headers) {
+}
+export function betterAuthSessions<TSession extends SessionShape>(getSession: GetSession<TSession>): SessionProvider<TSession> {
+	const betterAuthSession = Effect.fn("PlatformRpc.betterAuthSession")(function* (headers: Headers.Headers) {
 		const session = yield* Effect.tryPromise(() => getSession(new globalThis.Headers(headers))).pipe(
 			Effect.catch((error) => unavailable(error.cause)),
 		);
 		return Option.fromNullishOr(session);
-	}),
-});
+	});
+	return { get: betterAuthSession };
+}

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

@@ -0,0 +1,26 @@
+import { Cause, Effect, Schema } from "effect";
+import { isSensitiveKey, redactText } from "./sensitive.ts";
+export interface RpcBoundaryOptions<E> {
+	readonly message?: string;
+	readonly unexpected: (message: string) => E;
+}
+export function rpcBoundary<
+	TSchema extends Schema.ConstraintDecoder<{
+		readonly message: string;
+	}>,
+>(schema: TSchema, options: RpcBoundaryOptions<TSchema["Type"]>) {
+	const declared = Schema.is(schema);
+	return <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, TSchema["Type"], R> =>
+		Effect.catchCause(self, (cause) => {
+			if (Cause.hasInterruptsOnly(cause)) {
+				return Effect.failCause(Cause.fromReasons(cause.reasons.filter(Cause.isInterruptReason)));
+			}
+			const reason = cause.reasons[0];
+			if (cause.reasons.length === 1 && reason && Cause.isFailReason(reason) && declared(reason.error)) {
+				return Effect.fail(reason.error);
+			}
+			const rejection = options.unexpected(redactText(options.message ?? "Internal server error", isSensitiveKey));
+			Object.defineProperty(rejection, "cause", { configurable: true, enumerable: false, value: cause });
+			return Effect.failCause(Cause.fromReasons([...Cause.fail(rejection).reasons, ...cause.reasons.filter(Cause.isInterruptReason)]));
+		});
+}

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

@@ -0,0 +1,70 @@
+import { Effect, Option } from "effect";
+import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
+import { RpcSerialization } from "effect/unstable/rpc";
+
+function loopbackAddress(address: string): boolean {
+	const unmapped = unmapAddress(address);
+	return unmapped === "::1" || (/^127(?:\.\d{1,3}){3}$/u.test(unmapped) && unmapped.split(".").every((part) => Number(part) <= 255));
+}
+function unmapAddress(address: string): string {
+	return address.replace(/^::ffff:/iu, "");
+}
+function loopbackHost(host: string | undefined): boolean {
+	if (host === undefined) {
+		return false;
+	}
+	const authority = /^(?<hostname>\[[^\]]+\]|[^:]+)(?::(?<port>\d{1,5}))?$/u.exec(host)?.groups;
+	if (authority === undefined || (authority.port !== undefined && Number(authority.port) > 65_535)) {
+		return false;
+	}
+	const hostname = authority.hostname?.toLowerCase();
+	return hostname !== undefined && (hostname === "localhost" || hostname === "[::1]" || loopbackAddress(hostname));
+}
+export function sameOrigin(request: HttpServerRequest.HttpServerRequest): boolean {
+	const origin = request.headers.origin;
+	if (origin === undefined) {
+		return true;
+	}
+	try {
+		const url = new URL(origin);
+		return url.protocol === "http:" && url.origin === origin && url.host === request.headers.host;
+	} catch {
+		return false;
+	}
+}
+export function loopbackOnly<E, R>(
+	handler: (request: HttpServerRequest.HttpServerRequest) => Effect.Effect<HttpServerResponse.HttpServerResponse, E, R>,
+) {
+	return (request: HttpServerRequest.HttpServerRequest) =>
+		loopbackHost(request.headers.host) && Option.match(request.remoteAddress, { onNone: () => true, onSome: loopbackAddress })
+			? 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))) {
+		return false;
+	}
+	const host = request.headers["x-forwarded-host"];
+	const protocol = request.headers["x-forwarded-proto"];
+	if (host === undefined || !/^(?:\[[\da-f:]+\]|[\da-z.-]+)(?::\d{1,5})?$/iu.test(host) || (protocol !== "http" && protocol !== "https")) {
+		return false;
+	}
+	try {
+		const url = new URL(`${protocol}://${host}`);
+		return request.headers.origin === undefined || request.headers.origin === url.origin;
+	} catch {
+		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 });
+});

package/src/{rpc-server → server/rpc-server}/origin.ts

@@ -1,29 +1,26 @@
 import { Option } from "effect";
 import { Headers } from "effect/unstable/http";
-
 export interface OriginRequest {
 	readonly headers: Headers.Headers;
 	readonly origin: Option.Option<string>;
 	readonly rpc: string;
 }
-
 export type OriginPolicy = (request: OriginRequest) => boolean;
-
 export interface TrustedOriginsOptions {
 	readonly allow: readonly string[];
 	readonly missing: "allow" | "reject";
 }
-
-export const trustedOrigins =
-	(options: TrustedOriginsOptions): OriginPolicy =>
-	({ origin }) =>
+export function trustedOrigins(options: TrustedOriginsOptions): OriginPolicy {
+	return ({ origin }) =>
 		Option.match(origin, {
 			onNone: () => options.missing === "allow",
 			onSome: (value) => options.allow.includes(value),
 		});
-
-export const originRequest = (headers: Headers.Headers, rpc: string): OriginRequest => ({
-	headers,
-	origin: Headers.get(headers, "origin"),
-	rpc,
-});
+}
+export function originRequest(headers: Headers.Headers, rpc: string): OriginRequest {
+	return {
+		headers,
+		origin: Headers.get(headers, "origin"),
+		rpc,
+	};
+}

package/src/{rpc-server → server/rpc-server}/redact.ts

@@ -3,8 +3,7 @@ import { isSensitiveKey, REDACTED, redactText, type SensitiveKey } from "./sensi
 
 const MAX_DEPTH = 8;
 const MAX_ENTRIES = 50;
-
-const binary = (value: object): string | undefined => {
+function binary(value: object): string | undefined {
 	if (ArrayBuffer.isView(value)) {
 		return `<${value.constructor.name} ${value.byteLength} bytes>`;
 	}
@@ -12,9 +11,8 @@ const binary = (value: object): string | undefined => {
 		return `<ArrayBuffer ${value.byteLength} bytes>`;
 	}
 	return undefined;
-};
-
-const entriesOf = (value: object): [string, unknown][] => {
+}
+function entriesOf(value: object): [string, unknown][] {
 	const entries = Object.entries(value);
 	if (!Predicate.isError(value)) {
 		return entries;
@@ -25,9 +23,8 @@ const entriesOf = (value: object): [string, unknown][] => {
 		["stack", value.stack],
 	];
 	return value.cause === undefined ? [...shape, ...entries] : [...shape, ...entries, ["cause", value.cause]];
-};
-
-const walk = (value: unknown, sensitive: SensitiveKey, depth: number): unknown => {
+}
+function walk(value: unknown, sensitive: SensitiveKey, depth: number): unknown {
 	if (Redacted.isRedacted(value)) {
 		return REDACTED;
 	}
@@ -53,6 +50,7 @@ const walk = (value: unknown, sensitive: SensitiveKey, depth: number): unknown =
 		.slice(0, MAX_ENTRIES)
 		.map(([key, nested]): [string, unknown] => [key, sensitive(key) ? REDACTED : walk(nested, sensitive, depth + 1)]);
 	return Object.fromEntries(entries.length > MAX_ENTRIES ? [...kept, ["<truncated>", `${entries.length - MAX_ENTRIES} more keys`]] : kept);
-};
-
-export const redact = (value: unknown, sensitive: SensitiveKey = isSensitiveKey): unknown => walk(value, sensitive, 0);
+}
+export function redact(value: unknown, sensitive: SensitiveKey = isSensitiveKey): unknown {
+	return walk(value, sensitive, 0);
+}