@shivaedev/contract 0.0.0 → 0.16.0

package/src/internal/queryReactivity.ts

@@ -0,0 +1,109 @@
+import { Duration, Effect } from "effect";
+import * as AsyncResult from "effect/reactivity/AsyncResult";
+import * as Atom from "effect/reactivity/Atom";
+import type * as AtomRegistry from "effect/reactivity/AtomRegistry";
+import * as Reactivity from "effect/reactivity/Reactivity";
+import { queryCoalesceWindow } from "#queryCoalesceWindow.ts";
+import { liveBatches, liveKeys } from "./liveInvalidation.ts";
+
+export function queryReactivity<R, E>(runtime: Atom.AtomRuntime<R, E>) {
+	const service = runtime.atom(Effect.service(Reactivity.Reactivity));
+	type Query = Atom.Atom<AsyncResult.AsyncResult<unknown, unknown>>;
+	const cached = new WeakMap<Query, Query>();
+	return (
+		atom: Query,
+		keys: readonly string[],
+		track: (registry: AtomRegistry.AtomRegistry) => () => void,
+		owner?: AtomRegistry.AtomRegistry,
+	): Query => {
+		const existing = cached.get(atom);
+		if (existing !== undefined) {
+			return existing;
+		}
+		const source = Atom.setIdleTTL(
+			Atom.readable((get) => atom.read(get), atom.refresh),
+			0,
+		);
+		let wrapped = Atom.transform(
+			source,
+			(get) => {
+				if (owner !== undefined && owner !== get.registry) {
+					throw new Error("A session-scoped query belongs to its binding registry");
+				}
+				const context = get(service);
+				if (!AsyncResult.isSuccess(context)) {
+					return get(source);
+				}
+				const reactivity = context.value;
+				get.addFinalizer(track(get.registry));
+				let pending: (() => boolean) | undefined;
+				let timer: ReturnType<typeof setTimeout> | undefined;
+				function clear() {
+					clearTimeout(timer);
+					timer = undefined;
+					pending = undefined;
+				}
+				function refresh(active: () => boolean) {
+					if (!active()) {
+						return;
+					}
+					if (get.once(source).waiting) {
+						pending = active;
+					} else {
+						pending = undefined;
+						get.refresh(source);
+					}
+				}
+				function changed() {
+					const batch = liveBatches.get(reactivity);
+					if (batch === undefined || batch.seen.has(changed)) {
+						return;
+					}
+					batch.seen.add(changed);
+					const delay = Duration.toMillis(Duration.fromInputUnsafe(get.once(queryCoalesceWindow(wrapped)) ?? batch.window ?? 0));
+					if (delay === 0) {
+						clear();
+						get.refresh(source);
+					} else {
+						timer ??= setTimeout(() => {
+							timer = undefined;
+							refresh(batch.active);
+						}, delay);
+					}
+				}
+				get.addFinalizer(clear);
+				get.addFinalizer(reactivity.registerUnsafe(liveKeys(keys), changed));
+				get.addFinalizer(
+					reactivity.registerUnsafe(keys, () => {
+						if (!liveBatches.has(reactivity)) {
+							clear();
+							get.refresh(source);
+						}
+					}),
+				);
+				get.subscribe(source, (value) => {
+					get.setSelf(value);
+					if (pending !== undefined && !value.waiting) {
+						const active = pending;
+						pending = undefined;
+						if (active()) {
+							get.refresh(source);
+						}
+					}
+				});
+				return get.once(source);
+			},
+			{ initialValueTarget: source },
+		);
+		if (atom.keepAlive) {
+			wrapped = Atom.keepAlive(wrapped);
+		} else if (atom.idleTTL !== undefined) {
+			wrapped = Atom.setIdleTTL(wrapped, atom.idleTTL);
+		}
+		if (Atom.isSerializable(atom)) {
+			Object.assign(wrapped, { [Atom.SerializableTypeId]: atom[Atom.SerializableTypeId] });
+		}
+		cached.set(atom, wrapped);
+		return wrapped;
+	};
+}

package/src/keys.ts

@@ -0,0 +1,62 @@
+import { Schema } from "effect";
+
+export type Identity = string | number;
+
+export interface ListKey<TName extends string = string> {
+	readonly _tag: "List";
+	readonly collection: TName;
+}
+
+export interface ItemKey<TName extends string = string> {
+	readonly _tag: "Item";
+	readonly collection: TName;
+	readonly id: Identity;
+}
+
+export type Key = ListKey | ItemKey;
+
+export const Key = Schema.Union([
+	Schema.Struct({ _tag: Schema.Literal("List"), collection: Schema.String }),
+	Schema.Struct({ _tag: Schema.Literal("Item"), collection: Schema.String, id: Schema.Union([Schema.String, Schema.Number]) }),
+]);
+
+export interface Collection<TName extends string, TId extends Identity> {
+	readonly item: (id: TId) => ItemKey<TName>;
+	readonly list: ListKey<TName>;
+	readonly name: TName;
+}
+
+export function collection<const TName extends string, TId extends Schema.Top & { readonly Type: Identity }>(
+	name: TName,
+	_id: TId,
+): Collection<TName, TId["Type"]> {
+	return {
+		item: (id) => ({ _tag: "Item", collection: name, id }),
+		list: { _tag: "List", collection: name },
+		name,
+	};
+}
+
+export interface KeyContext {
+	readonly scope: string;
+}
+
+function contextual(key: string, context?: KeyContext): string {
+	return context === undefined ? key : `${JSON.stringify(["session", context.scope])}:${key}`;
+}
+
+function own(key: Key): string {
+	return key._tag === "List" ? key.collection : `${key.collection}:${key.id}`;
+}
+
+export function readKeys(keys: readonly Key[], context?: KeyContext): readonly string[] {
+	return [...new Set(keys.flatMap((key) => (key._tag === "Item" ? [own(key), `${key.collection}:*`] : [own(key)])))].map((key) =>
+		contextual(key, context),
+	);
+}
+
+export function invalidationKeys(keys: readonly Key[], context?: KeyContext): readonly string[] {
+	return [...new Set(keys.flatMap((key) => (key._tag === "List" ? [key.collection] : [own(key), key.collection])))].map((key) =>
+		contextual(key, context),
+	);
+}

package/src/live.ts

@@ -0,0 +1,122 @@
+import { type Cause, Duration, Effect, Option, Schema, Stream } from "effect";
+import * as Atom from "effect/reactivity/Atom";
+import type * as AtomRegistry from "effect/reactivity/AtomRegistry";
+import * as Reactivity from "effect/reactivity/Reactivity";
+import { invalidateLive } from "#internal/liveInvalidation.ts";
+import { invalidationKeys, Key, type KeyContext, readKeys } from "#keys.ts";
+
+export const LiveHint = Schema.Union([
+	Schema.Struct({ _tag: Schema.Literal("Changed"), keys: Schema.Array(Key) }),
+	Schema.Struct({ _tag: Schema.Literal("Resync") }),
+]);
+export type LiveHint = typeof LiveHint.Type;
+export interface LiveStatus<E> {
+	readonly connection: "connecting" | "live" | "reconnecting";
+	readonly failure: Option.Option<Cause.Cause<E>>;
+	readonly needsResync: boolean;
+	readonly pending: number;
+}
+export interface LiveOptions<E, R> {
+	readonly coalesceWindow?: Duration.Input;
+	readonly keyContext?: KeyContext | undefined;
+	readonly resume?: Atom.Atom<unknown>;
+	readonly resyncKeys: readonly Key[] | ((registry: AtomRegistry.AtomRegistry) => readonly Key[]);
+	readonly retryDelay?: Duration.Input;
+	readonly stream: Stream.Stream<LiveHint, E, R>;
+}
+
+const MAX_PENDING = 256;
+
+export function live<R, E, TRuntimeError>(runtime: Atom.AtomRuntime<R, TRuntimeError>, options: LiveOptions<E, R>) {
+	const coalesceWindow = Atom.keepAlive(Atom.make<Duration.Input>(options.coalesceWindow ?? "20 millis"));
+	const paused = Atom.make(false);
+	const status = Atom.make<LiveStatus<E>>({ connection: "connecting", failure: Option.none(), needsResync: true, pending: 0 });
+	const connection = runtime
+		.atom((get) =>
+			Effect.gen(function* () {
+				get.mount(status);
+				const reactivity = yield* Reactivity.Reactivity;
+				function update(value: Partial<LiveStatus<E>>) {
+					get.set(status, { ...get.once(status), ...value });
+				}
+				const pending = new Set<string>();
+				let timer: ReturnType<typeof setTimeout> | undefined;
+				function clear() {
+					clearTimeout(timer);
+					timer = undefined;
+					pending.clear();
+				}
+				let active = true;
+				get.addFinalizer(() => {
+					active = false;
+					clear();
+				});
+				function changed(changedKeys: readonly Key[]) {
+					const window = get.once(coalesceWindow);
+					const keys = invalidationKeys(changedKeys, options.keyContext);
+					invalidateLive(reactivity, keys, () => active && !get.once(paused), window);
+					const delay = Duration.toMillis(Duration.fromInputUnsafe(window));
+					if (delay === 0) {
+						invalidateLive(reactivity, keys, () => active && !get.once(paused));
+						return;
+					}
+					for (const key of invalidationKeys(changedKeys, options.keyContext)) {
+						pending.add(key);
+					}
+					timer ??= setTimeout(() => {
+						const queued = [...pending];
+						clear();
+						if (!get.once(paused)) {
+							invalidateLive(reactivity, queued, () => active && !get.once(paused));
+						}
+					}, delay);
+				}
+				function resync() {
+					clear();
+					if (get.once(paused)) {
+						update({ needsResync: true });
+						return;
+					}
+					const keys = typeof options.resyncKeys === "function" ? options.resyncKeys(get.registry) : options.resyncKeys;
+					reactivity.invalidateUnsafe(keys.map((key) => readKeys([key], options.keyContext)[0] ?? ""));
+					update({ needsResync: false, pending: 0 });
+				}
+				// A subscription alone does not build the flag, so its first read would otherwise announce a change.
+				get.once(paused);
+				get.subscribe(paused, (value) => {
+					if (!value) {
+						resync();
+					}
+				});
+				if (options.resume !== undefined) {
+					// A subscription alone does not initialize a derived signal's dependencies.
+					get.once(options.resume);
+					get.subscribe(options.resume, resync);
+				}
+				const attempt = Effect.suspend(() => {
+					let isFirst = true;
+					function observe(hint: LiveHint) {
+						update({ connection: "live", failure: Option.none() });
+						if (get.once(paused)) {
+							update({ needsResync: true, pending: Math.min(MAX_PENDING, get.once(status).pending + 1) });
+						} else if (isFirst || hint._tag === "Resync") {
+							resync();
+						} else {
+							changed(hint.keys);
+						}
+						isFirst = false;
+					}
+					return options.stream.pipe(
+						Stream.runForEach((hint) => Effect.sync(() => observe(hint))),
+						Effect.scoped,
+						Effect.catchCause((failure) => Effect.sync(() => update({ failure: Option.some(failure) }))),
+						Effect.andThen(Effect.sync(() => update({ connection: "reconnecting", needsResync: true }))),
+						Effect.andThen(Effect.sleep(options.retryDelay ?? "1 second")),
+					);
+				});
+				yield* Effect.forever(attempt);
+			}),
+		)
+		.pipe(Atom.setIdleTTL(0));
+	return { coalesceWindow, connection, paused, status };
+}

package/src/makeLiveServer.ts

@@ -0,0 +1,76 @@
+import { Effect, Queue, Stream } from "effect";
+import * as Reactivity from "effect/reactivity/Reactivity";
+import { makeHintPolicy } from "#internal/makeHintPolicy.ts";
+import { type Key, type KeyContext, readKeys } from "#keys.ts";
+import type { LiveHint } from "#live.ts";
+
+export const makeLiveServer = Effect.gen(function* () {
+	const reactivity = yield* Reactivity.Reactivity;
+	let openStreams = 0;
+	const resyncKey = `@shivaedev/contract/resync/${crypto.randomUUID()}`;
+	function stream(keys: readonly Key[], context?: KeyContext) {
+		return Stream.unwrap(
+			Effect.gen(function* () {
+				const queue = yield* Queue.unbounded<LiveHint>();
+				const allowedKeys = yield* makeHintPolicy(keys.length, (retryKeys) =>
+					Queue.offer(queue, { _tag: "Changed", keys: retryKeys }).pipe(Effect.asVoid),
+				);
+				const pending = new Map<string, Key>();
+				let scheduled = false;
+				let resync = false;
+				let active = true;
+				function flush() {
+					if (scheduled) {
+						return;
+					}
+					scheduled = true;
+					queueMicrotask(() => {
+						scheduled = false;
+						if (active) {
+							Queue.offerUnsafe(queue, resync ? { _tag: "Resync" } : { _tag: "Changed", keys: [...pending.values()] });
+						}
+						pending.clear();
+						resync = false;
+					});
+				}
+				const cancel = keys.map((key) => {
+					const own = readKeys([key], context);
+					return reactivity.registerUnsafe(own, () => {
+						pending.set(own[0] ?? "", key);
+						flush();
+					});
+				});
+				cancel.push(
+					reactivity.registerUnsafe([resyncKey], () => {
+						resync = true;
+						flush();
+					}),
+				);
+				openStreams += 1;
+				yield* Effect.addFinalizer(() =>
+					Effect.sync(() => {
+						active = false;
+						openStreams -= 1;
+						for (const stop of cancel) {
+							stop();
+						}
+					}),
+				);
+				yield* Queue.offer(queue, { _tag: "Resync" });
+				return Stream.fromQueue(queue).pipe(
+					Stream.mapEffect((hint) =>
+						hint._tag === "Resync"
+							? Effect.succeed(hint)
+							: Effect.map(allowedKeys(hint.keys), (allowed): LiveHint => ({ _tag: "Changed", keys: allowed })),
+					),
+					Stream.filter((hint) => hint._tag === "Resync" || hint.keys.length > 0),
+				);
+			}),
+		);
+	}
+	const resync = Effect.sync(() => {
+		reactivity.invalidateUnsafe([resyncKey]);
+		return openStreams;
+	});
+	return { resync, stream };
+});

package/src/operation.ts

@@ -0,0 +1,145 @@
+import { Schema } from "effect";
+import type { Bivariant } from "@shivaedev/types/Bivariant.ts";
+import type { Key } from "./keys.ts";
+import { type MatchingTags, type Reject, type RejectionSpecs, type Rejections, type RejectionUnion, rejectionSet } from "./rejection.ts";
+
+export type PayloadSchema<TPayload extends Schema.Top | Schema.Struct.Fields> = TPayload extends Schema.Struct.Fields
+	? Schema.Struct<TPayload>
+	: TPayload;
+
+type NoRejections = Record<never, never>;
+
+export interface OperationShape {
+	readonly error: Schema.Top;
+	readonly kind: "query" | "command" | "stream";
+	readonly name: string;
+	readonly payload: Schema.Top;
+	readonly Rejection: object;
+	readonly reject: object;
+	readonly rejections: RejectionSpecs;
+	readonly success: Schema.Top;
+}
+
+export interface QueryShape extends OperationShape {
+	readonly kind: "query";
+	reads: Bivariant<(payload: unknown) => readonly Key[]>;
+}
+
+export interface StreamShape extends OperationShape {
+	readonly kind: "stream";
+	reads: Bivariant<(payload: unknown) => readonly Key[]>;
+}
+
+export interface CommandShape extends OperationShape {
+	invalidates: Bivariant<(payload: unknown, result: unknown) => readonly Key[]>;
+	readonly kind: "command";
+}
+
+interface Operation<TName extends string, TPayload extends Schema.Top, TSuccess extends Schema.Top, TSpecs extends RejectionSpecs>
+	extends OperationShape {
+	readonly error: RejectionUnion<TSpecs>;
+	readonly name: TName;
+	readonly payload: TPayload;
+	readonly Rejection: Rejections<TSpecs>;
+	readonly reject: Reject<TSpecs>;
+	readonly rejections: TSpecs;
+	readonly success: TSuccess;
+}
+
+export interface Query<TName extends string, TPayload extends Schema.Top, TSuccess extends Schema.Top, TSpecs extends RejectionSpecs>
+	extends Operation<TName, TPayload, TSuccess, TSpecs> {
+	readonly kind: "query";
+	reads: (payload: TPayload["Type"]) => readonly Key[];
+}
+
+export interface Streaming<TName extends string, TPayload extends Schema.Top, TSuccess extends Schema.Top, TSpecs extends RejectionSpecs>
+	extends Operation<TName, TPayload, TSuccess, TSpecs> {
+	readonly kind: "stream";
+	reads: (payload: TPayload["Type"]) => readonly Key[];
+}
+
+export interface Command<TName extends string, TPayload extends Schema.Top, TSuccess extends Schema.Top, TSpecs extends RejectionSpecs>
+	extends Operation<TName, TPayload, TSuccess, TSpecs> {
+	invalidates: (payload: TPayload["Type"], result: TSuccess["Type"]) => readonly Key[];
+	readonly kind: "command";
+}
+
+interface Declaration<TPayload extends Schema.Top | Schema.Struct.Fields, TSuccess extends Schema.Top, TSpecs extends RejectionSpecs> {
+	readonly payload?: TPayload;
+	readonly rejections?: TSpecs & MatchingTags<TSpecs>;
+	readonly success?: TSuccess;
+}
+
+interface Loose {
+	readonly payload?: Schema.Top | Schema.Struct.Fields;
+	readonly rejections?: RejectionSpecs;
+	readonly success?: Schema.Top;
+}
+
+function payloadSchema(payload: Loose["payload"]): Schema.Top {
+	if (payload === undefined) {
+		return Schema.Void;
+	}
+	return Schema.isSchema(payload) ? payload : Schema.Struct(payload);
+}
+
+function operation<TKind extends OperationShape["kind"]>(kind: TKind, name: string, declaration: Loose) {
+	const { payload, success, rejections = {} } = declaration;
+	return {
+		kind,
+		name,
+		payload: payloadSchema(payload),
+		rejections,
+		success: success ?? Schema.Void,
+		...rejectionSet(rejections),
+	};
+}
+
+export function query<
+	const TName extends string,
+	TPayload extends Schema.Top | Schema.Struct.Fields = Schema.Void,
+	TSuccess extends Schema.Top = Schema.Void,
+	const TSpecs extends RejectionSpecs = NoRejections,
+>(
+	name: TName,
+	declaration: Declaration<TPayload, TSuccess, TSpecs> & {
+		readonly reads: (payload: PayloadSchema<TPayload>["Type"]) => readonly Key[];
+	},
+): NoInfer<Query<TName, PayloadSchema<TPayload>, TSuccess, TSpecs>>;
+export function query(name: string, declaration: Loose & { readonly reads: (payload: unknown) => readonly Key[] }): QueryShape {
+	return { ...operation("query", name, declaration), reads: declaration.reads };
+}
+
+export function command<
+	const TName extends string,
+	TPayload extends Schema.Top | Schema.Struct.Fields = Schema.Void,
+	TSuccess extends Schema.Top = Schema.Void,
+	const TSpecs extends RejectionSpecs = NoRejections,
+>(
+	name: TName,
+	declaration: Declaration<TPayload, TSuccess, TSpecs> & {
+		readonly invalidates: (payload: PayloadSchema<TPayload>["Type"], result: TSuccess["Type"]) => readonly Key[];
+	},
+): NoInfer<Command<TName, PayloadSchema<TPayload>, TSuccess, TSpecs>>;
+export function command(
+	name: string,
+	declaration: Loose & { readonly invalidates: (payload: unknown, result: unknown) => readonly Key[] },
+): CommandShape {
+	return { ...operation("command", name, declaration), invalidates: declaration.invalidates };
+}
+
+export function stream<
+	const TName extends string,
+	TPayload extends Schema.Top | Schema.Struct.Fields = Schema.Void,
+	TSuccess extends Schema.Top = Schema.Void,
+	const TSpecs extends RejectionSpecs = NoRejections,
+>(
+	name: TName,
+	declaration: Declaration<TPayload, TSuccess, TSpecs> & {
+		readonly success: TSuccess;
+		readonly reads: (payload: PayloadSchema<TPayload>["Type"]) => readonly Key[];
+	},
+): NoInfer<Streaming<TName, PayloadSchema<TPayload>, TSuccess, TSpecs>>;
+export function stream(name: string, declaration: Loose & { readonly reads: (payload: unknown) => readonly Key[] }): StreamShape {
+	return { ...operation("stream", name, declaration), reads: declaration.reads };
+}

package/src/publicConfig.ts

@@ -0,0 +1,9 @@
+import type { Schema } from "effect";
+import { contract } from "#contract.ts";
+import { query } from "#operation.ts";
+
+export function publicConfig<T, E>(schema: Schema.Codec<T, E>) {
+	return contract("platform.publicConfig", {
+		queries: [query("get", { reads: () => [], success: schema })],
+	});
+}

package/src/queryCoalesceWindow.ts

@@ -0,0 +1,13 @@
+import type { Duration } from "effect";
+import * as Atom from "effect/reactivity/Atom";
+
+const windows = new WeakMap<Atom.Atom<unknown>, Atom.Writable<Duration.Input | undefined>>();
+
+export function queryCoalesceWindow<A>(query: Atom.Atom<A>): Atom.Writable<Duration.Input | undefined> {
+	let window = windows.get(query);
+	if (window === undefined) {
+		window = Atom.keepAlive(Atom.make<Duration.Input | undefined>(undefined));
+		windows.set(query, window);
+	}
+	return window;
+}

package/src/readPolicy.ts

@@ -0,0 +1,33 @@
+import { Context, type Duration, Effect, Option } from "effect";
+import type { Rpc } from "effect/rpc";
+import type { Key } from "./keys.ts";
+import { QueryReads } from "./serverMetadata.ts";
+
+export const ReadPolicy = Context.Reference<(key: Key) => Effect.Effect<boolean, unknown>>("@shivaedev/contract/ReadPolicy", {
+	defaultValue: () => () => Effect.succeed(true),
+});
+
+export const ReadPolicyMemoWindow = Context.Reference<Duration.Input>("@shivaedev/contract/ReadPolicyMemoWindow", {
+	defaultValue: () => "1 second",
+});
+
+export const authorizeReads = Effect.fnUntraced(function* <A, E, R, TPolicyServices, TDenied, TPolicyError>(
+	effect: Effect.Effect<A, E, R>,
+	request: { readonly rpc: Rpc.AnyWithProps; readonly payload: unknown },
+	policy: (key: Key) => Effect.Effect<boolean, TPolicyError, TPolicyServices>,
+	denied: Effect.Effect<never, TDenied>,
+) {
+	const context = yield* Effect.context<TPolicyServices>();
+	function canRead(key: Key) {
+		return Effect.provideContext(policy(key), context);
+	}
+	const reads = Context.getOption(request.rpc.annotations, QueryReads);
+	if (Option.isSome(reads)) {
+		for (const key of reads.value(request.payload)) {
+			if (!(yield* canRead(key))) {
+				return yield* denied;
+			}
+		}
+	}
+	return yield* Effect.provideService(effect, ReadPolicy, canRead);
+});

package/src/rejection.ts

@@ -0,0 +1,91 @@
+import { type Cause, Effect, Schema } from "effect";
+
+export type RejectionValue<TTag extends string, TFields extends Schema.Struct.Fields> = Schema.TaggedStruct<TTag, TFields>["Type"] &
+	Cause.YieldableError;
+
+export type RejectionClass<TTag extends string, TFields extends Schema.Struct.Fields> = Schema.Class<
+	RejectionValue<TTag, TFields>,
+	Schema.TaggedStruct<TTag, TFields>,
+	Cause.YieldableError
+>;
+
+export type TaggedRejection = Schema.Top & (new (...args: never) => { readonly _tag: string });
+
+export interface RejectionSpecs {
+	readonly [tag: string]: Schema.Struct.Fields | TaggedRejection;
+}
+
+export type Rejections<TSpecs extends RejectionSpecs> = {
+	readonly [TTag in keyof TSpecs & string]: TSpecs[TTag] extends TaggedRejection
+		? TSpecs[TTag]
+		: TSpecs[TTag] extends Schema.Struct.Fields
+			? RejectionClass<TTag, TSpecs[TTag]>
+			: never;
+};
+
+export type RejectedBy<TSpecs extends RejectionSpecs> = {
+	[TTag in keyof TSpecs & string]: Rejections<TSpecs>[TTag]["Type"];
+}[keyof TSpecs & string];
+
+export type Reject<TSpecs extends RejectionSpecs> = {
+	readonly [TTag in keyof TSpecs & string]: Rejections<TSpecs>[TTag] extends new (
+		...args: infer TArguments
+	) => infer TValue
+		? (...args: TArguments) => Effect.Effect<never, TValue>
+		: never;
+};
+
+export type RejectionUnion<TSpecs extends RejectionSpecs> = [keyof TSpecs & string] extends [never]
+	? Schema.Never
+	: Schema.Union<readonly Rejections<TSpecs>[keyof TSpecs & string][]>;
+
+export type MatchingTags<TSpecs extends RejectionSpecs> = {
+	readonly [TTag in keyof TSpecs]: TSpecs[TTag] extends TaggedRejection
+		? TSpecs[TTag]["Type"] extends { readonly _tag: TTag }
+			? TSpecs[TTag]
+			: `The rejection class under "${TTag & string}" must have that _tag`
+		: TSpecs[TTag];
+};
+
+export interface RejectionSet<TSpecs extends RejectionSpecs> {
+	readonly error: RejectionUnion<TSpecs>;
+	readonly Rejection: Rejections<TSpecs>;
+	readonly reject: Reject<TSpecs>;
+}
+
+interface LooseRejectionSet {
+	readonly error: Schema.Top;
+	readonly Rejection: { readonly [tag: string]: TaggedRejection };
+	readonly reject: { readonly [tag: string]: (...args: readonly unknown[]) => Effect.Effect<never, unknown> };
+}
+
+export function rejectionSet<const TSpecs extends RejectionSpecs>(specs: TSpecs): RejectionSet<TSpecs>;
+export function rejectionSet(specs: RejectionSpecs): LooseRejectionSet {
+	const classes = Object.entries(specs).map(([tag, spec]): readonly [string, TaggedRejection] => [
+		tag,
+		Schema.isSchema(spec) ? spec : Schema.TaggedError<Cause.YieldableError>()(tag, spec),
+	]);
+	return {
+		error: classes.length === 0 ? Schema.Never : Schema.Union(classes.map(([, schema]) => schema)),
+		Rejection: Object.fromEntries(classes),
+		reject: Object.fromEntries(
+			classes.map(([tag, Rejection]) => [tag, (...args: readonly unknown[]) => Effect.fail(Reflect.construct(Rejection, args))]),
+		),
+	};
+}
+
+export type FieldRejection<TField extends string> = Readonly<{
+	field: Schema.Literals<readonly TField[]>;
+	message: Schema.String;
+}>;
+
+export function fieldRejection<const TFields extends Schema.Struct.Fields>(struct: {
+	readonly fields: TFields;
+}): FieldRejection<keyof TFields & string>;
+export function fieldRejection<const TFields extends Schema.Struct.Fields, const TField extends keyof TFields & string>(
+	struct: { readonly fields: TFields },
+	fields: readonly TField[],
+): FieldRejection<TField>;
+export function fieldRejection(struct: { readonly fields: Schema.Struct.Fields }, fields?: readonly string[]): FieldRejection<string> {
+	return { field: Schema.Literals(fields ?? Object.keys(struct.fields)), message: Schema.String };
+}