@rikalabs/akter 0.1.0-alpha.0

package/dist/members/event.js

@@ -0,0 +1,24 @@
+import { Schema } from "effect";
+import { declareChain } from "./payload.js";
+/**
+ * `EventMember.make` is `Actor.event`: declares a durable event class. Its schema identifier is
+ * fixed to the tag, so a stored event names its class. `migrations` upcasts
+ * events stored at older versions when they are read; stored events are never
+ * rewritten. An invalid migration chain throws when the class is built. The
+ * value is itself the class: `Posted.make(...)`, `new Posted(...)`, and
+ * `instanceof` all work.
+ *
+ * @example
+ * const Posted = Actor.event("Posted", { text: Schema.String })
+ */
+const make = (tag, fields, options) => {
+    const declared = Schema.TaggedClass()(tag, fields);
+    declareChain({ schema: declared, label: `Event ${tag}`, fields: fields, options });
+    return declared;
+};
+/** `Actor.event`; see `make`. */
+export const EventMember = { make };
+/** Entries one `read.events` call returns when the reader names no `limit`. */
+export const DEFAULT_REPLAY_LIMIT = 1_000;
+/** The largest page a reader may ask for; it bounds rows per page, not their bytes. */
+export const MAX_REPLAY_LIMIT = 10_000;

package/dist/members/job.d.ts

@@ -0,0 +1,157 @@
+import { type Duration, Schema } from "effect";
+import type { AnyCommand, PayloadFields, ValueSchema } from "./command.ts";
+import { type PayloadMigrations } from "./payload.ts";
+/**
+ * An `Actor.job` value: a schema-backed class of requests for external I/O
+ * that a turn stages with `turn.enqueue` and an executor runs after commit.
+ * Its instances are the job's payload; `success` types the executor's return
+ * value and `progress` its transient frames.
+ */
+export type JobClass<Tag extends string, Fields extends PayloadFields, Success extends ValueSchema, Progress extends ValueSchema | undefined = undefined> = Schema.Class<Schema.TaggedStruct<Tag, Fields>["Type"], Schema.TaggedStruct<Tag, Fields>, {}> & {
+    readonly tag: Tag;
+    readonly success: Success;
+    readonly progress: Progress;
+};
+/** Any job, as a `jobs` binding names it. */
+export type AnyJob = ValueSchema & {
+    readonly tag: string;
+    readonly success: ValueSchema;
+    readonly progress: ValueSchema | undefined;
+    readonly Type: {
+        readonly _tag: string;
+    };
+};
+/** A job that declares a `progress` schema. */
+export type ProgressJob = AnyJob & {
+    readonly progress: ValueSchema;
+};
+/** The frame type an executor of `J` reports with `X.Executor.progress`. */
+export type ProgressOf<J extends ProgressJob> = J["progress"]["Type"];
+/**
+ * `JobMember.make` is `Actor.job`: declares a job class. `payload` holds its record fields;
+ * `success` is the schema of the executor's return value and defaults to
+ * `Schema.Void`. `progress`, when declared, is the schema of the transient
+ * frames its executor may report before the result commits; they are never
+ * state. `migrations` upcasts payloads stored at older versions before each
+ * attempt and before a dead letter's route; `writeVersion` is as for events.
+ * The value is itself the class: `Charge.make(...)`, `new Charge(...)`, and
+ * `instanceof` all work, and one job may be bound by several actors.
+ *
+ * @example
+ * const Charge = Actor.job("Charge", {
+ *   payload: { amount: Schema.Int },
+ *   success: Schema.Struct({ providerId: Schema.String }),
+ * })
+ */
+declare const make: <const Tag extends string, const Fields extends PayloadFields = {}, Success extends ValueSchema = Schema.Void, Progress extends ValueSchema | undefined = undefined>(tag: Tag, options?: {
+    readonly payload?: Fields;
+    readonly success?: Success;
+    readonly progress?: Progress;
+    readonly migrations?: PayloadMigrations;
+    readonly writeVersion?: number;
+}) => JobClass<Tag, Fields, Success, Progress>;
+/** `Actor.job`; see `make`. */
+export declare const JobMember: {
+    make: typeof make;
+};
+/**
+ * The payload of an `onDeadLetter` command. `ambiguous` is true when the last
+ * attempt ended without a known outcome (a crash, timeout, interruption, or
+ * defect), so the provider may still have applied it.
+ */
+export declare const DeadLetter: <J extends AnyJob>(job: J) => Schema.Struct<{
+    readonly jobId: Schema.String;
+    readonly job: J;
+    readonly attempts: Schema.Int;
+    readonly cause: Schema.String;
+    readonly ambiguous: Schema.Boolean;
+}>;
+/** The decoded payload of an `onDeadLetter` command for job `J`. */
+export type DeadLetter<J extends AnyJob> = ReturnType<typeof DeadLetter<J>>["Type"];
+/**
+ * The payload of an `onCancelled` command: what is known of a cancelled job.
+ * `Succeeded` carries the provider's result; `Failed` is reported only when no
+ * attempt can have applied the call; every other case is `Unknown`, with
+ * `ambiguous` true, because the provider may have acted.
+ */
+export declare const Cancelled: <J extends AnyJob>(job: J) => Schema.Struct<{
+    readonly jobId: Schema.String;
+    readonly job: J;
+    readonly attempts: Schema.Int;
+    readonly outcome: Schema.TaggedUnion<{
+        readonly Failed: Schema.TaggedStruct<"Failed", {
+            readonly cause: Schema.String;
+        }>;
+        readonly Succeeded: Schema.TaggedStruct<"Succeeded", {
+            readonly value: ValueSchema;
+        }>;
+        readonly Unknown: Schema.TaggedStruct<"Unknown", {
+            readonly cause: Schema.String;
+        }>;
+    }>;
+    readonly ambiguous: Schema.Boolean;
+}>;
+/** The decoded payload of an `onCancelled` command for job `J`. */
+export type Cancelled<J extends AnyJob> = ReturnType<typeof Cancelled<J>>["Type"];
+/** A cancelled job's outcome before its route decodes `value`. */
+export declare const CancelledOutcome: Schema.TaggedUnion<{
+    readonly Failed: Schema.TaggedStruct<"Failed", {
+        readonly cause: Schema.String;
+    }>;
+    readonly Succeeded: Schema.TaggedStruct<"Succeeded", {
+        readonly value: Schema.Unknown;
+    }>;
+    readonly Unknown: Schema.TaggedStruct<"Unknown", {
+        readonly cause: Schema.String;
+    }>;
+}>;
+/** Commands whose payload accepts `T`. */
+type Accepting<Command extends AnyCommand, T> = Command extends AnyCommand ? [T] extends [Command["payload"]["Type"]] ? Command : never : never;
+/**
+ * One actor's binding of a job: the job it enqueues and how this actor runs
+ * and routes it. Routes name commands of this actor whose payload accepts the
+ * executor's return value, the job's dead letter, or its cancellation; two
+ * actors may bind one job with different routes and limits.
+ */
+export interface JobBinding<J extends AnyJob, Command extends AnyCommand> {
+    readonly job: J;
+    /** Bounds one executor attempt, measured on the runner. Default 30 seconds. */
+    readonly timeout?: Duration.Input;
+    /**
+     * The least time between two progress frames one attempt sends; frames
+     * reported sooner replace the one waiting. Default 250 milliseconds, from
+     * 50 milliseconds to 1 minute.
+     */
+    readonly progressEvery?: Duration.Input;
+    /**
+     * Retries after the first failed attempt (default 3), and the wait after
+     * failed attempt `n`: `min(base × 2^(n − 1), max)`. Default base 1 second,
+     * max 256 seconds. Retries are persisted, not process-local sleeps.
+     */
+    readonly retry?: {
+        readonly times: number;
+        readonly backoff?: {
+            readonly base: Duration.Input;
+            readonly max: Duration.Input;
+        };
+    };
+    /** Receives the executor's return value, with the job id as its command id. */
+    readonly onSuccess?: Accepting<Command, J["success"]["Type"]>;
+    /** Receives `Actor.DeadLetter(J)` once when retries are exhausted. */
+    readonly onDeadLetter?: Accepting<Command, DeadLetter<J>>;
+    /**
+     * Receives `Actor.Cancelled(J)` once for a job cancelled after an attempt
+     * started, with the job id as its command id.
+     */
+    readonly onCancelled?: Accepting<Command, Cancelled<J>>;
+    /**
+     * Attempts of this job running at once for one actor, across every
+     * runner: an integer from 1 to 64. Unlimited when omitted.
+     */
+    readonly concurrency?: {
+        readonly perActor: number;
+    };
+}
+/** Any job binding, whatever its job and routes. */
+export type AnyJobBinding = JobBinding<AnyJob, AnyCommand>;
+export {};

package/dist/members/job.js

@@ -0,0 +1,67 @@
+import { Schema } from "effect";
+import { declareChain } from "./payload.js";
+/**
+ * `JobMember.make` is `Actor.job`: declares a job class. `payload` holds its record fields;
+ * `success` is the schema of the executor's return value and defaults to
+ * `Schema.Void`. `progress`, when declared, is the schema of the transient
+ * frames its executor may report before the result commits; they are never
+ * state. `migrations` upcasts payloads stored at older versions before each
+ * attempt and before a dead letter's route; `writeVersion` is as for events.
+ * The value is itself the class: `Charge.make(...)`, `new Charge(...)`, and
+ * `instanceof` all work, and one job may be bound by several actors.
+ *
+ * @example
+ * const Charge = Actor.job("Charge", {
+ *   payload: { amount: Schema.Int },
+ *   success: Schema.Struct({ providerId: Schema.String }),
+ * })
+ */
+const make = (tag, options) => {
+    if (tag.length === 0)
+        throw new Error("Actor.job needs a non-empty tag");
+    const fields = options?.payload ?? {};
+    const declared = Schema.TaggedClass()(tag, fields);
+    declareChain({ schema: declared, label: `Job ${tag}`, fields, options });
+    return Object.assign(declared, {
+        tag,
+        success: (options?.success ?? Schema.Void),
+        progress: options?.progress,
+    });
+};
+/** `Actor.job`; see `make`. */
+export const JobMember = { make };
+/**
+ * The payload of an `onDeadLetter` command. `ambiguous` is true when the last
+ * attempt ended without a known outcome (a crash, timeout, interruption, or
+ * defect), so the provider may still have applied it.
+ */
+export const DeadLetter = (job) => Schema.Struct({
+    jobId: Schema.String,
+    job,
+    attempts: Schema.Int,
+    cause: Schema.String,
+    ambiguous: Schema.Boolean,
+});
+/**
+ * The payload of an `onCancelled` command: what is known of a cancelled job.
+ * `Succeeded` carries the provider's result; `Failed` is reported only when no
+ * attempt can have applied the call; every other case is `Unknown`, with
+ * `ambiguous` true, because the provider may have acted.
+ */
+export const Cancelled = (job) => Schema.Struct({
+    jobId: Schema.String,
+    job,
+    attempts: Schema.Int,
+    outcome: Schema.TaggedUnion({
+        Succeeded: { value: job.success },
+        Failed: { cause: Schema.String },
+        Unknown: { cause: Schema.String },
+    }),
+    ambiguous: Schema.Boolean,
+});
+/** A cancelled job's outcome before its route decodes `value`. */
+export const CancelledOutcome = Schema.TaggedUnion({
+    Succeeded: { value: Schema.Unknown },
+    Failed: { cause: Schema.String },
+    Unknown: { cause: Schema.String },
+});

package/dist/members/payload.d.ts

@@ -0,0 +1,93 @@
+import { Effect, Schema } from "effect";
+import type { StateMigration } from "../state/migration.ts";
+import type { ValueSchema } from "./command.ts";
+type Fields = Readonly<Record<string, ValueSchema>>;
+/**
+ * An event's or effect's migration chain: every step since version 0, or,
+ * once no stored value needs the first `from` versions, the steps after them.
+ * Declaring the dropped count keeps every later version number unchanged.
+ */
+export type PayloadMigrations = ReadonlyArray<StateMigration> | {
+    readonly from: number;
+    readonly steps: ReadonlyArray<StateMigration>;
+};
+/** Migration options shared by `Actor.event` and `Actor.job`. */
+export interface PayloadOptions {
+    readonly migrations?: PayloadMigrations;
+    /**
+     * The version new values are written at. During a rolling deploy that adds
+     * a step, runners that don't know the step yet must still read every new
+     * value, so the first release writes the previous version and needs that
+     * step's `downcast`. Defaults to the chain's current version.
+     */
+    readonly writeVersion?: number;
+}
+/** A validated chain: stored versions `first..current` decode, and new values are written at `writeVersion`. */
+interface PayloadChain {
+    readonly first: number;
+    readonly current: number;
+    readonly writeVersion: number;
+    /** Step `i` upcasts version `first + i` to `first + i + 1`. */
+    readonly steps: ReadonlyArray<StateMigration>;
+}
+declare const PayloadError_base: Schema.Class<PayloadError, Schema.TaggedStruct<"PayloadError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A stored value its chain cannot read; every read treats it as a defect, never a skip. */
+declare class PayloadError extends PayloadError_base {
+}
+/** Records a class's chain when the class is built; an invalid chain throws there. */
+export declare const declareChain: (declared: {
+    readonly schema: Schema.Top;
+    readonly label: string;
+    readonly fields: Fields;
+    readonly options: PayloadOptions | undefined;
+}) => void;
+/**
+ * The chain of an event or job class. Lookup follows the prototype chain, so
+ * a subclass of an `Actor.event` or `Actor.job` value shares its chain; a class
+ * declared without one reads and writes version 0.
+ */
+export declare const payloadChain: (schema: Schema.Top) => PayloadChain;
+/**
+ * Encodes and decodes one tagged class's stored values, which carry the tag
+ * in `_tag` and their version beside them. Values at the current version take
+ * the class's own codec; older ones pass through each later step first, and
+ * new ones are downcast through each step above `writeVersion`. A stored
+ * value is its class's JSON object: the tag and the fields of its version.
+ */
+export declare const payloadCodec: <S extends ValueSchema & {
+    readonly Type: {
+        readonly _tag: string;
+    };
+}>({ schema, tag, }: {
+    readonly schema: S;
+    readonly tag: string;
+}) => {
+    chain: PayloadChain;
+    /** Encodes a value at the chain's write version. */
+    encode: (value: S["Type"]) => Effect.Effect<{
+        value: string;
+        version: number;
+    }, Schema.SchemaError, never>;
+    /** Decodes a stored value written at `version` into the current class. */
+    decode: (text: string, version: number) => Effect.Effect<S["Type"], PayloadError, S["DecodingServices"]>;
+    /** A stored value as the current version encodes it; unchanged when it is already current. */
+    upcast: (text: string, version: number) => Effect.Effect<string, PayloadError, S["DecodingServices"] | S["EncodingServices"]>;
+};
+/** One event or job class an actor type reads or writes, as the startup check sees it. */
+export interface PayloadDeclaration {
+    readonly actorType: string;
+    readonly kind: "event" | "job";
+    readonly tag: string;
+    readonly chain: PayloadChain;
+    /** Whether this layer writes new values of the class, so it records and heartbeats its write version. */
+    readonly writes: boolean;
+}
+/** What `durable payloads check` and `clear` need of an actor definition. */
+export interface DefinitionPayloads {
+    readonly declarations: ReadonlyArray<PayloadDeclaration>;
+    readonly keepEventsMs: number;
+    readonly commandTimeoutMs: number;
+}
+export {};

package/dist/members/payload.js

@@ -0,0 +1,145 @@
+import { Effect, Schema } from "effect";
+/** A stored value its chain cannot read; every read treats it as a defect, never a skip. */
+class PayloadError extends Schema.TaggedError()("PayloadError", {
+    message: Schema.String,
+}) {
+}
+const sameFields = (left, right) => {
+    const keys = Object.keys(left);
+    return (keys.length === Object.keys(right).length &&
+        keys.every((key) => Object.hasOwn(right, key) && left[key] === right[key]));
+};
+const isVersion = (value) => Number.isSafeInteger(value) && value >= 0;
+/**
+ * Validates a chain against the declared fields, as the state chain is: each
+ * `to` has the next `from`'s fields and the last `to` has the declared ones.
+ * Fields compare key by key, so a step may restate them in a new object.
+ */
+const chainOf = (label, fields, options) => {
+    const declared = options?.migrations ?? [];
+    const { from: first, steps } = Array.isArray(declared)
+        ? { from: 0, steps: declared }
+        : declared;
+    if (!isVersion(first))
+        throw new Error(`${label} migrations.from must be a non-negative integer`);
+    for (let index = 1; index < steps.length; index++)
+        if (!sameFields(steps[index - 1].to, steps[index].from))
+            throw new Error(`${label} migration ${index} must start from the previous migration's result`);
+    if (steps.length > 0 && !sameFields(steps.at(-1).to, fields))
+        throw new Error(`${label}'s last migration must produce its declared fields`);
+    for (const step of steps)
+        if ("_tag" in step.from || "_tag" in step.to)
+            throw new Error(`${label} migrations must not name _tag; the tag never changes`);
+    const current = first + steps.length;
+    const writeVersion = options?.writeVersion ?? current;
+    if (!isVersion(writeVersion) || writeVersion < first || writeVersion > current)
+        throw new Error(`${label} writeVersion must be a version from ${first} to ${current}`);
+    for (let version = writeVersion; version < current; version++)
+        if (steps[version - first].downcast === undefined)
+            throw new Error(`${label} writes version ${writeVersion}, so migration ${version - first} needs a downcast`);
+    return { first, current, writeVersion, steps };
+};
+const chains = new WeakMap();
+const NO_CHAIN = { first: 0, current: 0, writeVersion: 0, steps: [] };
+/** Records a class's chain when the class is built; an invalid chain throws there. */
+export const declareChain = (declared) => {
+    chains.set(declared.schema, chainOf(declared.label, declared.fields, declared.options));
+};
+/**
+ * The chain of an event or job class. Lookup follows the prototype chain, so
+ * a subclass of an `Actor.event` or `Actor.job` value shares its chain; a class
+ * declared without one reads and writes version 0.
+ */
+export const payloadChain = (schema) => {
+    for (let current = schema; current !== null;) {
+        const chain = chains.get(current);
+        if (chain !== undefined)
+            return chain;
+        current = Object.getPrototypeOf(current);
+    }
+    return NO_CHAIN;
+};
+/**
+ * Encodes and decodes one tagged class's stored values, which carry the tag
+ * in `_tag` and their version beside them. Values at the current version take
+ * the class's own codec; older ones pass through each later step first, and
+ * new ones are downcast through each step above `writeVersion`. A stored
+ * value is its class's JSON object: the tag and the fields of its version.
+ */
+export const payloadCodec = ({ schema, tag, }) => {
+    const chain = payloadChain(schema);
+    const json = Schema.toCodecJson(schema);
+    const codec = Schema.fromJsonString(json);
+    const encodeCurrent = Schema.encodeEffect(codec);
+    const decodeCurrent = Schema.decodeEffect(codec);
+    const encodeCurrentJson = Schema.encodeEffect(json);
+    const decodeCurrentJson = Schema.decodeUnknownEffect(json);
+    const Stored = Schema.StructWithRest(Schema.Struct({ _tag: Schema.Literal(tag) }), [
+        Schema.Record(Schema.String, Schema.Json),
+    ]);
+    const decodeStored = Schema.decodeUnknownEffect(Stored);
+    const decodeStoredText = Schema.decodeEffect(Schema.fromJsonString(Stored));
+    const encodeStoredText = Schema.encodeEffect(Schema.fromJsonString(Stored));
+    const steps = chain.steps.map((step) => {
+        const from = Schema.toCodecJson(Schema.Struct(step.from));
+        const to = Schema.toCodecJson(Schema.Struct(step.to));
+        return {
+            step,
+            decodeFrom: Schema.decodeUnknownEffect(from),
+            encodeFrom: Schema.encodeUnknownEffect(from),
+            decodeTo: Schema.decodeUnknownEffect(to),
+            encodeTo: Schema.encodeUnknownEffect(to),
+        };
+    });
+    const failure = (version, message) => PayloadError.make({
+        message: `Stored ${tag} at payload version ${version} does not decode: ${message}`,
+    });
+    const fieldsOf = ({ _tag, ...fields }) => fields;
+    const upcastStored = (text, version) => Effect.gen(function* () {
+        if (version > chain.current)
+            return yield* PayloadError.make({
+                message: `Stored ${tag} has payload version ${version}, newer than this code's chain (${chain.current}); roll forward`,
+            });
+        if (version < chain.first)
+            return yield* PayloadError.make({
+                message: `Stored ${tag} has payload version ${version}, older than this code's chain (${chain.first})`,
+            });
+        let value = fieldsOf(yield* decodeStoredText(text).pipe(Effect.mapError((error) => failure(version, error.message))));
+        for (const { step, decodeFrom, encodeTo } of steps.slice(version - chain.first)) {
+            const previous = yield* decodeFrom(value).pipe(Effect.mapError((error) => failure(version, error.message)));
+            const next = yield* Effect.try({
+                try: () => step.upcast(previous),
+                catch: (cause) => failure(version, String(cause)),
+            });
+            value = yield* encodeTo(next).pipe(Effect.mapError((error) => failure(version, error.message)));
+        }
+        return yield* decodeCurrentJson({ ...value, _tag: tag }).pipe(Effect.mapError((error) => failure(version, error.message)));
+    });
+    const downcast = (value) => Effect.gen(function* () {
+        let encoded = fieldsOf(yield* decodeStored(yield* encodeCurrentJson(value)));
+        for (let version = chain.current; version > chain.writeVersion; version--) {
+            const { step, decodeTo, encodeFrom } = steps[version - 1 - chain.first];
+            const next = yield* decodeTo(encoded);
+            encoded = yield* encodeFrom(step.downcast(next));
+        }
+        return {
+            value: yield* encodeStoredText(yield* decodeStored({ ...encoded, _tag: tag })),
+            version: chain.writeVersion,
+        };
+    });
+    return {
+        chain,
+        /** Encodes a value at the chain's write version. */
+        encode: (value) => chain.writeVersion === chain.current
+            ? encodeCurrent(value).pipe(Effect.map((text) => ({ value: text, version: chain.current })))
+            : downcast(value),
+        /** Decodes a stored value written at `version` into the current class. */
+        decode: (text, version) => version === chain.current
+            ? decodeCurrent(text).pipe(Effect.mapError((error) => failure(version, error.message)))
+            : upcastStored(text, version),
+        /** A stored value as the current version encodes it; unchanged when it is already current. */
+        upcast: (text, version) => version === chain.current
+            ? Effect.succeed(text)
+            : upcastStored(text, version).pipe(Effect.flatMap((decoded) => encodeCurrent(decoded).pipe(Effect.mapError((error) => failure(version, error.message))))),
+    };
+};

package/dist/members/reducer.d.ts

@@ -0,0 +1,64 @@
+import { Schema, type Result } from "effect";
+import type { ActorState } from "../state/migration.ts";
+import { type DeclaredError, type Member, type PayloadOf, type PayloadOption, type ValueSchema } from "./command.ts";
+type Fields = Readonly<Record<string, ValueSchema>>;
+type StateOf<F extends Fields> = Schema.Struct<F>["Type"];
+/**
+ * Ordered batching: `combine(first, second)` is one payload whose single
+ * reduction equals reducing `first` and then `second`, which lets the server
+ * fold consecutive queued calls, in their order, into one turn. It needs that
+ * fold equivalence only; it is not commutativity or a merge of concurrent
+ * replicas. Declared as a method so its parameters stay bivariant and any
+ * reducer fits `AnyReducer`.
+ */
+export interface Batch<Payload> {
+    combine(first: Payload, second: Payload): Payload;
+}
+/**
+ * A pure state transition declared in the contract. The server runs it as an
+ * ordinary fenced, receipted turn with no handler; a batched reducer replies
+ * `void` and declares no error, so combined turns stay equivalent to
+ * sequential ones and each call keeps its own receipt.
+ */
+export interface Reducer<Tag extends string, F extends Fields, Payload extends ValueSchema, Success extends ValueSchema, Error extends DeclaredError> extends Member<"reducer", Tag, Payload, Success, Error> {
+    readonly state: ActorState<F>;
+    /** Declared as a method so its parameters stay bivariant and any reducer fits `AnyReducer`. */
+    reduce(state: StateOf<F>, payload: Payload["Type"]): Result.Result<StateOf<F>, Error["Type"]>;
+    readonly batch: Batch<Payload["Type"]> | undefined;
+}
+/** Any reducer, whatever its schemas. */
+export type AnyReducer = Reducer<string, Fields, ValueSchema, ValueSchema, DeclaredError>;
+/**
+ * The overloads of `Actor.reducer`. A batched reducer replies `void` and
+ * cannot fail; any other replies the committed state. Declaring `error` on a
+ * batched reducer throws.
+ *
+ * @example
+ * const Add = Actor.reducer("Add", {
+ *   state: Counter,
+ *   payload: { by: Schema.Int },
+ *   reduce: (state, { by }) => Result.succeed({ count: state.count + by }),
+ *   batch: { combine: (first, second) => ({ by: first.by + second.by }) },
+ * })
+ */
+export interface MakeReducer {
+    <const Tag extends string, const F extends Fields, const P extends PayloadOption = Schema.Void>(tag: Tag, options: {
+        readonly state: ActorState<F>;
+        readonly payload?: P;
+        readonly error?: Schema.Never;
+        readonly reduce: (state: StateOf<F>, payload: PayloadOf<P>["Type"]) => Result.Result<StateOf<F>, never>;
+        readonly batch: Batch<PayloadOf<P>["Type"]>;
+    }): Reducer<Tag, F, PayloadOf<P>, Schema.Void, Schema.Never>;
+    <const Tag extends string, const F extends Fields, const P extends PayloadOption = Schema.Void, Error extends DeclaredError = Schema.Never>(tag: Tag, options: {
+        readonly state: ActorState<F>;
+        readonly payload?: P;
+        readonly error?: Error;
+        readonly reduce: (state: StateOf<F>, payload: PayloadOf<P>["Type"]) => Result.Result<StateOf<F>, Error["Type"]>;
+        readonly batch?: undefined;
+    }): Reducer<Tag, F, PayloadOf<P>, Schema.Struct<F>, Error>;
+}
+/** `Reducer.make` is `Actor.reducer`; see `MakeReducer` for its two forms. */
+export declare const Reducer: {
+    make: MakeReducer;
+};
+export {};

package/dist/members/reducer.js

@@ -0,0 +1,27 @@
+import { Schema } from "effect";
+import { member, } from "./command.js";
+const reducer = (tag, options) => {
+    const { state, reduce, batch } = options;
+    if (batch === undefined)
+        return {
+            ...member("reducer")(tag, {
+                payload: options.payload,
+                success: Schema.Struct(state.fields),
+                error: options.error,
+            }),
+            state,
+            reduce,
+            batch,
+        };
+    if (options.error !== undefined && options.error !== Schema.Never)
+        throw new Error(`Batched reducer ${tag} cannot declare an error`);
+    return {
+        ...member("reducer")(tag, { payload: options.payload }),
+        state,
+        reduce,
+        batch,
+    };
+};
+const make = reducer;
+/** `Reducer.make` is `Actor.reducer`; see `MakeReducer` for its two forms. */
+export const Reducer = { make };

package/dist/members/stream.d.ts

@@ -0,0 +1,36 @@
+import type { Schema } from "effect";
+import { type DeclaredError, type Member, type PayloadOf, type PayloadOption, type ValueSchema } from "./command.ts";
+import type { ProgressJob } from "./job.ts";
+/**
+ * A live, read-only feed that runs on the actor's activation for one
+ * subscriber. `payload` is the subscription's input and `success` the schema
+ * of each element; nothing it emits is stored.
+ */
+export interface Stream<Tag extends string, Payload extends ValueSchema, Success extends ValueSchema, Error extends DeclaredError> extends Member<"stream", Tag, Payload, Success, Error> {
+    /** Jobs whose executor progress its handler may read with `read.progress`. */
+    readonly progress: {
+        readonly jobs: ReadonlyArray<ProgressJob>;
+    } | undefined;
+}
+/** Any stream member, whatever its schemas. */
+export type AnyStream = Stream<string, ValueSchema, ValueSchema, DeclaredError>;
+declare const make: <const Tag extends string, Success extends ValueSchema, const P extends PayloadOption = Schema.Void, Error extends DeclaredError = Schema.Never>(tag: Tag, options: {
+    readonly success: Success;
+    readonly payload?: P;
+    readonly error?: Error;
+    readonly progress?: {
+        readonly jobs: ReadonlyArray<ProgressJob>;
+    };
+}) => Stream<Tag, PayloadOf<P>, Success, Error>;
+/**
+ * `StreamMember.make` is `Actor.stream`: declares a live, read-only feed by
+ * tag. `success` types each element; `payload` defaults to `Schema.Void`, and
+ * `progress.jobs` lists the jobs whose executor progress the handler may follow.
+ *
+ * @example
+ * const Ticks = Actor.stream("Ticks", { success: Schema.Int })
+ */
+export declare const StreamMember: {
+    make: typeof make;
+};
+export {};

package/dist/members/stream.js

@@ -0,0 +1,14 @@
+import { member, } from "./command.js";
+const make = (tag, options) => ({
+    ...member("stream")(tag, options),
+    progress: options.progress,
+});
+/**
+ * `StreamMember.make` is `Actor.stream`: declares a live, read-only feed by
+ * tag. `success` types each element; `payload` defaults to `Schema.Void`, and
+ * `progress.jobs` lists the jobs whose executor progress the handler may follow.
+ *
+ * @example
+ * const Ticks = Actor.stream("Ticks", { success: Schema.Int })
+ */
+export const StreamMember = { make };