@rikalabs/akter 0.1.0-alpha.0

package/dist/index.d.ts

@@ -0,0 +1,159 @@
+import { Effect } from "effect";
+import { InTurn } from "./handles/intents.ts";
+import { InStream } from "./contexts/command.ts";
+import { type Caller } from "./identity/caller.ts";
+import { Query } from "./members/command.ts";
+import { Connection } from "./members/connection.ts";
+import { Cancelled, DeadLetter } from "./members/job.ts";
+import { blob, content } from "./members/blob.ts";
+import { table } from "./tables/owned.ts";
+import { Delivery } from "./members/subscription.ts";
+/**
+ * The declaration namespace of `@rikalabs/akter`: one constructor per
+ * kind of member, the actor definition, and the ambient-context combinators.
+ * Everything here is browser-safe declaration data; serving and runtime
+ * assembly live in `@rikalabs/akter/runtime`. An invalid definition
+ * throws when it is built, not when the actor first runs.
+ *
+ * @example
+ * const Increment = Actor.command("Increment", { success: Schema.Int })
+ * const Counter = Actor.make("Counter", { key: Schema.String, api: { Increment } })
+ */
+export declare const Actor: {
+    /** Defines an actor type: its key, state, events, tables, blobs, members, creation, schedules, jobs, subscriptions, and policy. */
+    make: import("./actor/definition.ts").Make;
+    /** Declares a command member; see `Command.make`. */
+    command: <const Tag extends string, const P extends import("./index.ts").PayloadOption = import("effect/Schema").Void, Success extends import("./members/command.ts").ValueSchema = import("effect/Schema").Void, Error extends import("./index.ts").DeclaredError = import("effect/Schema").Never>(tag: Tag, options?: {
+        readonly payload?: P | undefined;
+        readonly success?: Success | undefined;
+        readonly error?: Error | undefined;
+    } | undefined) => import("./members/command.ts").Member<"command", Tag, import("./members/command.ts").PayloadOf<P>, Success, Error>;
+    /** Declares a query member; see `Query.make`. */
+    query: <const Tag extends string, const P extends import("./index.ts").PayloadOption = import("effect/Schema").Void, Success extends import("./members/command.ts").ValueSchema = import("effect/Schema").Void, Error extends import("./index.ts").DeclaredError = import("effect/Schema").Never, const Watch extends boolean = false>(tag: Tag, options?: {
+        readonly payload?: P;
+        readonly success?: Success;
+        readonly error?: Error;
+        readonly watch?: Watch;
+    }) => Query<Tag, import("./members/command.ts").PayloadOf<P>, Success, Error, Watch>;
+    /** Declares a connection member: a long-lived session between one client and the actor. */
+    connection: <const Tag extends string, Server extends import("./members/command.ts").ValueSchema, const P extends import("./index.ts").PayloadOption = import("effect/Schema").Void, Client extends import("./members/command.ts").ValueSchema = import("effect/Schema").Never, Session extends import("./members/command.ts").ValueSchema | undefined = undefined, Error extends import("./index.ts").DeclaredError = import("effect/Schema").Never, Jobs extends import("./index.ts").ProgressJob = never>(tag: Tag, options: {
+        readonly server: Server;
+        readonly payload?: P;
+        readonly client?: Client;
+        readonly session?: Session;
+        readonly error?: Error;
+        readonly stampCursor?: boolean;
+        readonly progress?: {
+            readonly jobs: ReadonlyArray<Jobs>;
+            readonly to?: "principal" | "all";
+        };
+    }) => Connection<Tag, import("./members/command.ts").PayloadOf<P>, Server, Client, Session, Error, Jobs>;
+    /** Declares a stream member: a live, read-only feed for one subscriber. */
+    stream: <const Tag extends string, Success extends import("./members/command.ts").ValueSchema, const P extends import("./index.ts").PayloadOption = import("effect/Schema").Void, Error extends import("./index.ts").DeclaredError = import("effect/Schema").Never>(tag: Tag, options: {
+        readonly success: Success;
+        readonly payload?: P;
+        readonly error?: Error;
+        readonly progress?: {
+            readonly jobs: ReadonlyArray<import("./index.ts").ProgressJob>;
+        };
+    }) => import("./index.ts").StreamMember<Tag, import("./members/command.ts").PayloadOf<P>, Success, Error>;
+    /** Declares a workflow member and its typed step constructors. */
+    workflow: <const Tag extends string, const PayloadFields extends Readonly<Record<string, import("./members/command.ts").ValueSchema>> = {}, Success extends import("./members/command.ts").ValueSchema = import("effect/Schema").Void, Error extends import("./index.ts").DeclaredError = import("effect/Schema").Never>(tag: Tag, options?: {
+        readonly payload?: PayloadFields;
+        readonly success?: Success;
+        readonly error?: Error;
+        readonly key?: (payload: import("effect/Schema").Struct<PayloadFields>["Type"]) => string;
+        readonly versions?: Readonly<Record<string, import("./members/workflow.ts").VersionRange>>;
+    }) => import("./index.ts").Workflow<Tag, import("effect/Schema").Struct<PayloadFields>, Success, Error>;
+    /** Declares a durable event class: `const Posted = Actor.event("Posted", fields)`. */
+    event: <const Tag extends string, const Fields extends import("effect/Schema").Struct.Fields>(tag: Tag, fields: Fields, options?: import("./index.ts").PayloadOptions) => import("./index.ts").EventOf<Tag, Fields>;
+    /** Declares a pure state transition the server runs as an ordinary command turn; a batched one folds queued calls in order. */
+    reducer: import("./members/reducer.ts").MakeReducer;
+    /** Declares a job class: a request for external I/O that a turn enqueues and an executor runs after commit. */
+    job: <const Tag extends string, const Fields extends import("./members/command.ts").PayloadFields = {}, Success extends import("./members/command.ts").ValueSchema = import("effect/Schema").Void, Progress extends import("./members/command.ts").ValueSchema | undefined = undefined>(tag: Tag, options?: {
+        readonly payload?: Fields;
+        readonly success?: Success;
+        readonly progress?: Progress;
+        readonly migrations?: import("./index.ts").PayloadMigrations;
+        readonly writeVersion?: number;
+    }) => import("./index.ts").JobClass<Tag, Fields, Success, Progress>;
+    /** The payload schema of a job binding's `onDeadLetter` command: `Actor.DeadLetter(J)`. */
+    DeadLetter: typeof DeadLetter;
+    /** The payload schema of a job binding's `onCancelled` command: `Actor.Cancelled(J)`. */
+    Cancelled: typeof Cancelled;
+    /** Declares an actor's keyed state fields and their migrations. */
+    state: <const F extends Readonly<Record<string, import("./members/command.ts").ValueSchema>>>(fields: F, options?: {
+        readonly migrations?: ReadonlyArray<import("./state/migration.ts").StateMigration>;
+    }) => import("./state/migration.ts").ActorState<F>;
+    /** Declares an actor-owned Drizzle table whose rows carry the writing actor's identity. */
+    table: typeof table;
+    /** Declares named binary storage an actor lists in `blobs`. */
+    blob: typeof blob;
+    /** Declares shared content: immutable bytes stored once per tenant that actors reference by name. */
+    content: typeof content;
+    /** Builds one step of a state, event, or job migration chain. */
+    migration: <const From extends Readonly<Record<string, import("./members/command.ts").ValueSchema>>, const To extends Readonly<Record<string, import("./members/command.ts").ValueSchema>>>(from: From, to: To, upcast: import("./state/migration.ts").StateMigration<From, To>["upcast"], options?: {
+        readonly downcast?: (next: import("effect/Schema").Struct<To>["Type"]) => import("effect/Schema").Struct<From>["Type"];
+    }) => import("./state/migration.ts").StateMigration<From, To>;
+    /** The key of an actor with one instance per tenant; its handle is `X.get()`. */
+    singleton: {
+        readonly _tag: "Singleton";
+    };
+    /** Declares a subscription to another actor type's committed events. */
+    subscription: import("./members/subscription.ts").SubscriptionFunction;
+    /** The payload schema of a subscription handler, which also names the source and events it delivers. */
+    Delivery: typeof Delivery;
+    /**
+     * Ready-made `access` policies for `Actor.make`. `public` allows every caller
+     * and kind, which opens the actor to anyone who can reach the server; use it
+     * only for demos and deliberately public actors.
+     */
+    access: {
+        public: import("./index.ts").Access;
+    };
+    /** Provided by the runtime only inside command turns; `X.intents` requires it. */
+    InTurn: typeof InTurn;
+    /** Provided by the runtime only inside stream handlers; `read.follow` requires it. */
+    InStream: typeof InStream;
+    /** Runs the piped Effect with `caller` as the ambient caller that handles capture, for trusted code that acts on behalf of a user; without it, in-process code is `System({ source: "process" })`. */
+    as: (caller: Caller) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, never>>;
+    /** Runs the piped Effect in `tenant`, for trusted code that acts on behalf of a tenant; the default tenant is `"default"`. */
+    tenant: (tenant: string) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, never>>;
+    /** Gives the command call of the piped Effect the explicit command id `id`, so a retry across processes keeps one identity. */
+    commandId: (id: string) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, never>>;
+};
+export type { Aggregate, AggregateKind, AnyFleetView, DerivedTable, FleetFilter, FleetOptions, FleetPage, FleetRow, FleetView, } from "./tables/fleet.ts";
+export { Fleet } from "./tables/fleet.ts";
+export { Actors } from "./handles/actors.ts";
+export { Intent } from "./handles/intents.ts";
+export { Content, ContentStore } from "./handles/content.ts";
+export type { WorkflowRun } from "./handles/run.ts";
+export type { ConnectionHandlers, Executors, Handle, Intents, StreamHandler, } from "./actor/definition.ts";
+export { ActorRef, Anonymous, Caller, CurrentCaller, Tenant, User, System, Principal, } from "./identity/caller.ts";
+export { ContentRef } from "./identity/content.ts";
+export type { ContentEntry } from "./identity/content.ts";
+export type { Access, AccessRequest } from "./policies/access.ts";
+export type { Policy } from "./policies/command.ts";
+export { ActorError, ActorUnavailable, CommandConflict, CommandExpired, InvalidCommandId, InvalidInput, Unauthorized, Timeout, NotCreated, MailboxFull, RunnerAtCapacity, QuotaExceeded, SpendLimitExceeded, ConnectionLimitExceeded, StorageQuotaExceeded, SessionEnded, } from "./errors/actor.ts";
+export { RetentionGap, UnknownCursor } from "./errors/events.ts";
+export { ContentTooLarge, InvalidContentRef } from "./errors/content.ts";
+export { ActivityOutcomeUnknown, InvalidExecutionId, InvalidExecutionKey, } from "./errors/workflow.ts";
+export type { Race, Sleep, Step, Wait, Workflow } from "./members/workflow.ts";
+export type { AnyConnection, Connection } from "./members/connection.ts";
+export type { AnyStream, Stream as StreamMember } from "./members/stream.ts";
+export type { AnyJob, JobBinding, JobClass, ProgressJob, ProgressOf } from "./members/job.ts";
+export type { EventOf } from "./members/event.ts";
+export type { DeclaredError, PayloadOption } from "./members/command.ts";
+export type { PayloadMigrations, PayloadOptions } from "./members/payload.ts";
+export type { Batch, Reducer } from "./members/reducer.ts";
+export type { AnyBlob, AnyContent, Blob, ContentBlob } from "./members/blob.ts";
+export type { AnySubscription, DeliveredEvent, DeliveredGap, DeliveredRejection, Delivery, DeliverySchema, Route, SubscribeContext, SubscribeFrom, Subscription, } from "./members/subscription.ts";
+export type { CommandContext, EventEntry, QueryContext, Turn } from "./contexts/command.ts";
+export type { WorkflowContext } from "./contexts/workflow.ts";
+export type { EnqueueContext, EnqueueOptions, ExecutorContext } from "./contexts/job.ts";
+export type { BroadcastContext, BroadcastOptions, ConnectionContext, ConnectionInfo, FrameOf, SessionAccess, } from "./contexts/connection.ts";
+export type { BlobRead, BlobWrite, ContentRead, ContentWrite } from "./state/blob.ts";
+export type { Filter, Filtered, Group, GroupDatabase, Insert, ListOptions, Order, AdoptedTable, AdoptOptions, OwnedTable, OwnerColumns, ReadAdoptedTable, ReadOptions, Row, ScopedRead, ScopedRows, } from "./tables/owned.ts";
+export { ASSERTION_HEADER, ASSERTION_TYPE, canonicalRequest, KEY_REFRESH_PATH, KEY_REFRESH_TYPE, reauthenticationDigest, requestDigest, } from "./serve/assertion/binding.ts";
+export type { BoundRequest } from "./serve/assertion/binding.ts";
+export { ClientWireMessage, ServerWireMessage, SUBPROTOCOL } from "./protocol/frames.ts";

package/dist/index.js

@@ -0,0 +1,97 @@
+import { Effect } from "effect";
+import { Definition } from "./actor/definition.js";
+import { InTurn } from "./handles/intents.js";
+import { InStream } from "./contexts/command.js";
+import { CurrentCommandId } from "./identity/command.js";
+import { CurrentCaller, Tenant } from "./identity/caller.js";
+import { Command, Query } from "./members/command.js";
+import { Connection } from "./members/connection.js";
+import { StreamMember } from "./members/stream.js";
+import { EventMember } from "./members/event.js";
+import { Reducer } from "./members/reducer.js";
+import { Cancelled, DeadLetter, JobMember } from "./members/job.js";
+import { ActorStates } from "./state/migration.js";
+import { blob, content } from "./members/blob.js";
+import { table } from "./tables/owned.js";
+import { WorkflowMember } from "./runtime/workflows/steps.js";
+import { Delivery, SubscriptionMember } from "./members/subscription.js";
+import { publicAccess } from "./policies/access.js";
+/**
+ * The declaration namespace of `@rikalabs/akter`: one constructor per
+ * kind of member, the actor definition, and the ambient-context combinators.
+ * Everything here is browser-safe declaration data; serving and runtime
+ * assembly live in `@rikalabs/akter/runtime`. An invalid definition
+ * throws when it is built, not when the actor first runs.
+ *
+ * @example
+ * const Increment = Actor.command("Increment", { success: Schema.Int })
+ * const Counter = Actor.make("Counter", { key: Schema.String, api: { Increment } })
+ */
+export const Actor = {
+    /** Defines an actor type: its key, state, events, tables, blobs, members, creation, schedules, jobs, subscriptions, and policy. */
+    make: Definition.make,
+    /** Declares a command member; see `Command.make`. */
+    command: Command.make,
+    /** Declares a query member; see `Query.make`. */
+    query: Query.make,
+    /** Declares a connection member: a long-lived session between one client and the actor. */
+    connection: Connection.make,
+    /** Declares a stream member: a live, read-only feed for one subscriber. */
+    stream: StreamMember.make,
+    /** Declares a workflow member and its typed step constructors. */
+    workflow: WorkflowMember.make,
+    /** Declares a durable event class: `const Posted = Actor.event("Posted", fields)`. */
+    event: EventMember.make,
+    /** Declares a pure state transition the server runs as an ordinary command turn; a batched one folds queued calls in order. */
+    reducer: Reducer.make,
+    /** Declares a job class: a request for external I/O that a turn enqueues and an executor runs after commit. */
+    job: JobMember.make,
+    /** The payload schema of a job binding's `onDeadLetter` command: `Actor.DeadLetter(J)`. */
+    DeadLetter,
+    /** The payload schema of a job binding's `onCancelled` command: `Actor.Cancelled(J)`. */
+    Cancelled,
+    /** Declares an actor's keyed state fields and their migrations. */
+    state: ActorStates.make,
+    /** Declares an actor-owned Drizzle table whose rows carry the writing actor's identity. */
+    table,
+    /** Declares named binary storage an actor lists in `blobs`. */
+    blob,
+    /** Declares shared content: immutable bytes stored once per tenant that actors reference by name. */
+    content,
+    /** Builds one step of a state, event, or job migration chain. */
+    migration: ActorStates.migration,
+    /** The key of an actor with one instance per tenant; its handle is `X.get()`. */
+    singleton: Definition.singleton,
+    /** Declares a subscription to another actor type's committed events. */
+    subscription: SubscriptionMember.make,
+    /** The payload schema of a subscription handler, which also names the source and events it delivers. */
+    Delivery,
+    /**
+     * Ready-made `access` policies for `Actor.make`. `public` allows every caller
+     * and kind, which opens the actor to anyone who can reach the server; use it
+     * only for demos and deliberately public actors.
+     */
+    access: { public: publicAccess },
+    /** Provided by the runtime only inside command turns; `X.intents` requires it. */
+    InTurn,
+    /** Provided by the runtime only inside stream handlers; `read.follow` requires it. */
+    InStream,
+    /** Runs the piped Effect with `caller` as the ambient caller that handles capture, for trusted code that acts on behalf of a user; without it, in-process code is `System({ source: "process" })`. */
+    as: (caller) => (effect) => Effect.provideService(effect, CurrentCaller, caller),
+    /** Runs the piped Effect in `tenant`, for trusted code that acts on behalf of a tenant; the default tenant is `"default"`. */
+    tenant: (tenant) => (effect) => Effect.provideService(effect, Tenant, tenant),
+    /** Gives the command call of the piped Effect the explicit command id `id`, so a retry across processes keeps one identity. */
+    commandId: (id) => (effect) => Effect.provideService(effect, CurrentCommandId, id),
+};
+export { Fleet } from "./tables/fleet.js";
+export { Actors } from "./handles/actors.js";
+export { Intent } from "./handles/intents.js";
+export { Content, ContentStore } from "./handles/content.js";
+export { ActorRef, Anonymous, Caller, CurrentCaller, Tenant, User, System, Principal, } from "./identity/caller.js";
+export { ContentRef } from "./identity/content.js";
+export { ActorError, ActorUnavailable, CommandConflict, CommandExpired, InvalidCommandId, InvalidInput, Unauthorized, Timeout, NotCreated, MailboxFull, RunnerAtCapacity, QuotaExceeded, SpendLimitExceeded, ConnectionLimitExceeded, StorageQuotaExceeded, SessionEnded, } from "./errors/actor.js";
+export { RetentionGap, UnknownCursor } from "./errors/events.js";
+export { ContentTooLarge, InvalidContentRef } from "./errors/content.js";
+export { ActivityOutcomeUnknown, InvalidExecutionId, InvalidExecutionKey, } from "./errors/workflow.js";
+export { ASSERTION_HEADER, ASSERTION_TYPE, canonicalRequest, KEY_REFRESH_PATH, KEY_REFRESH_TYPE, reauthenticationDigest, requestDigest, } from "./serve/assertion/binding.js";
+export { ClientWireMessage, ServerWireMessage, SUBPROTOCOL } from "./protocol/frames.js";

package/dist/members/blob.d.ts

@@ -0,0 +1,43 @@
+declare const BlobTypeId: unique symbol;
+declare const ContentTypeId: unique symbol;
+/**
+ * A declared blob: named binary entries each actor of a listing type stores in
+ * `actor_blobs`, scoped like every other row the actor owns.
+ */
+export interface Blob<Name extends string = string> {
+    readonly [BlobTypeId]: Name;
+    readonly kind: "blob";
+    readonly name: Name;
+}
+/**
+ * Declared content: named references to immutable bytes stored once per
+ * tenant. A turn attaches and detaches references; only off-turn reads see bytes.
+ */
+export interface ContentBlob<Name extends string = string> {
+    readonly [ContentTypeId]: Name;
+    readonly kind: "content";
+    readonly name: Name;
+}
+/** Any declared content, whatever its name. */
+export type AnyContent = ContentBlob<string>;
+/** Anything an actor lists in `blobs`: its own mutable bytes or references to shared content. */
+export type AnyBlob = Blob<string> | AnyContent;
+/** Whether `value` was made by `blob` or `content`. */
+export declare const isBlob: (value: unknown) => value is AnyBlob;
+/** Whether a declared blob is content. Tolerates a value that is not a blob at all, which the declared-blob check then refuses. */
+export declare const isContent: (value: AnyBlob) => value is AnyContent;
+/**
+ * `Actor.blob`: declares binary storage an actor lists in `blobs`; the name
+ * keys its entries. Throws unless `name` is 1-80 letters, digits, `-` or `_`,
+ * starting with a letter.
+ *
+ * @example
+ * const Avatar = Actor.blob("avatar")
+ */
+export declare const blob: <const Name extends string>(name: Name) => Blob<Name>;
+/**
+ * Declares shared content an actor lists in `blobs`; the name keys its
+ * references. The name rules are those of `blob`.
+ */
+export declare const content: <const Name extends string>(name: Name) => ContentBlob<Name>;
+export {};

package/dist/members/blob.js

@@ -0,0 +1,29 @@
+import { Predicate } from "effect";
+/** Only values made by `blob` and `content` are registered, so a look-alike object cannot name another namespace. */
+const declared = new WeakSet();
+/** Whether `value` was made by `blob` or `content`. */
+export const isBlob = (value) => value instanceof Object && declared.has(value);
+/** Whether a declared blob is content. Tolerates a value that is not a blob at all, which the declared-blob check then refuses. */
+export const isContent = (value) => Predicate.hasProperty(value, "kind") && value.kind === "content";
+const NAME = /^[A-Za-z][A-Za-z0-9_-]{0,79}$/;
+const declare = (kind, name) => {
+    if (!NAME.test(name))
+        throw new Error(`Blob name ${name} must be 1-80 letters, digits, - or _, starting with a letter`);
+    const value = Object.freeze({ kind, name });
+    declared.add(value);
+    return value;
+};
+/**
+ * `Actor.blob`: declares binary storage an actor lists in `blobs`; the name
+ * keys its entries. Throws unless `name` is 1-80 letters, digits, `-` or `_`,
+ * starting with a letter.
+ *
+ * @example
+ * const Avatar = Actor.blob("avatar")
+ */
+export const blob = (name) => declare("blob", name);
+/**
+ * Declares shared content an actor lists in `blobs`; the name keys its
+ * references. The name rules are those of `blob`.
+ */
+export const content = (name) => declare("content", name);

package/dist/members/command.d.ts

@@ -0,0 +1,109 @@
+import { type Cause, Schema } from "effect";
+/** A schema that needs no Effect services to encode or decode, so a member codec runs anywhere. */
+export type ValueSchema = Schema.Top & {
+    readonly DecodingServices: never;
+    readonly EncodingServices: never;
+};
+/**
+ * The `error` schema of a member: a tagged error class, a `Schema.Union` of
+ * them, or `Schema.Never`. A handler may fail with its values and callers
+ * receive them as typed failures; a framework reason can never masquerade as one.
+ */
+export type DeclaredError = ValueSchema & {
+    readonly Type: Cause.YieldableError & {
+        readonly _tag: string;
+    };
+};
+/** The struct fields a `payload` option may name instead of a schema. */
+export type PayloadFields = Readonly<Record<string, ValueSchema>>;
+/** A `payload` option: a schema, or struct fields that stand for `Schema.Struct(fields)`. */
+export type PayloadOption = ValueSchema | PayloadFields;
+/** The schema a `payload` option stands for. */
+export type PayloadOf<P extends PayloadOption> = P extends ValueSchema ? P : P extends Schema.Struct.Fields ? Schema.Struct<P> : never;
+/** The kinds of member an actor definition lists. */
+export type MemberKind = "command" | "query" | "reducer" | "connection" | "stream" | "workflow";
+/**
+ * An `api` or `internal` member. Commands and reducers run as fenced,
+ * receipted turns; queries read committed state without an activation.
+ */
+export interface Member<Kind extends MemberKind, Tag extends string, Payload extends ValueSchema, Success extends ValueSchema, Error extends DeclaredError> {
+    readonly kind: Kind;
+    readonly tag: Tag;
+    readonly payload: Payload;
+    readonly success: Success;
+    readonly error: Error;
+}
+/** A command member: a fenced, receipted turn that may change state, emit events, and stage intents and jobs. */
+export type Command<Tag extends string, Payload extends ValueSchema, Success extends ValueSchema, Error extends DeclaredError> = Member<"command", Tag, Payload, Success, Error>;
+/**
+ * A query member: reads committed state without activating the actor, taking
+ * the fence, or writing a receipt. A `watch` query can also be observed: its
+ * handler may use only `Read`, so the runtime can record what it read.
+ */
+export type Query<Tag extends string, Payload extends ValueSchema, Success extends ValueSchema, Error extends DeclaredError, Watch extends boolean = boolean> = Member<"query", Tag, Payload, Success, Error> & {
+    readonly watch: Watch;
+};
+/** Any `api` or `internal` member, whatever its schemas. */
+export type AnyMember = Member<MemberKind, string, ValueSchema, ValueSchema, DeclaredError>;
+/** Any command, whatever its schemas. */
+export type AnyCommand = Command<string, ValueSchema, ValueSchema, DeclaredError>;
+/** A record of members keyed by tag, as used by the `api` and `internal` definition sections. */
+export type MemberRecord = Readonly<Record<string, AnyMember>>;
+/** A record of commands keyed by tag. */
+export type CommandRecord = Readonly<Record<string, AnyCommand>>;
+/** Normalizes a `payload` option once: struct fields become `Schema.Struct(fields)`. */
+export declare const payloadSchema: <P extends PayloadOption>(payload: P | undefined) => PayloadOf<P>;
+/**
+ * The tagged error classes an `error` schema admits, flattening unions;
+ * `Schema.Never` admits none. The served protocol assigns each one its status.
+ */
+export declare const declaredErrors: (error: DeclaredError) => ReadonlyArray<DeclaredError>;
+/**
+ * Builds a member of `kind`: `payload` and `success` default to `Schema.Void`
+ * and `error` to `Schema.Never`.
+ */
+export declare const member: <Kind extends MemberKind>(kind: Kind) => <const Tag extends string, const P extends PayloadOption = Schema.Void, Success extends ValueSchema = Schema.Void, Error extends DeclaredError = Schema.Never>(tag: Tag, options?: {
+    readonly payload?: P;
+    readonly success?: Success;
+    readonly error?: Error;
+}) => Member<Kind, Tag, PayloadOf<P>, Success, Error>;
+/**
+ * `Command.make` is `Actor.command`: declares a command by tag. `payload` is a
+ * schema or struct fields and `success` a schema, both `Schema.Void` when
+ * omitted; `error` is the tagged error class, or `Schema.Union` of them, its
+ * handler may fail with, which callers receive as typed failures.
+ *
+ * @example
+ * const Increment = Actor.command("Increment", {
+ *   payload: { by: Schema.Int },
+ *   success: Schema.Int,
+ * })
+ */
+export declare const Command: {
+    make: <const Tag extends string, const P extends PayloadOption = Schema.Void, Success extends ValueSchema = Schema.Void, Error extends DeclaredError = Schema.Never>(tag: Tag, options?: {
+        readonly payload?: P | undefined;
+        readonly success?: Success | undefined;
+        readonly error?: Error | undefined;
+    } | undefined) => Member<"command", Tag, PayloadOf<P>, Success, Error>;
+};
+/**
+ * `Query.make` is `Actor.query`: declares a query by tag, with the same
+ * options as a command. A query reads committed state only and never
+ * activates the actor. With `watch: true` the query can also be observed
+ * (`handle.Total.watch()`): its handler may require nothing but `X.Read`,
+ * because the runtime records which state, event classes, tables, and blobs
+ * each rerun reads and reruns only after a commit that wrote one of them. It
+ * sees the clock and random sources as of its rerun, and they trigger no
+ * rerun of their own.
+ *
+ * @example
+ * const Total = Actor.query("Total", { success: Schema.Int, watch: true })
+ */
+export declare const Query: {
+    make: <const Tag extends string, const P extends PayloadOption = Schema.Void, Success extends ValueSchema = Schema.Void, Error extends DeclaredError = Schema.Never, const Watch extends boolean = false>(tag: Tag, options?: {
+        readonly payload?: P;
+        readonly success?: Success;
+        readonly error?: Error;
+        readonly watch?: Watch;
+    }) => Query<Tag, PayloadOf<P>, Success, Error, Watch>;
+};

package/dist/members/command.js

@@ -0,0 +1,61 @@
+import { Predicate, Schema, SchemaAST } from "effect";
+/** Normalizes a `payload` option once: struct fields become `Schema.Struct(fields)`. */
+export const payloadSchema = (payload) => (payload === undefined
+    ? Schema.Void
+    : Schema.isSchema(payload)
+        ? payload
+        : Schema.Struct(payload));
+/**
+ * The tagged error classes an `error` schema admits, flattening unions;
+ * `Schema.Never` admits none. The served protocol assigns each one its status.
+ */
+export const declaredErrors = (error) => {
+    if (SchemaAST.isNever(error.ast))
+        return [];
+    if (Predicate.hasProperty(error, "members") && Array.isArray(error.members))
+        return error.members.flatMap(declaredErrors);
+    return [error];
+};
+/**
+ * Builds a member of `kind`: `payload` and `success` default to `Schema.Void`
+ * and `error` to `Schema.Never`.
+ */
+export const member = (kind) => (tag, options) => ({
+    kind,
+    tag,
+    payload: payloadSchema(options?.payload),
+    success: (options?.success ?? Schema.Void),
+    error: (options?.error ?? Schema.Never),
+});
+/**
+ * `Command.make` is `Actor.command`: declares a command by tag. `payload` is a
+ * schema or struct fields and `success` a schema, both `Schema.Void` when
+ * omitted; `error` is the tagged error class, or `Schema.Union` of them, its
+ * handler may fail with, which callers receive as typed failures.
+ *
+ * @example
+ * const Increment = Actor.command("Increment", {
+ *   payload: { by: Schema.Int },
+ *   success: Schema.Int,
+ * })
+ */
+export const Command = { make: member("command") };
+/**
+ * `Query.make` is `Actor.query`: declares a query by tag, with the same
+ * options as a command. A query reads committed state only and never
+ * activates the actor. With `watch: true` the query can also be observed
+ * (`handle.Total.watch()`): its handler may require nothing but `X.Read`,
+ * because the runtime records which state, event classes, tables, and blobs
+ * each rerun reads and reruns only after a commit that wrote one of them. It
+ * sees the clock and random sources as of its rerun, and they trigger no
+ * rerun of their own.
+ *
+ * @example
+ * const Total = Actor.query("Total", { success: Schema.Int, watch: true })
+ */
+export const Query = {
+    make: (tag, options) => ({
+        ...member("query")(tag, options),
+        watch: (options?.watch ?? false),
+    }),
+};

package/dist/members/connection.d.ts

@@ -0,0 +1,55 @@
+import { Schema } from "effect";
+import { type DeclaredError, type Member, type PayloadOf, type PayloadOption, type ValueSchema } from "./command.ts";
+import type { ProgressJob } from "./job.ts";
+/**
+ * A long-lived session between one client and one actor. Its `payload` is
+ * the open params; `server` frames flow to the client and `client` frames to the
+ * actor; `session` is the per-connection state the handlers may set.
+ */
+export interface Connection<Tag extends string, Params extends ValueSchema, Server extends ValueSchema, Client extends ValueSchema, Session extends ValueSchema | undefined, Error extends DeclaredError, Jobs extends ProgressJob = never> extends Member<"connection", Tag, Params, typeof Schema.Void, Error> {
+    readonly server: Server;
+    readonly client: Client;
+    readonly session: Session;
+    /** Stamp member frames with the flushed-through cursor and event cursor. Default true. */
+    readonly stampCursor: boolean;
+    /** Executor progress this member's connections receive, if any. */
+    readonly progress: ConnectionProgress<Jobs> | undefined;
+}
+/**
+ * The jobs whose executor progress a connection member receives, and to
+ * whom: `"principal"` (the default) only connections whose caller has the
+ * enqueueing turn's principal, `"all"` every open connection of the member.
+ */
+interface ConnectionProgress<Jobs extends ProgressJob> {
+    readonly jobs: ReadonlyArray<Jobs>;
+    readonly to: "principal" | "all";
+}
+/** Any connection member, whatever its schemas. */
+export type AnyConnection = Connection<string, ValueSchema, ValueSchema, ValueSchema, ValueSchema | undefined, DeclaredError, ProgressJob>;
+declare const make: <const Tag extends string, Server extends ValueSchema, const P extends PayloadOption = typeof Schema.Void, Client extends ValueSchema = typeof Schema.Never, Session extends ValueSchema | undefined = undefined, Error extends DeclaredError = typeof Schema.Never, Jobs extends ProgressJob = never>(tag: Tag, options: {
+    readonly server: Server;
+    readonly payload?: P;
+    readonly client?: Client;
+    readonly session?: Session;
+    readonly error?: Error;
+    readonly stampCursor?: boolean;
+    readonly progress?: {
+        readonly jobs: ReadonlyArray<Jobs>;
+        readonly to?: "principal" | "all";
+    };
+}) => Connection<Tag, PayloadOf<P>, Server, Client, Session, Error, Jobs>;
+/**
+ * `Connection.make` is `Actor.connection`: declares a connection by tag.
+ * `server` types the frames sent to the client; `payload` the open params,
+ * `client` the frames it may send, and `session` the per-connection state
+ * handlers may set. Throws when the tag starts with `$`, which names framework
+ * members such as the one an event feed opens, or when a frame schema uses a
+ * reserved control tag (`Resync`, `ResyncReplayed`, `ResyncDone`).
+ *
+ * @example
+ * const Room = Actor.connection("Room", { server: Message, client: Say })
+ */
+export declare const Connection: {
+    make: typeof make;
+};
+export {};

package/dist/members/connection.js

@@ -0,0 +1,49 @@
+import { Schema, SchemaAST } from "effect";
+import { member, } from "./command.js";
+/** Tags reserved for framework control frames, which travel in their own envelope variant. */
+const CONTROL_TAGS = new Set(["Resync", "ResyncReplayed", "ResyncDone"]);
+const taggedIdentifiers = (schema) => {
+    const ast = SchemaAST.toEncoded(schema.ast);
+    const members = SchemaAST.isUnion(ast) ? ast.types : [ast];
+    const tags = [];
+    for (const member of members)
+        if (SchemaAST.isObjects(member))
+            for (const signature of member.propertySignatures)
+                if (signature.name === "_tag" && SchemaAST.isLiteral(signature.type))
+                    tags.push(String(signature.type.literal));
+    return tags;
+};
+const make = (tag, options) => {
+    if (tag.startsWith("$"))
+        throw new Error(`Connection ${tag} may not start with $`);
+    for (const schema of [options.server, options.client])
+        if (schema !== undefined)
+            for (const reserved of taggedIdentifiers(schema))
+                if (CONTROL_TAGS.has(reserved))
+                    throw new Error(`Connection ${tag} frames may not use the control tag ${reserved}`);
+    return {
+        ...member("connection")(tag, {
+            payload: options.payload,
+            error: options.error,
+        }),
+        server: options.server,
+        client: (options.client ?? Schema.Never),
+        session: options.session,
+        stampCursor: options.stampCursor ?? true,
+        progress: options.progress === undefined
+            ? undefined
+            : { jobs: options.progress.jobs, to: options.progress.to ?? "principal" },
+    };
+};
+/**
+ * `Connection.make` is `Actor.connection`: declares a connection by tag.
+ * `server` types the frames sent to the client; `payload` the open params,
+ * `client` the frames it may send, and `session` the per-connection state
+ * handlers may set. Throws when the tag starts with `$`, which names framework
+ * members such as the one an event feed opens, or when a frame schema uses a
+ * reserved control tag (`Resync`, `ResyncReplayed`, `ResyncDone`).
+ *
+ * @example
+ * const Room = Actor.connection("Room", { server: Message, client: Say })
+ */
+export const Connection = { make };

package/dist/members/event.d.ts

@@ -0,0 +1,36 @@
+import { Schema } from "effect";
+import type { ValueSchema } from "./command.ts";
+import { type PayloadOptions } from "./payload.ts";
+/**
+ * A declared event class. Its schema identifier is its tag, which is stored
+ * with each committed event so replay can filter and decode by class.
+ */
+export type EventClass = ValueSchema & {
+    readonly identifier: string;
+    readonly Type: {
+        readonly _tag: string;
+    };
+};
+/** The class `Actor.event` returns for tag `Tag` and fields `Fields`. */
+export type EventOf<Tag extends string, Fields extends Schema.Struct.Fields> = Schema.Class<Schema.TaggedStruct<Tag, Fields>["Type"], Schema.TaggedStruct<Tag, Fields>, {}>;
+/**
+ * `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 })
+ */
+declare const make: <const Tag extends string, const Fields extends Schema.Struct.Fields>(tag: Tag, fields: Fields, options?: PayloadOptions) => EventOf<Tag, Fields>;
+/** `Actor.event`; see `make`. */
+export declare const EventMember: {
+    make: typeof make;
+};
+/** Entries one `read.events` call returns when the reader names no `limit`. */
+export declare const DEFAULT_REPLAY_LIMIT = 1000;
+/** The largest page a reader may ask for; it bounds rows per page, not their bytes. */
+export declare const MAX_REPLAY_LIMIT = 10000;
+export {};