@shivaedev/platform 0.3.8 → 0.4.1

package/src/errors/taxonomy.ts

@@ -0,0 +1,18 @@
+import { Schema } from "effect";
+
+const described = { message: Schema.String };
+const perField = { message: Schema.String, field: Schema.optionalKey(Schema.String) };
+
+export class NotFound extends Schema.TaggedError<NotFound>()("NotFound", described) {}
+
+export class Unauthorized extends Schema.TaggedError<Unauthorized>()("Unauthorized", described) {}
+
+export class Forbidden extends Schema.TaggedError<Forbidden>()("Forbidden", described) {}
+
+export class BadRequest extends Schema.TaggedError<BadRequest>()("BadRequest", perField) {}
+
+export class Conflict extends Schema.TaggedError<Conflict>()("Conflict", perField) {}
+
+export class PreconditionFailed extends Schema.TaggedError<PreconditionFailed>()("PreconditionFailed", described) {}
+
+export class AuthUnavailable extends Schema.TaggedError<AuthUnavailable>()("AuthUnavailable", described) {}

package/src/errors.ts

@@ -0,0 +1,2 @@
+export { type RejectedField, rejectedField } from "./errors/rejected-field.ts";
+export { AuthUnavailable, BadRequest, Conflict, Forbidden, NotFound, PreconditionFailed, Unauthorized } from "./errors/taxonomy.ts";

package/src/node-http/subscription-signal.ts

@@ -1,13 +1,5 @@
 import type { IncomingMessage } from "node:http";
 
-interface NodeRequestCarrier {
-	readonly runtime?: {
-		readonly node?: {
-			readonly req?: IncomingMessage;
-		};
-	};
-}
-
 export interface NodeSubscriptionSignalOptions {
 	/** A Web request, including its signal and an optional srvx node runtime. */
 	readonly request?: Request | undefined;
@@ -24,19 +16,22 @@ export interface NodeSubscriptionSignal {
 	readonly signal: AbortSignal;
 }
 
-const nodeRequestFrom = (
-	request: Request | undefined,
-): IncomingMessage | undefined =>
-	(request as (Request & NodeRequestCarrier) | undefined)?.runtime?.node?.req;
+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 => {
+	const req = property(property(property(request, "runtime"), "node"), "req");
+	return isIncomingMessage(req) ? req : undefined;
+};
 
 /**
  * Combine Web/procedure abort signals with node request and socket close events.
  * The node events cover long-lived responses under Bun's node:http compatibility
  * layer, where a Web request signal alone may not report an abandoned socket.
  */
-export const nodeSubscriptionSignal = (
-	options: NodeSubscriptionSignalOptions,
-): NodeSubscriptionSignal => {
+export const nodeSubscriptionSignal = (options: NodeSubscriptionSignalOptions): NodeSubscriptionSignal => {
 	const controller = new AbortController();
 	const signals: AbortSignal[] = [controller.signal];
 	if (options.request !== undefined) signals.push(options.request.signal);

package/src/node-http.ts

@@ -2,4 +2,4 @@ export {
 	type NodeSubscriptionSignal,
 	type NodeSubscriptionSignalOptions,
 	nodeSubscriptionSignal,
-} from "./node-http/subscription-signal.js";
+} from "./node-http/subscription-signal.ts";

package/src/rpc/identity.ts

@@ -0,0 +1,11 @@
+import { Context, type Option } from "effect";
+
+export class RequestId extends Context.Service<RequestId, string>()("@shivaedev/platform/rpc/RequestId") {}
+
+export interface IdentityValue {
+	readonly id: string;
+}
+
+export class Identity extends Context.Service<Identity, IdentityValue>()("@shivaedev/platform/rpc/Identity") {}
+
+export class OptionalIdentity extends Context.Service<OptionalIdentity, Option.Option<IdentityValue>>()("@shivaedev/platform/rpc/OptionalIdentity") {}

package/src/rpc/middleware.ts

@@ -0,0 +1,15 @@
+import { Schema } from "effect";
+import { RpcMiddleware } from "effect/unstable/rpc";
+import { AuthUnavailable, Forbidden, Unauthorized } from "../errors/taxonomy.ts";
+import type { Identity, OptionalIdentity, RequestId } from "./identity.ts";
+
+export class RequestTracing extends RpcMiddleware.Service<RequestTracing, { provides: RequestId }>()("@shivaedev/platform/rpc/RequestTracing") {}
+
+export class Authenticated extends RpcMiddleware.Service<Authenticated, { provides: Identity }>()("@shivaedev/platform/rpc/Authenticated", {
+	error: Schema.Union([Unauthorized, AuthUnavailable, Forbidden]),
+}) {}
+
+export class MaybeAuthenticated extends RpcMiddleware.Service<MaybeAuthenticated, { provides: OptionalIdentity }>()(
+	"@shivaedev/platform/rpc/MaybeAuthenticated",
+	{ error: Schema.Union([AuthUnavailable, Forbidden]) },
+) {}

package/src/rpc-server/adapters/better-auth-sessions.ts

@@ -0,0 +1,22 @@
+import { Effect, Option } from "effect";
+import type { Headers } from "effect/unstable/http";
+import { AuthUnavailable } from "../../errors/taxonomy.ts";
+import { redact } from "../redact.ts";
+import type { SessionProvider, SessionShape } from "../session.ts";
+
+export type GetSession<Session extends SessionShape> = (headers: globalThis.Headers) => Promise<Session | null>;
+
+const unavailable = (cause: unknown) =>
+	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) {
+		const session = yield* Effect.tryPromise(() => getSession(new globalThis.Headers(headers))).pipe(
+			Effect.catch((error) => unavailable(error.cause)),
+		);
+		return Option.fromNullishOr(session);
+	}),
+});

package/src/rpc-server/origin.ts

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

package/src/rpc-server/redact-cause.ts

@@ -0,0 +1,41 @@
+import { Cause, Context, ErrorReporter, Predicate } from "effect";
+import { redact } from "./redact.ts";
+import { isSensitiveKey, redactText, type SensitiveKey } from "./sensitive.ts";
+
+const reporterHints = (error: Error, sensitive: SensitiveKey) => ({
+	...(ErrorReporter.isIgnored(error) ? { [ErrorReporter.ignore]: true } : {}),
+	...(ErrorReporter.severity in error ? { [ErrorReporter.severity]: ErrorReporter.getSeverity(error) } : {}),
+	...(ErrorReporter.attributes in error ? { [ErrorReporter.attributes]: redact(ErrorReporter.getAttributes(error), sensitive) } : {}),
+});
+
+const redactError = (error: Error, sensitive: SensitiveKey): Error => {
+	const options = error.cause === undefined ? undefined : { cause: redact(error.cause, sensitive) };
+	const copy = new Error(redactText(error.message, sensitive), options);
+	Object.defineProperty(copy, "name", { value: error.name, writable: true, configurable: true });
+	Object.defineProperty(copy, "stack", {
+		value: error.stack === undefined ? undefined : redactText(error.stack, sensitive),
+		writable: true,
+		configurable: true,
+	});
+	return Object.assign(copy, redact(Object.fromEntries(Object.entries(error)), sensitive), reporterHints(error, sensitive));
+};
+
+export const redactDefect = (defect: unknown, sensitive: SensitiveKey = isSensitiveKey): unknown =>
+	Predicate.isError(defect) ? redactError(defect, sensitive) : redact(defect, sensitive);
+
+export const redactCause = <E>(cause: Cause.Cause<E>, sensitive: SensitiveKey = isSensitiveKey): Cause.Cause<E> =>
+	Cause.fromReasons(
+		cause.reasons.flatMap<Cause.Reason<E>>((reason) =>
+			Cause.isDieReason(reason)
+				? Cause.annotate(Cause.die(redactDefect(reason.defect, sensitive)), Context.makeUnsafe(reason.annotations)).reasons
+				: [reason],
+		),
+	);
+
+export const redactingErrorReporter = (
+	reporter: ErrorReporter.ErrorReporter,
+	sensitive: SensitiveKey = isSensitiveKey,
+): ErrorReporter.ErrorReporter => ({
+	[ErrorReporter.TypeId]: ErrorReporter.TypeId,
+	report: (options) => reporter.report({ ...options, cause: redactCause(options.cause, sensitive) }),
+});

package/src/rpc-server/redact.ts

@@ -0,0 +1,42 @@
+import { Predicate, Redacted } from "effect";
+import { isSensitiveKey, REDACTED, redactText, type SensitiveKey } from "./sensitive.ts";
+
+const MAX_DEPTH = 8;
+const MAX_ENTRIES = 50;
+
+const binary = (value: object): string | undefined => {
+	if (ArrayBuffer.isView(value)) return `<${value.constructor.name} ${value.byteLength} bytes>`;
+	if (value instanceof ArrayBuffer) return `<ArrayBuffer ${value.byteLength} bytes>`;
+	return undefined;
+};
+
+const entriesOf = (value: object): Array<[string, unknown]> => {
+	const entries = Object.entries(value);
+	if (!Predicate.isError(value)) return entries;
+	const shape: Array<[string, unknown]> = [
+		["name", value.name],
+		["message", value.message],
+		["stack", value.stack],
+	];
+	return value.cause === undefined ? [...shape, ...entries] : [...shape, ...entries, ["cause", value.cause]];
+};
+
+const walk = (value: unknown, sensitive: SensitiveKey, depth: number): unknown => {
+	if (Redacted.isRedacted(value)) return REDACTED;
+	if (Predicate.isString(value)) return redactText(value, sensitive);
+	if (!Predicate.isObjectOrArray(value)) return value;
+	const summary = binary(value);
+	if (summary !== undefined) return summary;
+	if (depth >= MAX_DEPTH) return "<truncated>";
+	if (Array.isArray(value)) {
+		const items = value.slice(0, MAX_ENTRIES).map((item) => walk(item, sensitive, depth + 1));
+		return value.length > MAX_ENTRIES ? [...items, `<${value.length - MAX_ENTRIES} more items>`] : items;
+	}
+	const entries = entriesOf(value);
+	const kept = entries
+		.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);

package/src/rpc-server/sensitive.ts

@@ -0,0 +1,60 @@
+export const REDACTED = "<redacted>";
+
+const MAX_STRING = 2048;
+const SENSITIVE_PARTS = [
+	"password",
+	"passphrase",
+	"secret",
+	"token",
+	"authorization",
+	"cookie",
+	"apikey",
+	"accesskey",
+	"credential",
+	"privatekey",
+	"jwt",
+	"bearer",
+	"signature",
+	"sessionid",
+	"cardnumber",
+	"accountnumber",
+	"csrf",
+	"xsrf",
+];
+const SENSITIVE_WORDS = ["otp", "pin", "cvv", "cvc", "ssn", "iban"];
+const SENSITIVE_NAMES = ["session", "pan"];
+
+export type SensitiveKey = (key: string) => boolean;
+
+const wordsOf = (key: string): Array<string> =>
+	key
+		.replaceAll(/([a-z0-9])([A-Z])/g, "$1 $2")
+		.replaceAll(/([A-Z])([A-Z][a-z])/g, "$1 $2")
+		.toLowerCase()
+		.split(/[\s_-]+/);
+
+export const isSensitiveKey: SensitiveKey = (key) => {
+	const normalized = key.toLowerCase().replaceAll(/[-_]/g, "");
+	return (
+		SENSITIVE_NAMES.includes(normalized) ||
+		SENSITIVE_PARTS.some((part) => normalized.includes(part)) ||
+		wordsOf(key).some((word) => SENSITIVE_WORDS.includes(word))
+	);
+};
+
+const AUTH_SCHEME = /\b(Bearer|Basic)\s+[A-Za-z0-9._~+/-]+=*/gi;
+const JWT = /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]*/g;
+const URL_PASSWORD = /(\/\/[^:/\s@]+:)[^@/\s]+@/g;
+const ASSIGNMENT = /([A-Za-z][\w.-]*)(["']?\s*[=:]\s*["']?)([^\s"'&,;]+)/g;
+
+const scrub = (text: string, sensitive: SensitiveKey): string =>
+	text
+		.replaceAll(AUTH_SCHEME, `$1 ${REDACTED}`)
+		.replaceAll(JWT, REDACTED)
+		.replaceAll(URL_PASSWORD, `$1${REDACTED}@`)
+		.replaceAll(ASSIGNMENT, (match: string, key: string, separator: string) => (sensitive(key) ? `${key}${separator}${REDACTED}` : match));
+
+export const redactText = (text: string, sensitive: SensitiveKey): string => {
+	const scrubbed = scrub(text, sensitive);
+	return scrubbed.length > MAX_STRING ? `${scrubbed.slice(0, MAX_STRING)}…<${scrubbed.length - MAX_STRING} more chars>` : scrubbed;
+};

package/src/rpc-server/session.ts

@@ -0,0 +1,54 @@
+import { Effect, Layer, Option } from "effect";
+import type { Headers } from "effect/unstable/http";
+import { type AuthUnavailable, Forbidden, Unauthorized } from "../errors/taxonomy.ts";
+import { Identity, OptionalIdentity } from "../rpc/identity.ts";
+import { Authenticated, MaybeAuthenticated } from "../rpc/middleware.ts";
+import { type OriginPolicy, originRequest } from "./origin.ts";
+import { transportHeaders } from "./transport.ts";
+
+export interface SessionShape {
+	readonly user: { readonly id: string };
+}
+
+export interface SessionProvider<Session extends SessionShape> {
+	readonly get: (headers: Headers.Headers) => Effect.Effect<Option.Option<Session>, AuthUnavailable>;
+}
+
+export interface SessionPolicy<Session extends SessionShape> {
+	readonly provider: SessionProvider<Session>;
+	readonly origin: OriginPolicy;
+}
+
+export const resolveSession: <Session extends SessionShape>(
+	policy: SessionPolicy<Session>,
+	headers: Headers.Headers,
+	rpc: string,
+) => Effect.Effect<Option.Option<Session>, AuthUnavailable | Forbidden> = Effect.fn("PlatformRpc.resolveSession")(function* <
+	Session extends SessionShape,
+>(policy: SessionPolicy<Session>, headers: Headers.Headers, rpc: string) {
+	const transport = yield* transportHeaders(headers);
+	if (!policy.origin(originRequest(transport, rpc))) return yield* new Forbidden({ message: "Origin not allowed" });
+	return yield* policy.provider.get(transport);
+});
+
+const identified = (id: string) => Effect.andThen(Effect.annotateCurrentSpan("user.id", id), Effect.succeed(id));
+
+export const authenticatedLayer = <Session extends SessionShape>(policy: SessionPolicy<Session>): Layer.Layer<Authenticated> =>
+	Layer.succeed(Authenticated, (effect, { headers, rpc }) =>
+		Effect.gen(function* () {
+			const session = yield* resolveSession(policy, headers, rpc._tag);
+			if (Option.isNone(session)) return yield* new Unauthorized({ message: "Authentication required" });
+			const id = yield* identified(session.value.user.id);
+			return yield* effect.pipe(Effect.provideService(Identity, { id }), Effect.annotateLogs({ userId: id }));
+		}),
+	);
+
+export const maybeAuthenticatedLayer = <Session extends SessionShape>(policy: SessionPolicy<Session>): Layer.Layer<MaybeAuthenticated> =>
+	Layer.succeed(MaybeAuthenticated, (effect, { headers, rpc }) =>
+		Effect.gen(function* () {
+			const session = yield* resolveSession(policy, headers, rpc._tag);
+			if (Option.isNone(session)) return yield* Effect.provideService(effect, OptionalIdentity, Option.none());
+			const id = yield* identified(session.value.user.id);
+			return yield* effect.pipe(Effect.provideService(OptionalIdentity, Option.some({ id })), Effect.annotateLogs({ userId: id }));
+		}),
+	);

package/src/rpc-server/tracing.ts

@@ -0,0 +1,56 @@
+import { Cause, Effect, Layer, Option, Predicate, Random } from "effect";
+import { Headers } from "effect/unstable/http";
+import { RequestId } from "../rpc/identity.ts";
+import { RequestTracing } from "../rpc/middleware.ts";
+import { redact } from "./redact.ts";
+import { redactCause } from "./redact-cause.ts";
+import type { SensitiveKey } from "./sensitive.ts";
+
+export interface RequestTracingOptions {
+	readonly header?: string;
+	readonly sensitive?: SensitiveKey;
+}
+
+const ACCEPTED_REQUEST_ID = /^[A-Za-z0-9._:-]{1,128}$/;
+
+const hex = (byte: number): string => byte.toString(16).padStart(2, "0");
+
+const generateRequestId = Effect.map(Effect.all(Array.from({ length: 16 }, () => Random.nextIntBetween(0, 255))), (bytes) => bytes.map(hex).join(""));
+
+const requestIdOf = (headers: Headers.Headers, header: string): Effect.Effect<string> =>
+	Option.match(
+		Option.filter(Headers.get(headers, header), (value) => ACCEPTED_REQUEST_ID.test(value)),
+		{
+			onNone: () => generateRequestId,
+			onSome: Effect.succeed,
+		},
+	);
+
+const failureTag = (cause: Cause.Cause<unknown>): string =>
+	Option.match(Cause.findErrorOption(cause), {
+		onNone: () => "unknown",
+		onSome: (error) => (Predicate.hasProperty(error, "_tag") && Predicate.isString(error._tag) ? error._tag : "unknown"),
+	});
+
+const logFailure = (cause: Cause.Cause<unknown>, payload: unknown, sensitive: SensitiveKey | undefined): Effect.Effect<void> => {
+	if (Cause.hasInterruptsOnly(cause)) return Effect.void;
+	const annotations = { "rpc.payload": redact(payload, sensitive) };
+	if (!Cause.hasDies(cause)) return Effect.annotateLogs(Effect.logInfo("RPC failure"), { ...annotations, "rpc.failure": failureTag(cause) });
+	const defects = cause.reasons.filter(Cause.isDieReason).map((reason) => redact(reason.defect, sensitive));
+	return Effect.annotateLogs(Effect.logError("RPC defect"), { ...annotations, "rpc.defect": defects });
+};
+
+export const requestTracingLayer = (options: RequestTracingOptions = {}): Layer.Layer<RequestTracing> =>
+	Layer.succeed(RequestTracing, (effect, { headers, payload, rpc }) =>
+		Effect.gen(function* () {
+			const requestId = yield* requestIdOf(headers, options.header ?? "x-request-id");
+			yield* Effect.annotateCurrentSpan({ "request.id": requestId, "rpc.method": rpc._tag });
+			return yield* effect.pipe(
+				Effect.catchCauseIf(Cause.hasDies, (cause) => Effect.failCause(redactCause(cause, options.sensitive))),
+				Effect.tapCause((cause) => logFailure(cause, payload, options.sensitive)),
+				Effect.provideService(RequestId, requestId),
+				Effect.annotateLogs({ requestId, "rpc.method": rpc._tag }),
+				Effect.withLogSpan("rpc.duration"),
+			);
+		}),
+	);

package/src/rpc-server/transport.ts

@@ -0,0 +1,8 @@
+import { Effect, Option } from "effect";
+import { type Headers, HttpServerRequest } from "effect/unstable/http";
+
+export const transportHeaders = (rpcHeaders: Headers.Headers): Effect.Effect<Headers.Headers> =>
+	Effect.map(
+		Effect.serviceOption(HttpServerRequest.HttpServerRequest),
+		Option.match({ onNone: () => rpcHeaders, onSome: (request) => request.headers }),
+	);

package/src/rpc-server.ts

@@ -0,0 +1,15 @@
+export { betterAuthSessions, type GetSession } from "./rpc-server/adapters/better-auth-sessions.ts";
+export { type OriginPolicy, type OriginRequest, type TrustedOriginsOptions, trustedOrigins } from "./rpc-server/origin.ts";
+export { redact } from "./rpc-server/redact.ts";
+export { redactCause, redactDefect, redactingErrorReporter } from "./rpc-server/redact-cause.ts";
+export { isSensitiveKey, type SensitiveKey } from "./rpc-server/sensitive.ts";
+export {
+	authenticatedLayer,
+	maybeAuthenticatedLayer,
+	resolveSession,
+	type SessionPolicy,
+	type SessionProvider,
+	type SessionShape,
+} from "./rpc-server/session.ts";
+export { type RequestTracingOptions, requestTracingLayer } from "./rpc-server/tracing.ts";
+export { transportHeaders } from "./rpc-server/transport.ts";

package/src/rpc.ts

@@ -0,0 +1,2 @@
+export { Identity, type IdentityValue, OptionalIdentity, RequestId } from "./rpc/identity.ts";
+export { Authenticated, MaybeAuthenticated, RequestTracing } from "./rpc/middleware.ts";

package/src/runtime/make.ts

@@ -1,20 +1,20 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import type { Layer } from "effect";
-import { Cause, Context, Effect, Exit, ManagedRuntime } from "effect";
-import type { PlatformRuntime, PlatformRuntimeOptions } from "./types.js";
+import { Cause, Config, Context, Effect, Exit, ManagedRuntime } from "effect";
+import type { PlatformRuntime, PlatformRuntimeOptions } from "./types.ts";
 
 const RuntimeCacheKey = Symbol.for("@shivaedev/platform/runtime-cache");
-const globalRuntimeCache = globalThis as typeof globalThis & {
-	[RuntimeCacheKey]?: Map<string | symbol, PlatformRuntime<unknown, unknown>>;
-};
-const runtimeCache =
-	globalRuntimeCache[RuntimeCacheKey] ??
-	new Map<string | symbol, PlatformRuntime<unknown, unknown>>();
-globalRuntimeCache[RuntimeCacheKey] = runtimeCache;
+const sharedCache: unknown = Reflect.get(globalThis, RuntimeCacheKey);
+const runtimeCache: Map<string | symbol, unknown> = sharedCache instanceof Map ? sharedCache : new Map<string | symbol, unknown>();
+Reflect.set(globalThis, RuntimeCacheKey, runtimeCache);
 
-const make = <Services, BuildError>(
-	layer: Layer.Layer<Services, BuildError>,
-): PlatformRuntime<Services, BuildError> => {
+// One development cache key belongs to one makePlatformRuntime call site, so its entry has that site's services and build error.
+function cachedEntry<Services, BuildError>(runtime: unknown): PlatformRuntime<Services, BuildError>;
+function cachedEntry(runtime: unknown): unknown {
+	return runtime;
+}
+
+const make = <Services, BuildError>(layer: Layer.Layer<Services, BuildError>): PlatformRuntime<Services, BuildError> => {
 	const managed = ManagedRuntime.make(layer);
 	const services = new AsyncLocalStorage<Context.Context<never>>();
 
@@ -25,15 +25,10 @@ const make = <Services, BuildError>(
 		const ambient = currentServices();
 		return ambient === undefined
 			? effect
-			: Effect.flatMap(managed.contextEffect, (base) =>
-					Effect.provideContext(effect, Context.merge(base, ambient)),
-				);
+			: Effect.flatMap(managed.contextEffect, (base) => Effect.provideContext(effect, Context.merge(base, ambient)));
 	};
 
-	const runPromiseExit: PlatformRuntime<
-		Services,
-		BuildError
-	>["runPromiseExit"] = (effect, options) =>
+	const runPromiseExit: PlatformRuntime<Services, BuildError>["runPromiseExit"] = (effect, options) =>
 		managed.runPromiseExit(withAmbient(effect), options);
 
 	const runtime: PlatformRuntime<Services, BuildError> = {
@@ -49,26 +44,24 @@ const make = <Services, BuildError>(
 			throw Cause.squash(exit.cause);
 		},
 		runPromiseExit,
-		runWithServices: (context, evaluate) =>
-			services.run(context as Context.Context<never>, evaluate),
+		runWithServices: (context, evaluate) => services.run(context, evaluate),
 	};
 
 	return runtime;
 };
 
+const production = Effect.map(Effect.orDie(Config.string("NODE_ENV").pipe(Config.withDefault(""))), (environment) => environment === "production");
+
 export const makePlatformRuntime = <Services, BuildError>(
 	layer: Layer.Layer<Services, BuildError>,
 	options: PlatformRuntimeOptions = {},
 ): PlatformRuntime<Services, BuildError> => {
-	const key =
-		process.env.NODE_ENV === "production"
-			? undefined
-			: options.developmentCacheKey;
+	const key = Effect.runSync(production) ? undefined : options.developmentCacheKey;
 	if (key === undefined) return make(layer);
 
 	const cached = runtimeCache.get(key);
 	if (cached !== undefined) {
-		return cached as PlatformRuntime<Services, BuildError>;
+		return cachedEntry<Services, BuildError>(cached);
 	}
 
 	const runtime = make(layer);
@@ -79,6 +72,6 @@ export const makePlatformRuntime = <Services, BuildError>(
 			await runtime.dispose();
 		},
 	};
-	runtimeCache.set(key, cachedRuntime as PlatformRuntime<unknown, unknown>);
+	runtimeCache.set(key, cachedRuntime);
 	return cachedRuntime;
 };

package/src/runtime/types.ts

@@ -17,18 +17,9 @@ export interface PlatformRuntime<Services, BuildError> {
 		effect: Effect.Effect<A, E, Requirements>,
 		options?: { readonly signal?: AbortSignal },
 	) => Promise<Exit.Exit<A, E | BuildError>>;
-	readonly runWithServices: <Provided, Value>(
-		services: Context.Context<Provided>,
-		evaluate: () => Value,
-	) => Value;
+	readonly runWithServices: <Provided, Value>(services: Context.Context<Provided>, evaluate: () => Value) => Value;
 }
 
-export type PlatformRuntimeServices<Runtime> =
-	Runtime extends PlatformRuntime<infer Services, infer _BuildError>
-		? Services
-		: never;
+export type PlatformRuntimeServices<Runtime> = Runtime extends PlatformRuntime<infer Services, infer _BuildError> ? Services : never;
 
-export type PlatformRuntimeBuildError<Runtime> =
-	Runtime extends PlatformRuntime<infer _Services, infer BuildError>
-		? BuildError
-		: never;
+export type PlatformRuntimeBuildError<Runtime> = Runtime extends PlatformRuntime<infer _Services, infer BuildError> ? BuildError : never;

package/src/runtime.ts

@@ -1,7 +1,7 @@
-export { makePlatformRuntime } from "./runtime/make.js";
+export { makePlatformRuntime } from "./runtime/make.ts";
 export type {
 	PlatformRuntime,
 	PlatformRuntimeBuildError,
 	PlatformRuntimeOptions,
 	PlatformRuntimeServices,
-} from "./runtime/types.js";
+} from "./runtime/types.ts";

package/src/testing/types.ts

@@ -1,43 +1,21 @@
 import type { TestContext, Vitest } from "@effect/vitest";
-import type {
-	AnyDatabase,
-	DatabaseService,
-} from "@shivaedev/effect-prisma/testing";
+import type { AnyDatabase, DatabaseService } from "@shivaedev/effect-prisma/testing";
 import type { EffectTRPCAdapter } from "@shivaedev/effect-trpc";
-import type {
-	CallerOptions,
-	CallerResult,
-	EffectCallerFactory,
-	TrpcHarnessTest,
-	TrpcHarnessTester,
-} from "@shivaedev/effect-trpc/testing";
+import type { CallerOptions, CallerResult, EffectCallerFactory, TrpcHarnessTest, TrpcHarnessTester } from "@shivaedev/effect-trpc/testing";
 import type { Effect, Layer } from "effect";
 
-export type PlatformHarness<
-	Database extends AnyDatabase,
-	Options,
-	Caller,
-	Extension,
-> = Readonly<{
+export type PlatformHarness<Database extends AnyDatabase, Options, Caller, Extension> = Readonly<{
 	db: DatabaseService<Database>;
 	trpc: EffectCallerFactory<Options, Caller>;
 }> &
 	Readonly<{
-		promise: <Value>(
-			evaluate: () => Promise<Value>,
-		) => Effect.Effect<Value, unknown>;
+		promise: <Value>(evaluate: () => Promise<Value>) => Effect.Effect<Value, unknown>;
 	}> &
 	Omit<Extension, "db" | "promise" | "trpc">;
 
-export type PlatformTest<Harness, Provided> = TrpcHarnessTest<
-	Harness,
-	Provided
->;
+export type PlatformTest<Harness, Provided> = TrpcHarnessTest<Harness, Provided>;
 
-export type PlatformTester<Harness, Provided> = TrpcHarnessTester<
-	Harness,
-	Provided
->;
+export type PlatformTester<Harness, Provided> = TrpcHarnessTester<Harness, Provided>;
 
 export type PlatformIt<Harness, Provided> = Vitest.Methods & {
 	readonly effectApp: PlatformTester<Harness, Provided>;
@@ -55,10 +33,7 @@ export interface MakePlatformItOptions<
 	readonly extend?: (
 		base: Readonly<{
 			db: DatabaseService<Database>;
-			trpc: EffectCallerFactory<
-				CallerOptions<NoInfer<CreateCaller>>,
-				CallerResult<NoInfer<CreateCaller>>
-			>;
+			trpc: EffectCallerFactory<CallerOptions<NoInfer<CreateCaller>>, CallerResult<NoInfer<CreateCaller>>>;
 		}>,
 		context: TestContext,
 	) => Effect.Effect<Extension, unknown, Provided | Effect.Services<Database>>;