@rikalabs/akter 0.1.0-alpha.0

package/dist/members/subscription.d.ts

@@ -0,0 +1,182 @@
+import { type DateTime, type Effect, Schema } from "effect";
+import { ActorRef } from "../identity/caller.ts";
+import type { AnyCommand } from "./command.ts";
+import type { EventClass } from "./event.ts";
+/** What a subscription needs of its source: an actor definition's name and declared events. */
+export interface SourceDefinition {
+    readonly name: string;
+    readonly events: ReadonlyArray<EventClass>;
+}
+/** One committed source event, as the subscriber's handler receives it. */
+export interface DeliveredEvent<E> {
+    readonly _tag: "Event";
+    /** The subscription's tag. */
+    readonly subscription: string;
+    /** The publisher. */
+    readonly source: ActorRef;
+    /** The event's cursor in the publisher's stream. */
+    readonly cursor: string;
+    readonly event: E;
+    /** The publisher's command that emitted it. */
+    readonly commandId: string;
+    readonly timestamp: DateTime.Utc;
+}
+/** Source history after `after` was pruned; the next delivery comes after `resumeAfter`. */
+export interface DeliveredGap {
+    readonly _tag: "RetentionGap";
+    readonly subscription: string;
+    readonly source: ActorRef;
+    readonly after: string;
+    readonly resumeAfter: string;
+}
+/** A dynamic subscription the source refused; it is no longer active. */
+export interface DeliveredRejection {
+    readonly _tag: "Rejected";
+    readonly subscription: string;
+    readonly source: ActorRef;
+    readonly reason: "UnknownCursor";
+    readonly cursor: string;
+}
+/** One subscription delivery: a handler receives exactly one per turn. */
+export type Delivery<E> = DeliveredEvent<E> | DeliveredGap | DeliveredRejection;
+declare const deliverySchema: <E extends ReadonlyArray<EventClass>>(events: E) => Schema.Union<readonly [Schema.TaggedStruct<"Event", {
+    readonly subscription: Schema.String;
+    readonly source: Schema.Struct<{
+        readonly tenant: Schema.NonEmptyString;
+        readonly actor: Schema.NonEmptyString;
+        readonly id: Schema.NonEmptyString;
+    }>;
+    readonly cursor: Schema.String;
+    readonly event: Schema.Union<E>;
+    readonly commandId: Schema.String;
+    readonly timestamp: Schema.DateTimeUtc;
+}>, Schema.TaggedStruct<"RetentionGap", {
+    readonly subscription: Schema.String;
+    readonly source: Schema.Struct<{
+        readonly tenant: Schema.NonEmptyString;
+        readonly actor: Schema.NonEmptyString;
+        readonly id: Schema.NonEmptyString;
+    }>;
+    readonly after: Schema.String;
+    readonly resumeAfter: Schema.String;
+}>, Schema.TaggedStruct<"Rejected", {
+    readonly subscription: Schema.String;
+    readonly source: Schema.Struct<{
+        readonly tenant: Schema.NonEmptyString;
+        readonly actor: Schema.NonEmptyString;
+        readonly id: Schema.NonEmptyString;
+    }>;
+    readonly reason: Schema.Literal<"UnknownCursor">;
+    readonly cursor: Schema.String;
+}>]>;
+/**
+ * The payload schema of a subscription handler, which also records what it
+ * delivers: `events` of `source`. A subscription names it as its `delivery`,
+ * so the source and events are declared once, and the handler command can be
+ * declared before the subscription that references it.
+ */
+export type DeliverySchema<S extends SourceDefinition = SourceDefinition, E extends ReadonlyArray<EventClass> = ReadonlyArray<EventClass>> = ReturnType<typeof deliverySchema<E>> & {
+    readonly source: S;
+    readonly events: E;
+};
+/**
+ * `Actor.Delivery`: the payload schema of a subscription handler, one delivery
+ * of `events` from `source`. Throws when `events` is empty or names an event
+ * `source` does not declare, or one twice.
+ *
+ * @example
+ * const OrderDelivery = Actor.Delivery({ source: Orders, events: [Placed] })
+ * const Record = Actor.command("Record", { payload: OrderDelivery })
+ */
+export declare const Delivery: <const S extends SourceDefinition, const E extends ReadonlyArray<S["events"][number]>>(options: {
+    readonly source: S;
+    readonly events: E;
+}) => DeliverySchema<S, E>;
+/** Declared as a method so a route of specific events still fits `AnySubscription`. */
+type RouteFunction<E> = {
+    route(event: E, source: ActorRef): string;
+}["route"];
+/** A routed subscription's route: the subscriber's id for one event, or every event to the tenant's singleton. */
+export type Route<E> = RouteFunction<E> | {
+    readonly _tag: "Singleton";
+};
+/**
+ * A declared subscription of one subscriber type, with the source and events
+ * of its delivery. `Routed` is true when it has a `route`, so `turn.subscribe`
+ * accepts only dynamic ones.
+ */
+export interface Subscription<Tag extends string, E extends ReadonlyArray<EventClass>, Routed extends boolean, H extends AnyCommand = AnyCommand> {
+    readonly kind: "subscription";
+    readonly tag: Tag;
+    /** The source definition, typed loosely so a subscriber's type doesn't embed its source's. */
+    readonly source: SourceDefinition;
+    readonly events: E;
+    readonly retired: ReadonlyArray<string>;
+    readonly handler: H;
+    readonly route: Route<E[number]["Type"]> | undefined;
+    readonly routed: Routed;
+}
+/** Any subscription, whatever its source and events. */
+export type AnySubscription = Subscription<string, ReadonlyArray<EventClass>, boolean>;
+/** A handler command whose payload doesn't accept the subscription's deliveries fails to compile. */
+type Accepting<H extends AnyCommand, E> = [Delivery<E>] extends [H["payload"]["Type"]] ? unknown : {
+    readonly "The handler's payload must accept the subscription's delivery": never;
+};
+interface SubscriptionOptions<D extends DeliverySchema, H> {
+    /** The source and events this subscription delivers, declared once with `Actor.Delivery`. */
+    readonly delivery: D;
+    /** The `internal` command each delivery runs as a turn; several subscriptions may share it. */
+    readonly handler: H;
+    /** Event tags this subscription once delivered; rows carrying them skip them. */
+    readonly retired?: ReadonlyArray<string>;
+}
+/**
+ * Declares a subscription: every committed event its `delivery` names reaches
+ * `handler`, an internal command of the subscriber, as an ordinary command
+ * turn. With `route` it is routed: every source of the type in the
+ * tenant, to the subscriber `route` names. Without it, it is dynamic: only the
+ * sources a subscriber's turn subscribes to.
+ */
+export interface SubscriptionFunction {
+    <const Tag extends string, const D extends DeliverySchema, const H extends AnyCommand>(tag: Tag, options: SubscriptionOptions<D, H & Accepting<H, D["events"][number]["Type"]>> & {
+        readonly route: Route<D["events"][number]["Type"]>;
+    }): Subscription<Tag, D["events"], true, H>;
+    <const Tag extends string, const D extends DeliverySchema, const H extends AnyCommand>(tag: Tag, options: SubscriptionOptions<D, H & Accepting<H, D["events"][number]["Type"]>>): Subscription<Tag, D["events"], false, H>;
+}
+/**
+ * `SubscriptionMember.make` is `Actor.subscription`; see `SubscriptionFunction`
+ * for the routed and dynamic forms. Throws on an invalid tag, a delivery that
+ * is not an `Actor.Delivery`, a retired-and-delivered tag, a handler that is
+ * not a command, or a `route` that is neither a function nor `Actor.singleton`.
+ *
+ * @example
+ * const OnPosted = Actor.subscription("OnPosted", {
+ *   delivery: PostedDelivery,
+ *   handler: Record,
+ *   route: (event, source) => source.id,
+ * })
+ */
+export declare const SubscriptionMember: {
+    make: SubscriptionFunction;
+};
+/** Where a new dynamic subscription starts: after its registration, from the first retained event, or after a cursor. */
+export type SubscribeFrom = "now" | "start" | (string & {});
+/** The part of a command turn that subscribes to and unsubscribes from sources; see `X.Turn`. */
+export interface SubscribeContext<Subs extends AnySubscription> {
+    /**
+     * Starts following `id` through the dynamic subscription `subscription`
+     * when this turn commits; a declared failure or rollback discards it.
+     * `from` defaults to `"now"`: events committed after the registration
+     * reaches the source.
+     */
+    readonly subscribe: (subscription: Extract<Subs, {
+        readonly routed: false;
+    }>, id: string, options?: {
+        readonly from?: SubscribeFrom;
+    }) => Effect.Effect<void>;
+    /** Stops following `id` when this turn commits; no later delivery of it runs the handler. */
+    readonly unsubscribe: (subscription: Extract<Subs, {
+        readonly routed: false;
+    }>, id: string) => Effect.Effect<void>;
+}
+export {};

package/dist/members/subscription.js

@@ -0,0 +1,91 @@
+import { Predicate, Schema } from "effect";
+import { ActorRef } from "../identity/caller.js";
+const deliveryFields = { subscription: Schema.String, source: ActorRef };
+const deliverySchema = (events) => Schema.Union([
+    Schema.TaggedStruct("Event", {
+        ...deliveryFields,
+        cursor: Schema.String,
+        event: Schema.Union(events),
+        commandId: Schema.String,
+        timestamp: Schema.DateTimeUtc,
+    }),
+    Schema.TaggedStruct("RetentionGap", {
+        ...deliveryFields,
+        after: Schema.String,
+        resumeAfter: Schema.String,
+    }),
+    Schema.TaggedStruct("Rejected", {
+        ...deliveryFields,
+        reason: Schema.Literal("UnknownCursor"),
+        cursor: Schema.String,
+    }),
+]);
+/**
+ * `Actor.Delivery`: the payload schema of a subscription handler, one delivery
+ * of `events` from `source`. Throws when `events` is empty or names an event
+ * `source` does not declare, or one twice.
+ *
+ * @example
+ * const OrderDelivery = Actor.Delivery({ source: Orders, events: [Placed] })
+ * const Record = Actor.command("Record", { payload: OrderDelivery })
+ */
+export const Delivery = (options) => {
+    if (options.events.length === 0)
+        throw new Error(`A delivery of ${options.source.name} names no event`);
+    const tags = new Set();
+    for (const event of options.events) {
+        if (!options.source.events.includes(event))
+            throw new Error(`${options.source.name} does not declare event ${event.identifier}`);
+        if (tags.has(event.identifier))
+            throw new Error(`A delivery of ${options.source.name} lists ${event.identifier} twice`);
+        tags.add(event.identifier);
+    }
+    return Object.assign(deliverySchema(options.events), {
+        source: options.source,
+        events: options.events,
+    });
+};
+const SUBSCRIPTION_TAG = /^[A-Za-z][A-Za-z0-9]{0,79}$/;
+const subscription = ((tag, options) => {
+    if (!SUBSCRIPTION_TAG.test(tag))
+        throw new Error(`Subscription tag ${tag} must be 1-80 letters and digits, starting with a letter`);
+    const { delivery } = options;
+    if (!Predicate.hasProperty(delivery, "source") || !Predicate.hasProperty(delivery, "events"))
+        throw new Error(`Subscription ${tag}'s delivery must be an Actor.Delivery schema`);
+    const tags = new Set(delivery.events.map((event) => event.identifier));
+    const retired = options.retired ?? [];
+    for (const old of retired)
+        if (tags.has(old))
+            throw new Error(`Subscription ${tag} both delivers and retires ${old}`);
+    if (options.handler.kind !== "command")
+        throw new Error(`Subscription ${tag}'s handler must be a command`);
+    const route = options.route;
+    if (route !== undefined &&
+        !Predicate.isFunction(route) &&
+        !Predicate.isTagged(route, "Singleton"))
+        throw new Error(`Subscription ${tag}'s route is a function or Actor.singleton`);
+    return {
+        kind: "subscription",
+        tag,
+        source: delivery.source,
+        events: delivery.events,
+        retired,
+        handler: options.handler,
+        route,
+        routed: route !== undefined,
+    };
+});
+/**
+ * `SubscriptionMember.make` is `Actor.subscription`; see `SubscriptionFunction`
+ * for the routed and dynamic forms. Throws on an invalid tag, a delivery that
+ * is not an `Actor.Delivery`, a retired-and-delivered tag, a handler that is
+ * not a command, or a `route` that is neither a function nor `Actor.singleton`.
+ *
+ * @example
+ * const OnPosted = Actor.subscription("OnPosted", {
+ *   delivery: PostedDelivery,
+ *   handler: Record,
+ *   route: (event, source) => source.id,
+ * })
+ */
+export const SubscriptionMember = { make: subscription };

package/dist/members/workflow.d.ts

@@ -0,0 +1,99 @@
+import type { Duration, Effect, Option, Schema } from "effect";
+import type { StepIdentity } from "../contexts/workflow.ts";
+import type { DeclaredError, Member, ValueSchema } from "./command.ts";
+import type { EventClass } from "./event.ts";
+/** A version marker's supported range: new executions record `current`, and executions that recorded `min` or later still replay; `ctx.version(name)` reads the recorded value. */
+export interface VersionRange {
+    readonly current: number;
+    readonly min: number;
+}
+/** One constructor as the manifest records it. */
+export interface StepEntry {
+    readonly name: string;
+    readonly kind: StepIdentity["kind"];
+    /** An activity's payload schema; other kinds read none. */
+    readonly payload?: ValueSchema;
+    /** The schemas of the value the step records: an activity's or race's success and error, a wait's event. */
+    readonly result: ReadonlyArray<ValueSchema>;
+    /** The event tag a wait observes. */
+    readonly event?: string;
+}
+/** A workflow's module-level constructors, registered in declaration order. */
+export interface StepRegistry {
+    readonly steps: Map<string, StepEntry>;
+}
+/** A method signature, so a workflow with a specific payload is still an `AnyWorkflow`. */
+interface KeyFunction<Payload extends ValueSchema> {
+    key(payload: Payload["Type"]): string;
+}
+type KeyOf<Payload extends ValueSchema> = KeyFunction<Payload>["key"];
+/**
+ * A durable workflow member: a body the runtime replays from recorded steps.
+ * Its constructors (`step`, `sleep`, `wait`, `race`) are created at module
+ * level, and each records its result once per execution.
+ */
+export interface Workflow<Tag extends string, Payload extends ValueSchema, Success extends ValueSchema, Error extends DeclaredError> extends Member<"workflow", Tag, Payload, Success, Error> {
+    /** The execution key; the start's command id when omitted. */
+    readonly key: KeyOf<Payload> | undefined;
+    /** Version markers by name, for branching the body on how an old execution started. */
+    readonly versions: Readonly<Record<string, VersionRange>>;
+    /** The constructors created on this workflow, so the layer can check that a body uses only declared steps. */
+    readonly registry: StepRegistry;
+    /** An activity: `run(payload, execute)` records `execute`'s exit once per execution. */
+    readonly step: <const Name extends string, P extends ValueSchema = Schema.Void, S extends ValueSchema = Schema.Void, E extends DeclaredError = Schema.Never>(name: Name, options?: {
+        readonly payload?: P;
+        readonly success?: S;
+        readonly error?: E;
+    }) => Step<Name, P, S, E>;
+    /** A durable clock: calling it with a duration sleeps across restarts. */
+    readonly sleep: <const Name extends string>(name: Name) => Sleep<Name>;
+    /** An owner-event wait: the first matching event after the execution's cursor. */
+    readonly wait: <const Name extends string, Ev extends EventClass>(name: Name, event: Ev) => Wait<Name, Ev>;
+    /** The first of several effects to succeed, recorded so a replay returns the same winner. */
+    readonly race: <const Name extends string, S extends ValueSchema, E extends DeclaredError = Schema.Never>(name: Name, options: {
+        readonly success: S;
+        readonly error?: E;
+    }) => Race<Name, S, E>;
+}
+/** Any workflow, whatever its schemas. */
+export type AnyWorkflow = Workflow<string, ValueSchema, ValueSchema, DeclaredError>;
+/** An activity constructor: `run` executes once per execution and replays its recorded exit afterwards. */
+export interface Step<Name extends string, P extends ValueSchema, S extends ValueSchema, E extends DeclaredError> {
+    readonly name: Name;
+    readonly kind: "activity";
+    readonly run: <R>(payload: P["Type"], execute: (payload: P["Type"]) => Effect.Effect<S["Type"], E["Type"], R>) => Effect.Effect<S["Type"], E["Type"], R>;
+}
+/** A durable clock: calling it with a duration sleeps across restarts. */
+export interface Sleep<Name extends string> {
+    (duration: Duration.Input): Effect.Effect<void>;
+    readonly stepName: Name;
+    readonly kind: "clock";
+}
+/**
+ * An owner-event wait: resolves with the first matching event after the
+ * execution's cursor, or none on timeout. A matched event is recorded as the
+ * event class's current version encodes it.
+ */
+export interface Wait<Name extends string, Ev extends EventClass> {
+    (options?: {
+        readonly where?: (event: Ev["Type"]) => boolean;
+        readonly timeout?: Duration.Input;
+    }): Effect.Effect<Option.Option<Ev["Type"]>>;
+    readonly stepName: Name;
+    readonly kind: "wait";
+}
+/**
+ * A recorded race of effects: the first to succeed wins, and a replay returns
+ * the same winner. Only a winner or a declared failure is recorded; a
+ * suspension, defect, or interruption leaves the race to run again on replay.
+ */
+export interface Race<Name extends string, S extends ValueSchema, E extends DeclaredError> {
+    readonly name: Name;
+    readonly kind: "deferred";
+    readonly run: <R>(effects: ReadonlyArray<Effect.Effect<S["Type"], E["Type"], R>>) => Effect.Effect<S["Type"], E["Type"], R>;
+}
+/** Whether a member is a workflow. */
+export declare const isWorkflow: (member: {
+    readonly kind: string;
+}) => member is AnyWorkflow;
+export {};

package/dist/members/workflow.js

@@ -0,0 +1,2 @@
+/** Whether a member is a workflow. */
+export const isWorkflow = (member) => member.kind === "workflow";

package/dist/policies/access.d.ts

@@ -0,0 +1,35 @@
+import type { Effect } from "effect";
+import type { ActorRef, Caller } from "../identity/caller.ts";
+/** One question an access policy answers: may `caller` do `command` on the actor `ref`? */
+export interface AccessRequest {
+    readonly caller: Caller;
+    readonly ref: ActorRef;
+    readonly command: string;
+    /**
+     * What is being asked: `command` for commands and reducers, `query` for
+     * queries, `open` for a connection, `stream` for a stream, `feed` for an
+     * event feed (with `command` set to the event tag), `watch` for a query
+     * watch (with `command` set to the query tag), `reauthorize` for a live
+     * session's periodic check, and `content` for a content operation on the
+     * actor, with `command` set to `<blob>.grant` or `<blob>.get`, and `fleet`
+     * for a fleet view subscription, with `command` set to the view and `ref`
+     * naming the caller's tenant and the view's source actor type, with the view
+     * as its id, since a fleet read spans every actor of the type. A policy
+     * should deny kinds it does not know.
+     */
+    readonly kind: "command" | "query" | "open" | "stream" | "feed" | "watch" | "reauthorize" | "content" | "fleet";
+    /** On `reauthorize`, what the session is: an `open` connection, a `stream`, a `feed`, a `watch`, or a `fleet` subscription. */
+    readonly of?: "open" | "stream" | "feed" | "watch" | "fleet";
+}
+/**
+ * Decides whether a caller may do what a request names. The global
+ * `Actors.layer({ authorize })` hook and an actor's own `access` share this
+ * shape, and when both exist both must allow.
+ */
+export type Access = (request: AccessRequest) => boolean | Effect.Effect<boolean>;
+/**
+ * Allows every caller every kind of request, `Anonymous` visitors under
+ * `Actor.auth.none` included. It opens the actor to anyone who can reach the
+ * server, so use it only for demos and deliberately public actors.
+ */
+export declare const publicAccess: Access;

package/dist/policies/access.js

@@ -0,0 +1,6 @@
+/**
+ * Allows every caller every kind of request, `Anonymous` visitors under
+ * `Actor.auth.none` included. It opens the actor to anyone who can reach the
+ * server, so use it only for demos and deliberately public actors.
+ */
+export const publicAccess = () => true;

package/dist/policies/command.d.ts

@@ -0,0 +1,127 @@
+import { Duration } from "effect";
+import type { AnyCommand } from "../members/command.ts";
+/**
+ * Serializable actor limits, retention, and lifecycle settings; each key has
+ * exactly one meaning and one default. What the actor does (who creates it,
+ * its schedules, its jobs) is declared on the definition, not here.
+ */
+export interface Policy {
+    /** Idle time before the activation sleeps. Default 60 seconds. */
+    readonly hibernateAfter?: Duration.Input;
+    /**
+     * Deadline for one command turn's transaction and one query's execution.
+     * It does not bound a workflow or a live session. Default 30 seconds.
+     */
+    readonly executionTimeout?: Duration.Input;
+    /** Deadline for acquiring the generation lock. Default 2 seconds. */
+    readonly lockWait?: Duration.Input;
+    /** How long a caller waits for a reply; the turn itself is not cancelled. Default 30 seconds. */
+    readonly deliveryTimeout?: Duration.Input;
+    /** Maximum UTF-8 bytes of the encoded state object. Default 65,536. */
+    readonly maxStateBytes?: number;
+    /** Declared mailbox capacity; omitted, the runtime bounds active commands at 1,024 and refuses overload. */
+    readonly mailboxCapacity?: number;
+    /**
+     * How long a receipt is kept after its command id is issued; a timer's
+     * receipt counts from its due time. A receipt is never pruned before its id
+     * expires, nor while an intent or job with its id is still pending.
+     * Default 7 days.
+     */
+    readonly keepReceipts?: Duration.Input;
+    /**
+     * How long an event is kept after it is emitted. Pruning removes only an
+     * actor's oldest events, and replay after a pruned cursor fails
+     * `RetentionGap`. Default 30 days.
+     */
+    readonly keepEvents?: Duration.Input;
+    /**
+     * Maximum bytes across all of one actor's blob entries; a write past it is
+     * a defect of the turn. Default 67,108,864 (64 MiB).
+     */
+    readonly maxBlobBytes?: number;
+    /**
+     * Maximum entries across all of one actor's blobs; a write that would
+     * create an entry past it is a defect of the turn, while existing entries
+     * stay writable. Default 10,000.
+     */
+    readonly maxBlobEntries?: number;
+    /**
+     * How long a finished workflow execution keeps its result for `poll` after
+     * it finishes. Must be at least the deployment's retry window. Default 7 days.
+     */
+    readonly keepWorkflows?: Duration.Input;
+    /** A schedule tick later than this after its scheduled time is skipped. Default 1 day. */
+    readonly maxScheduleLag?: Duration.Input;
+    /**
+     * Whether open connections keep the activation awake. `"park"` (default)
+     * lets it hibernate with sockets open at their holders; `"keepAwake"`
+     * counts an open connection as activity.
+     */
+    readonly connections?: "park" | "keepAwake";
+    /** Longest time a connection runs on one authorization check, 1 second to 1 hour. Default 60 seconds. */
+    readonly reauthorizeEvery?: Duration.Input;
+    /** Limits on the watches of this actor's `watch: true` queries. */
+    readonly watch?: {
+        /** Watches open on one actor at once; the next fails `RunnerAtCapacity`. Default 1,000. */
+        readonly maxPerActor?: number;
+        /** The least time between two reruns of one watch. Default 100 milliseconds. */
+        readonly minInterval?: Duration.Input;
+        /**
+         * How often a watch reruns whether or not a commit signal arrived, so a
+         * signal lost to a broadcast gap or an owner's death, or a change no
+         * commit reports, is shown within this time. 5 seconds to 1 hour.
+         * Default 30 seconds.
+         */
+        readonly reconcileEvery?: Duration.Input;
+    };
+    /**
+     * The actor types that may subscribe to this actor's events, by name, so
+     * this definition never imports its subscribers. These are actor type
+     * names, not user principals. A subscription on any other type fails at
+     * `Actor.make`. Omitted, every type in the tenant may.
+     */
+    readonly allowedSubscriberTypes?: ReadonlyArray<string>;
+    /**
+     * How long past `keepEvents` subscriptions to this actor may hold its
+     * events back from pruning. An event older than both is pruned, and a
+     * subscriber behind it receives a `RetentionGap`. Default 7 days.
+     */
+    readonly holdEventsForSubscribers?: Duration.Input;
+}
+/** A `Policy` resolved for the runtime: every default applied and every duration in whole milliseconds. */
+export interface TurnPolicy {
+    readonly executionMs: number;
+    readonly lockWaitMs: number;
+    readonly deliveryMs: number;
+    readonly stateMaxBytes: number;
+    readonly idleMs: number;
+    readonly mailboxCapacity: number | "unbounded";
+    readonly createdBy: string | undefined;
+    readonly keepReceiptsMs: number;
+    readonly keepEventsMs: number;
+    readonly blobMaxBytes: number;
+    readonly blobMaxEntries: number;
+    readonly connections: "park" | "keepAwake";
+    readonly reauthorizeMs: number;
+    readonly watch: {
+        readonly maxPerActor: number;
+        readonly minIntervalMs: number;
+        readonly reconcileMs: number;
+    };
+    readonly keepWorkflowsMs: number;
+    readonly cronSkipMs: number;
+    readonly subscribers: ReadonlyArray<string> | undefined;
+    readonly holdEventsMs: number;
+}
+/**
+ * Applies the defaults of `declared` and validates each bound: durations run
+ * from 1 ms to 2^31 - 1 ms, retention horizons up to about ten years, and
+ * `reauthorizeEvery` from 1 second to 1 hour, and `watch.reconcileEvery` from
+ * 5 seconds to 1 hour. Throws when a value is out of range or `createdBy` is
+ * not one of `commands`.
+ */
+export declare const resolvePolicy: (policy: {
+    readonly declared: Policy | undefined;
+    readonly createdBy: AnyCommand | undefined;
+    readonly commands: ReadonlyArray<AnyCommand>;
+}) => TurnPolicy;

package/dist/policies/command.js

@@ -0,0 +1,45 @@
+import { Duration, Schema } from "effect";
+const Positive = Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 2_147_483_647 }));
+const milliseconds = (duration) => Positive.make(Duration.toMillis(duration));
+/** Retention horizons may exceed the 32-bit timeouts: up to about ten years. */
+const horizon = (duration) => Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 315_576_000_000 })).make(Duration.toMillis(duration));
+/**
+ * Applies the defaults of `declared` and validates each bound: durations run
+ * from 1 ms to 2^31 - 1 ms, retention horizons up to about ten years, and
+ * `reauthorizeEvery` from 1 second to 1 hour, and `watch.reconcileEvery` from
+ * 5 seconds to 1 hour. Throws when a value is out of range or `createdBy` is
+ * not one of `commands`.
+ */
+export const resolvePolicy = (policy) => {
+    const { declared, createdBy, commands } = policy;
+    if (createdBy !== undefined && !commands.includes(createdBy))
+        throw new Error("createdBy must be a command of this actor");
+    return Object.freeze({
+        executionMs: milliseconds(declared?.executionTimeout ?? "30 seconds"),
+        lockWaitMs: milliseconds(declared?.lockWait ?? "2 seconds"),
+        deliveryMs: milliseconds(declared?.deliveryTimeout ?? "30 seconds"),
+        stateMaxBytes: Positive.make(declared?.maxStateBytes ?? 65_536),
+        idleMs: milliseconds(declared?.hibernateAfter ?? "60 seconds"),
+        mailboxCapacity: declared?.mailboxCapacity === undefined
+            ? "unbounded"
+            : Positive.make(declared.mailboxCapacity),
+        createdBy: createdBy?.tag,
+        keepReceiptsMs: horizon(declared?.keepReceipts ?? "7 days"),
+        keepEventsMs: horizon(declared?.keepEvents ?? "30 days"),
+        blobMaxBytes: Positive.make(declared?.maxBlobBytes ?? 67_108_864),
+        blobMaxEntries: Positive.make(declared?.maxBlobEntries ?? 10_000),
+        connections: declared?.connections ?? "park",
+        reauthorizeMs: Schema.Int.check(Schema.isBetween({ minimum: 1_000, maximum: 3_600_000 })).make(Duration.toMillis(declared?.reauthorizeEvery ?? "60 seconds")),
+        watch: {
+            maxPerActor: Positive.make(declared?.watch?.maxPerActor ?? 1_000),
+            minIntervalMs: milliseconds(declared?.watch?.minInterval ?? "100 millis"),
+            reconcileMs: Schema.Int.check(Schema.isBetween({ minimum: 5_000, maximum: 3_600_000 })).make(Duration.toMillis(declared?.watch?.reconcileEvery ?? "30 seconds")),
+        },
+        keepWorkflowsMs: horizon(declared?.keepWorkflows ?? "7 days"),
+        cronSkipMs: horizon(declared?.maxScheduleLag ?? "1 day"),
+        subscribers: declared?.allowedSubscriberTypes === undefined
+            ? undefined
+            : [...declared.allowedSubscriberTypes],
+        holdEventsMs: horizon(declared?.holdEventsForSubscribers ?? "7 days"),
+    });
+};

package/dist/policies/job.d.ts

@@ -0,0 +1,28 @@
+import type { AnyCommand } from "../members/command.ts";
+import type { AnyJobBinding } from "../members/job.ts";
+/** A job binding with every default applied and every duration in whole milliseconds. */
+export interface JobPolicy {
+    /** The first attempt plus its retries. */
+    readonly attempts: number;
+    readonly timeoutMs: number;
+    readonly backoff: {
+        readonly baseMs: number;
+        readonly maxMs: number;
+    };
+    readonly progressEveryMs: number;
+    readonly perActor: number | undefined;
+    readonly onSuccess: AnyCommand | undefined;
+    readonly onDeadLetter: AnyCommand | undefined;
+    readonly onCancelled: AnyCommand | undefined;
+}
+/**
+ * Resolves one declared job's binding, throwing on a route that is not one of
+ * `commands`, a `concurrency.perActor` outside 1..64, `retry.times` outside
+ * 0..100, a duration outside its bounds, or a backoff whose max is below its
+ * base. `path` names the binding in those messages.
+ */
+export declare const resolveJobPolicy: ({ path, declared, commands, }: {
+    readonly path: string;
+    readonly declared: AnyJobBinding;
+    readonly commands: ReadonlyArray<AnyCommand>;
+}) => JobPolicy;