@shivaedev/effect-contract 0.4.0 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shivaedev/effect-contract",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Typed query and command contracts over native Effect RPC and reactivity",
   "homepage": "https://github.com/ShivaeDev/platform/tree/main/packages/effect-contract#readme",
   "bugs": {
@@ -23,13 +23,55 @@
     }
   },
   "exports": {
-    "./*.ts": {
-      "types": "./dist/*.d.ts",
-      "source": "./src/*.ts",
-      "import": "./dist/*.js",
-      "default": "./dist/*.js"
+    "./package.json": "./package.json",
+    "./bind.ts": {
+      "types": "./dist/bind.d.ts",
+      "source": "./src/bind.ts",
+      "import": "./dist/bind.js",
+      "default": "./dist/bind.js"
+    },
+    "./contract.ts": {
+      "types": "./dist/contract.d.ts",
+      "source": "./src/contract.ts",
+      "import": "./dist/contract.js",
+      "default": "./dist/contract.js"
+    },
+    "./keys.ts": {
+      "types": "./dist/keys.d.ts",
+      "source": "./src/keys.ts",
+      "import": "./dist/keys.js",
+      "default": "./dist/keys.js"
     },
-    "./package.json": "./package.json"
+    "./live.ts": {
+      "types": "./dist/live.d.ts",
+      "source": "./src/live.ts",
+      "import": "./dist/live.js",
+      "default": "./dist/live.js"
+    },
+    "./makeLiveServer.ts": {
+      "types": "./dist/makeLiveServer.d.ts",
+      "source": "./src/makeLiveServer.ts",
+      "import": "./dist/makeLiveServer.js",
+      "default": "./dist/makeLiveServer.js"
+    },
+    "./operation.ts": {
+      "types": "./dist/operation.d.ts",
+      "source": "./src/operation.ts",
+      "import": "./dist/operation.js",
+      "default": "./dist/operation.js"
+    },
+    "./rejection.ts": {
+      "types": "./dist/rejection.d.ts",
+      "source": "./src/rejection.ts",
+      "import": "./dist/rejection.js",
+      "default": "./dist/rejection.js"
+    },
+    "./resume.ts": {
+      "types": "./dist/resume.d.ts",
+      "source": "./src/resume.ts",
+      "import": "./dist/resume.js",
+      "default": "./dist/resume.js"
+    }
   },
   "files": [
     "dist",
@@ -37,6 +79,7 @@
     "!src/**/*.test.ts",
     "!src/**/*.spec.ts",
     "!src/**/test-support",
+    "docs",
     "CHANGELOG.md",
     "README.md"
   ],
@@ -46,13 +89,13 @@
   "devDependencies": {
     "@effect/platform-node": "4.0.0-rc.112",
     "@effect/vitest": "4.0.0-rc.112",
-    "@shivaedev/effect-test": "0.3.0",
-    "@shivaedev/quality": "0.15.0",
-    "@types/node": "24.10.1",
+    "@shivaedev/effect-test": "0.3.2",
+    "@shivaedev/quality": "0.19.0",
+    "@types/node": "24.19.1",
     "@typescript/native": "npm:typescript@7.0.2",
     "effect": "4.0.0-rc.112",
-    "esbuild": "0.28.1",
-    "happy-dom": "20.11.2",
+    "esbuild": "0.28.2",
+    "happy-dom": "20.14.5",
     "typescript": "npm:@typescript/typescript6@6.0.2",
     "vitest": "4.1.11"
   },
@@ -67,7 +110,7 @@
     "provenance": true
   },
   "scripts": {
-    "build": "node --eval \"import('node:fs').then(({ rmSync }) => rmSync('dist', { force: true, recursive: true }))\" && tsc6 --project tsconfig.build.json",
+    "build": "node --eval \"import('node:fs').then(({ rmSync }) => rmSync('dist', { force: true, recursive: true }))\" && tsc --project tsconfig.build.json",
     "ready": "pnpm typecheck && pnpm test && pnpm build",
     "test": "vitest run",
     "typecheck": "tsc --noEmit"

package/src/bind.ts

@@ -1,19 +1,19 @@
 import type { Duration, Schema } from "effect";
-import { Effect } from "effect";
+import { Effect, Stream } from "effect";
 import type { Headers } from "effect/unstable/http";
 import type * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
 import type * as Atom from "effect/unstable/reactivity/Atom";
 import type * as AtomRpc from "effect/unstable/reactivity/AtomRpc";
 import * as Reactivity from "effect/unstable/reactivity/Reactivity";
-import type { Rpc } from "effect/unstable/rpc";
+import type { Rpc, RpcSchema } from "effect/unstable/rpc";
 import type { RpcClientError } from "effect/unstable/rpc/RpcClientError";
 import type { Contract, Declared, Tag } from "./contract.ts";
 import { invalidationKeys, type Key, readKeys } from "./keys.ts";
-import type { CommandShape, QueryShape } from "./operation.ts";
+import type { CommandShape, QueryShape, StreamShape } from "./operation.ts";
 
 export type Failure<R extends Rpc.Any> =
-	R extends Rpc.Rpc<infer _Tag, infer _Payload, infer _Success, infer TError, infer TMiddleware, infer _Requires>
-		? TError["Type"] | TMiddleware["error"]["Type"] | RpcClientError
+	R extends Rpc.Rpc<infer _Tag, infer _Payload, infer _Success, infer _Error, infer TMiddleware, infer _Requires>
+		? Rpc.ErrorExit<R> | TMiddleware["error"]["Type"] | RpcClientError
 		: never;
 
 export type RunFailure<R extends Rpc.Any> =
@@ -36,20 +36,33 @@ export interface BoundCommand<R extends Rpc.Any, TSelf> {
 	readonly run: (payload: Rpc.Payload<R>) => Effect.Effect<Rpc.Success<R>, RunFailure<R>, TSelf | Reactivity.Reactivity>;
 }
 
+export interface BoundStream<R extends Rpc.Any, TSelf> {
+	readonly run: (payload: Rpc.Payload<R>) => Stream.Stream<Rpc.SuccessChunk<R>, RunFailure<R>, TSelf | Rpc.ServicesClient<R>>;
+}
+
 export type Bound<
 	TName extends string,
 	TQueries extends readonly QueryShape[],
 	TCommands extends readonly CommandShape[],
 	TRpcs extends Rpc.Any,
 	TSelf,
+	TStreams extends readonly StreamShape[] = readonly [],
 > = {
 	readonly [TQuery in TQueries[number] as TQuery["name"]]: BoundQuery<Rpc.ExtractTag<TRpcs, Tag<TName, TQuery["name"]>>, TSelf>;
 } & {
 	readonly [TCommand in TCommands[number] as TCommand["name"]]: BoundCommand<Rpc.ExtractTag<TRpcs, Tag<TName, TCommand["name"]>>, TSelf>;
+} & {
+	readonly [TStream in TStreams[number] as TStream["name"]]: BoundStream<Rpc.ExtractTag<TRpcs, Tag<TName, TStream["name"]>>, TSelf>;
 };
 
 type ErasedClient = AtomRpc.AtomRpcClient<unknown, string, Rpc.Rpc<string, Schema.Top, Schema.Top, Schema.Top>>;
 
+type ErasedStreamingClient = AtomRpc.AtomRpcClient<
+	unknown,
+	string,
+	Rpc.Rpc<string, Schema.Top, RpcSchema.Stream<Schema.Top, Schema.Top>, Schema.Never>
+>;
+
 type MatchingClient<TRpcs extends Rpc.Any, TClientRpcs extends Rpc.Any> = [TRpcs] extends [Extract<TClientRpcs, { readonly _tag: TRpcs["_tag"] }>]
 	? [Extract<TClientRpcs, { readonly _tag: TRpcs["_tag"] }>] extends [TRpcs]
 		? unknown
@@ -77,6 +90,12 @@ function boundCommand(service: ErasedClient, tag: string, command: CommandShape)
 	};
 }
 
+function boundStream(service: ErasedStreamingClient, tag: string) {
+	return {
+		run: (payload: unknown) => Stream.unwrap(service.use((client) => Effect.succeed(client(tag, payload)))),
+	};
+}
+
 export function bind<
 	TName extends string,
 	TQueries extends readonly QueryShape[],
@@ -85,17 +104,19 @@ export function bind<
 	TSelf,
 	TId extends string,
 	TClientRpcs extends Rpc.Any,
+	TStreams extends readonly StreamShape[],
 >(
-	contract: Contract<TName, TQueries, TCommands, TRpcs>,
+	contract: Contract<TName, TQueries, TCommands, TRpcs, TStreams>,
 	service: AtomRpc.AtomRpcClient<TSelf, TId, TClientRpcs> & MatchingClient<NoInfer<TRpcs>, TClientRpcs>,
-): Bound<TName, TQueries, TCommands, TRpcs, TSelf>;
+): Bound<TName, TQueries, TCommands, TRpcs, TSelf, TStreams>;
 export function bind(
-	contract: { readonly declaration: Declared<string, readonly QueryShape[], readonly CommandShape[]> },
-	service: ErasedClient,
+	contract: { readonly declaration: Declared<string, readonly QueryShape[], readonly CommandShape[], readonly StreamShape[]> },
+	service: AtomRpc.AtomRpcClient<unknown, string, Rpc.Any>,
 ): unknown {
-	const { name, queries, commands } = contract.declaration;
+	const { name, queries, commands, streams } = contract.declaration;
 	return Object.fromEntries([
 		...queries.map((query) => [query.name, boundQuery(service, `${name}.${query.name}`, query)] as const),
 		...commands.map((command) => [command.name, boundCommand(service, `${name}.${command.name}`, command)] as const),
+		...streams.map((stream) => [stream.name, boundStream(service, `${name}.${stream.name}`)] as const),
 	]);
 }

package/src/contract.ts

@@ -1,47 +1,57 @@
-import { Rpc, RpcGroup, type RpcMiddleware } from "effect/unstable/rpc";
-import type { CommandShape, OperationShape, QueryShape } from "./operation.ts";
+import type { Schema } from "effect";
+import { Rpc, RpcGroup, type RpcMiddleware, type RpcSchema } from "effect/unstable/rpc";
+import type { CommandShape, OperationShape, QueryShape, StreamShape } from "./operation.ts";
 
-export type Tag<Contract extends string, Name extends string> = `${Contract}.${Name}`;
+export type Tag<TContract extends string, TName extends string> = `${TContract}.${TName}`;
 
-export type OperationRpc<Contract extends string, Operation> = Operation extends OperationShape
-	? Rpc.Rpc<Tag<Contract, Operation["name"]>, Operation["payload"], Operation["success"], Operation["error"]>
+export type OperationRpc<TContract extends string, TOperation> = TOperation extends OperationShape
+	? TOperation extends StreamShape
+		? Rpc.Rpc<Tag<TContract, TOperation["name"]>, TOperation["payload"], RpcSchema.Stream<TOperation["success"], TOperation["error"]>, Schema.Never>
+		: Rpc.Rpc<Tag<TContract, TOperation["name"]>, TOperation["payload"], TOperation["success"], TOperation["error"]>
 	: never;
 
-export interface Declared<Name extends string, Queries extends readonly QueryShape[], Commands extends readonly CommandShape[]> {
-	readonly commands: Commands;
-	readonly name: Name;
-	readonly queries: Queries;
+export interface Declared<
+	TName extends string,
+	TQueries extends readonly QueryShape[],
+	TCommands extends readonly CommandShape[],
+	TStreams extends readonly StreamShape[] = readonly [],
+> {
+	readonly commands: TCommands;
+	readonly name: TName;
+	readonly queries: TQueries;
+	readonly streams: TStreams;
 }
 
 export interface Contract<
-	Name extends string,
-	Queries extends readonly QueryShape[],
-	Commands extends readonly CommandShape[],
-	Rpcs extends Rpc.Any = OperationRpc<Name, Queries[number] | Commands[number]>,
-> extends RpcGroup.RpcGroup<Rpcs> {
-	readonly declaration: Declared<Name, Queries, Commands>;
-	middleware: <M extends RpcMiddleware.AnyService>(middleware: M) => Contract<Name, Queries, Commands, Rpc.AddMiddleware<Rpcs, M>>;
+	TName extends string,
+	TQueries extends readonly QueryShape[],
+	TCommands extends readonly CommandShape[],
+	TRpcs extends Rpc.Any = OperationRpc<TName, TQueries[number] | TCommands[number]>,
+	TStreams extends readonly StreamShape[] = readonly [],
+> extends RpcGroup.RpcGroup<TRpcs> {
+	readonly declaration: Declared<TName, TQueries, TCommands, TStreams>;
+	middleware: <TM extends RpcMiddleware.AnyService>(middleware: TM) => Contract<TName, TQueries, TCommands, Rpc.AddMiddleware<TRpcs, TM>, TStreams>;
 }
 
-type Duplicated<Operations extends readonly OperationShape[], Seen extends string = never> = Operations extends readonly [
-	infer Head extends OperationShape,
-	...infer Tail extends readonly OperationShape[],
+type Duplicated<TOperations extends readonly OperationShape[], TSeen extends string = never> = TOperations extends readonly [
+	infer THead extends OperationShape,
+	...infer TTail extends readonly OperationShape[],
 ]
-	? (Head["name"] extends Seen ? Head["name"] : never) | Duplicated<Tail, Seen | Head["name"]>
+	? (THead["name"] extends TSeen ? THead["name"] : never) | Duplicated<TTail, TSeen | THead["name"]>
 	: never;
 
-type Unique<Operations extends readonly OperationShape[]> = [Duplicated<Operations>] extends [never]
+type Unique<TOperations extends readonly OperationShape[]> = [Duplicated<TOperations>] extends [never]
 	? unknown
-	: `Operation names must be unique; duplicated: ${Duplicated<Operations>}`;
+	: `Operation names must be unique; duplicated: ${Duplicated<TOperations>}`;
 
-const assertUnique = (operations: readonly OperationShape[]) => {
+function assertUnique(operations: readonly OperationShape[]) {
 	const duplicated = operations.map(({ name }) => name).filter((name, index, names) => names.indexOf(name) !== index);
 	if (duplicated.length > 0) {
 		throw new Error(`Operation names must be unique; duplicated: ${[...new Set(duplicated)].join(", ")}`);
 	}
-};
+}
 
-type AnyDeclared = Declared<string, readonly QueryShape[], readonly CommandShape[]>;
+type AnyDeclared = Declared<string, readonly QueryShape[], readonly CommandShape[], readonly StreamShape[]>;
 
 interface Group {
 	middleware: (middleware: RpcMiddleware.AnyService) => Group;
@@ -51,30 +61,40 @@ interface DeclaredGroup extends Group {
 	readonly declaration: AnyDeclared;
 }
 
-const withDeclaration = (group: Group, declaration: AnyDeclared): DeclaredGroup => {
+function withDeclaration(group: Group, declaration: AnyDeclared): DeclaredGroup {
 	const nativeMiddleware = group.middleware.bind(group);
 	return Object.assign(group, {
 		declaration,
 		middleware: (middleware: RpcMiddleware.AnyService) => withDeclaration(nativeMiddleware(middleware), declaration),
 	});
-};
+}
 
 export function contract<
-	const Name extends string,
-	const Queries extends readonly QueryShape[] = readonly [],
-	const Commands extends readonly CommandShape[] = readonly [],
+	const TName extends string,
+	const TQueries extends readonly QueryShape[] = readonly [],
+	const TCommands extends readonly CommandShape[] = readonly [],
+	const TStreams extends readonly StreamShape[] = readonly [],
 >(
-	name: Name,
-	operations: { readonly queries?: Queries & Unique<Queries>; readonly commands?: Commands & Unique<[...Queries, ...Commands]> },
-): Contract<Name, Queries, Commands>;
+	name: TName,
+	operations: {
+		readonly queries?: TQueries & Unique<TQueries>;
+		readonly commands?: TCommands & Unique<[...TQueries, ...TCommands]>;
+		readonly streams?: TStreams & Unique<[...TQueries, ...TCommands, ...TStreams]>;
+	},
+): Contract<TName, TQueries, TCommands, OperationRpc<TName, TQueries[number] | TCommands[number] | TStreams[number]>, TStreams>;
 export function contract(
 	name: string,
-	operations: { readonly queries?: readonly QueryShape[]; readonly commands?: readonly CommandShape[] },
+	operations: { readonly queries?: readonly QueryShape[]; readonly commands?: readonly CommandShape[]; readonly streams?: readonly StreamShape[] },
 ): DeclaredGroup {
-	const { queries = [], commands = [] } = operations;
-	assertUnique([...queries, ...commands]);
-	const rpcs = [...queries, ...commands].map((operation) =>
-		Rpc.make(`${name}.${operation.name}`, { error: operation.error, payload: operation.payload, success: operation.success }),
+	const { queries = [], commands = [], streams = [] } = operations;
+	assertUnique([...queries, ...commands, ...streams]);
+	const rpcs = [...queries, ...commands, ...streams].map((operation) =>
+		Rpc.make(`${name}.${operation.name}`, {
+			error: operation.error,
+			payload: operation.payload,
+			stream: operation.kind === "stream",
+			success: operation.success,
+		}),
 	);
-	return withDeclaration(RpcGroup.make(...rpcs), { commands, name, queries });
+	return withDeclaration(RpcGroup.make(...rpcs), { commands, name, queries, streams });
 }

package/src/keys.ts

@@ -2,14 +2,14 @@ import { Schema } from "effect";
 
 export type Identity = string | number;
 
-export interface ListKey<Name extends string = string> {
+export interface ListKey<TName extends string = string> {
 	readonly _tag: "List";
-	readonly collection: Name;
+	readonly collection: TName;
 }
 
-export interface ItemKey<Name extends string = string> {
+export interface ItemKey<TName extends string = string> {
 	readonly _tag: "Item";
-	readonly collection: Name;
+	readonly collection: TName;
 	readonly id: Identity;
 }
 
@@ -20,22 +20,24 @@ export const Key = Schema.Union([
 	Schema.Struct({ _tag: Schema.Literal("Item"), collection: Schema.String, id: Schema.Union([Schema.String, Schema.Number]) }),
 ]);
 
-export interface Collection<Name extends string, Id extends Identity> {
-	readonly item: (id: Id) => ItemKey<Name>;
-	readonly list: ListKey<Name>;
-	readonly name: Name;
+export interface Collection<TName extends string, TId extends Identity> {
+	readonly item: (id: TId) => ItemKey<TName>;
+	readonly list: ListKey<TName>;
+	readonly name: TName;
 }
 
-export const collection = <const Name extends string, Id extends Schema.Top & { readonly Type: Identity }>(
-	name: Name,
-	_id: Id,
-): Collection<Name, Id["Type"]> => ({
+export const collection = <const TName extends string, TId extends Schema.Top & { readonly Type: Identity }>(
+	name: TName,
+	_id: TId,
+): Collection<TName, TId["Type"]> => ({
 	item: (id) => ({ _tag: "Item", collection: name, id }),
 	list: { _tag: "List", collection: name },
 	name,
 });
 
-const own = (key: Key): string => (key._tag === "List" ? key.collection : `${key.collection}:${key.id}`);
+function own(key: Key): string {
+	return key._tag === "List" ? key.collection : `${key.collection}:${key.id}`;
+}
 
 export const readKeys = (keys: readonly Key[]): readonly string[] => [...new Set(keys.map(own))];
 

package/src/makeLiveServer.ts

@@ -0,0 +1,32 @@
+import { Effect, Stream } from "effect";
+import * as Reactivity from "effect/unstable/reactivity/Reactivity";
+import { type Key, readKeys } from "./keys.ts";
+import type { LiveHint } from "./live.ts";
+
+export const makeLiveServer = Effect.gen(function* () {
+	const reactivity = yield* Reactivity.Reactivity;
+	const resyncKey = `@shivaedev/effect-contract/resync/${crypto.randomUUID()}`;
+	let generation = 0;
+	function stream(keys: readonly Key[]) {
+		return Stream.unwrap(
+			Effect.sync(() => {
+				let seen = -1;
+				return reactivity.stream(
+					[...readKeys(keys), resyncKey],
+					Effect.sync((): LiveHint => {
+						if (seen !== generation) {
+							seen = generation;
+							return { _tag: "Resync" };
+						}
+						return { _tag: "Changed", keys };
+					}),
+				);
+			}),
+		);
+	}
+	const resync = Effect.sync(() => {
+		generation += 1;
+		reactivity.invalidateUnsafe([resyncKey]);
+	});
+	return { resync, stream };
+});

package/src/operation.ts

@@ -3,15 +3,15 @@ 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<Payload extends Schema.Top | Schema.Struct.Fields> = Payload extends Schema.Struct.Fields
-	? Schema.Struct<Payload>
-	: Payload;
+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";
+	readonly kind: "query" | "command" | "stream";
 	readonly name: string;
 	readonly payload: Schema.Top;
 	readonly Rejection: object;
@@ -25,38 +25,49 @@ export interface QueryShape extends OperationShape {
 	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<Name extends string, Payload extends Schema.Top, Success extends Schema.Top, Specs extends RejectionSpecs>
+interface Operation<TName extends string, TPayload extends Schema.Top, TSuccess extends Schema.Top, TSpecs extends RejectionSpecs>
 	extends OperationShape {
-	readonly error: RejectionUnion<Specs>;
-	readonly name: Name;
-	readonly payload: Payload;
-	readonly Rejection: Rejections<Specs>;
-	readonly reject: Reject<Specs>;
-	readonly rejections: Specs;
-	readonly success: Success;
+	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<Name extends string, Payload extends Schema.Top, Success extends Schema.Top, Specs extends RejectionSpecs>
-	extends Operation<Name, Payload, Success, Specs> {
+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: Payload["Type"]) => readonly Key[];
+	reads: (payload: TPayload["Type"]) => readonly Key[];
 }
 
-export interface Command<Name extends string, Payload extends Schema.Top, Success extends Schema.Top, Specs extends RejectionSpecs>
-	extends Operation<Name, Payload, Success, Specs> {
-	invalidates: (payload: Payload["Type"], result: Success["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<Payload extends Schema.Top | Schema.Struct.Fields, Success extends Schema.Top, Specs extends RejectionSpecs> {
-	readonly payload?: Payload;
-	readonly rejections?: Specs & MatchingTags<Specs>;
-	readonly success?: Success;
+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 {
@@ -65,14 +76,14 @@ interface Loose {
 	readonly success?: Schema.Top;
 }
 
-const payloadSchema = (payload: Loose["payload"]): Schema.Top => {
+function payloadSchema(payload: Loose["payload"]): Schema.Top {
 	if (payload === undefined) {
 		return Schema.Void;
 	}
 	return Schema.isSchema(payload) ? payload : Schema.Struct(payload);
-};
+}
 
-const operation = <Kind extends OperationShape["kind"]>(kind: Kind, name: string, declaration: Loose) => {
+function operation<TKind extends OperationShape["kind"]>(kind: TKind, name: string, declaration: Loose) {
 	const { payload, success, rejections = {} } = declaration;
 	return {
 		kind,
@@ -82,37 +93,53 @@ const operation = <Kind extends OperationShape["kind"]>(kind: Kind, name: string
 		success: success ?? Schema.Void,
 		...rejectionSet(rejections),
 	};
-};
+}
 
 export function query<
-	const Name extends string,
-	Payload extends Schema.Top | Schema.Struct.Fields = Schema.Void,
-	Success extends Schema.Top = Schema.Void,
-	const Specs extends RejectionSpecs = NoRejections,
+	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: Name,
-	declaration: Declaration<Payload, Success, Specs> & {
-		readonly reads: (payload: PayloadSchema<Payload>["Type"]) => readonly Key[];
+	name: TName,
+	declaration: Declaration<TPayload, TSuccess, TSpecs> & {
+		readonly reads: (payload: PayloadSchema<TPayload>["Type"]) => readonly Key[];
 	},
-): NoInfer<Query<Name, PayloadSchema<Payload>, Success, Specs>>;
+): 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 Name extends string,
-	Payload extends Schema.Top | Schema.Struct.Fields = Schema.Void,
-	Success extends Schema.Top = Schema.Void,
-	const Specs extends RejectionSpecs = NoRejections,
+	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: Name,
-	declaration: Declaration<Payload, Success, Specs> & {
-		readonly invalidates: (payload: PayloadSchema<Payload>["Type"], result: Success["Type"]) => readonly Key[];
+	name: TName,
+	declaration: Declaration<TPayload, TSuccess, TSpecs> & {
+		readonly invalidates: (payload: PayloadSchema<TPayload>["Type"], result: TSuccess["Type"]) => readonly Key[];
 	},
-): NoInfer<Command<Name, PayloadSchema<Payload>, Success, Specs>>;
+): 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 };
+}