@rikalabs/akter 0.1.0-alpha.0

package/dist/client/sessions/watch.js

@@ -0,0 +1,40 @@
+import { Effect, Schema, Stream } from "effect";
+import { decodeFailure, undecodableFailure } from "../transport.js";
+import { IDLE_MS, readEvents, reconnecting, session } from "./sse.js";
+const VERSION = /^(0|[1-9]\d*)$/;
+const decodeJson = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Json));
+/** The greater of the version held and a result's `id`, when that is a version. */
+const later = (current, seen) => seen !== undefined &&
+    VERSION.test(seen) &&
+    (current === undefined || BigInt(seen) > BigInt(current))
+    ? seen
+    : current;
+/**
+ * One watch of served state, a query declared `watch: true` or a fleet view:
+ * its current result, then the newest result after each change. A watch is
+ * state, not history, so a dropped connection is reopened after a jittered,
+ * growing delay, or the server's `retryAfter`, with the greatest version any
+ * result carried as `durable-min-version`; its first result is the current
+ * state, never older than one already delivered. It fails with the query's
+ * declared error or the `ActorError` that ended it when a retry cannot help,
+ * and an expired credential is retried once.
+ */
+export const watchStream = ({ decode, open, declared, token, options, }) => session({
+    signal: options.signal,
+    run: (emit) => {
+        const failureOf = (text, status, headers = new Headers()) => decodeFailure(declared)({ status, headers, text, sentAt: 0 });
+        let last = token();
+        return reconnecting((delivered) => Effect.gen(function* () {
+            const response = yield* open(last, yield* Effect.abortSignal);
+            yield* readEvents({ response, refused: failureOf, idleMs: IDLE_MS }).pipe(Stream.runForEach((message) => Effect.gen(function* () {
+                if (message.event === "end")
+                    return yield* failureOf(message.data, 0);
+                const json = yield* decodeJson(message.data).pipe(Effect.mapError(undecodableFailure));
+                const value = yield* decode(json);
+                last = later(last, message.id);
+                yield* delivered;
+                yield* emit(value);
+            })));
+        }));
+    },
+});

package/dist/client/transport.d.ts

@@ -0,0 +1,37 @@
+import { Effect, Option, Schema } from "effect";
+import { ActorError } from "../errors/actor.ts";
+import type { DeclaredError } from "../members/command.ts";
+import type { OfflineStoreError } from "./offline/store.ts";
+/** A response as the client reads it: status, headers, and the raw body text. */
+export interface Reply {
+    readonly status: number;
+    readonly headers: Headers;
+    readonly text: string;
+    /** The local monotonic time its request was sent. */
+    readonly sentAt: number;
+}
+/**
+ * What a call rejects with: a declared application error, a typed framework
+ * failure, or, on a client with an offline store, the store's own failure.
+ */
+export type Failure = ActorError | OfflineStoreError | DeclaredError["Type"];
+/**
+ * An HTTP `retry-after` header as milliseconds: delay seconds, or a date
+ * measured from the response's `date` less the `elapsed` time since its
+ * request was sent, else from `now`.
+ */
+export declare const retryAfterHeader: ({ headers, now, elapsed, }: {
+    readonly headers: Headers;
+    readonly now?: number;
+    readonly elapsed?: number;
+}) => number | undefined;
+/** A request that got no response, or a body that stopped mid-read; retryable. */
+export declare const networkFailure: () => ActorError;
+/** A response or message the client could not decode; not retryable. */
+export declare const undecodableFailure: () => ActorError;
+/** Succeeds once `signal` aborts, at once when it already has; never without a signal. */
+export declare const aborted: (signal: AbortSignal | undefined) => Effect.Effect<void, never, never>;
+/** Decodes the served body of a failed call; `declared` decodes the member's declared errors. */
+export declare const decodeFailure: (declared: ((body: Schema.Json) => Option.Option<Failure>) | undefined) => (reply: Reply) => Failure;
+/** Decodes a 2xx body with `decode`, as undefined when the body is empty. */
+export declare const decodeSuccess: <A>(decode: (body: Schema.Json | undefined) => Effect.Effect<A, Schema.SchemaError>) => (reply: Reply) => Effect.Effect<A, ActorError>;

package/dist/client/transport.js

@@ -0,0 +1,66 @@
+import { Effect, Option, Schema } from "effect";
+import { ActorError, TransportError } from "../errors/actor.js";
+import { actorErrorOf, isDefectBody } from "../protocol/wire.js";
+const decodeJson = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Json));
+const isEnvelope = Schema.is(Schema.TaggedStruct("ActorError", {}));
+/**
+ * An HTTP `retry-after` header as milliseconds: delay seconds, or a date
+ * measured from the response's `date` less the `elapsed` time since its
+ * request was sent, else from `now`.
+ */
+export const retryAfterHeader = ({ headers, now, elapsed = 0, }) => {
+    const value = headers.get("retry-after")?.trim();
+    if (value === undefined)
+        return undefined;
+    if (/^\d+$/.test(value))
+        return Number(value) * 1_000;
+    const at = Date.parse(value);
+    const date = Date.parse(headers.get("date") ?? "");
+    const sent = Number.isNaN(date) ? now : date + Math.max(0, elapsed);
+    return Number.isNaN(at) || sent === undefined ? undefined : Math.max(0, at - sent);
+};
+const transportFailure = (reason) => ActorError.make({ reason });
+/** A request that got no response, or a body that stopped mid-read; retryable. */
+export const networkFailure = () => transportFailure(TransportError.make({ code: "network", retryable: true }));
+/** A response or message the client could not decode; not retryable. */
+export const undecodableFailure = () => transportFailure(TransportError.make({ code: "decode", retryable: false }));
+/** Succeeds once `signal` aborts, at once when it already has; never without a signal. */
+export const aborted = (signal) => Effect.callback((resume) => {
+    if (signal === undefined)
+        return;
+    if (signal.aborted)
+        return resume(Effect.void);
+    const onAbort = () => resume(Effect.void);
+    signal.addEventListener("abort", onAbort, { once: true });
+    return Effect.sync(() => signal.removeEventListener("abort", onAbort));
+});
+/** A status a proxy or gateway may answer before any runner saw the request. */
+const isRetryableStatus = (status) => status >= 500 || status === 429 || status === 408;
+const statusError = (reply) => transportFailure(TransportError.make({
+    code: "status",
+    status: reply.status,
+    retryable: isRetryableStatus(reply.status),
+}));
+/** Decodes the served body of a failed call; `declared` decodes the member's declared errors. */
+export const decodeFailure = (declared) => (reply) => {
+    const body = decodeJson(reply.text);
+    if (Option.isNone(body))
+        return statusError(reply);
+    if (isEnvelope(body.value))
+        return Option.getOrElse(actorErrorOf({
+            body: body.value,
+            headerRetryAfterMs: retryAfterHeader({ headers: reply.headers }),
+        }), () => statusError(reply));
+    if (isDefectBody(body.value))
+        return transportFailure(TransportError.make({ code: "defect", status: reply.status, retryable: false }));
+    const error = declared?.(body.value) ?? Option.none();
+    return Option.isSome(error) ? error.value : statusError(reply);
+};
+/** Decodes a 2xx body with `decode`, as undefined when the body is empty. */
+export const decodeSuccess = (decode) => (reply) => {
+    const undecodable = transportFailure(TransportError.make({ code: "decode", status: reply.status, retryable: false }));
+    const body = reply.text === "" ? Option.some(undefined) : decodeJson(reply.text);
+    if (Option.isNone(body))
+        return Effect.fail(undecodable);
+    return decode(body.value).pipe(Effect.mapError(() => undecodable));
+};

package/dist/contexts/command.d.ts

@@ -0,0 +1,132 @@
+import { Context, type DateTime, Effect, Option, type Stream } from "effect";
+import type { RetentionGap, UnknownCursor } from "../errors/events.ts";
+import type { ActorRef, Caller, Principal } from "../identity/caller.ts";
+import type { AnyBlob } from "../members/blob.ts";
+import type { AnyJob, ProgressJob, ProgressOf } from "../members/job.ts";
+import type { EventClass } from "../members/event.ts";
+import type { BlobReadOf, BlobWriteOf } from "../state/blob.ts";
+import type { Group, AnyOwnedTable, ScopedRead, TurnRows } from "../tables/owned.ts";
+/**
+ * The running turn's marker while a command turn executes. Request/reply
+ * calls such as a handle's commands and `Content.upload` refuse to run while
+ * it is set.
+ */
+export declare const InsideTurn: Context.Reference<symbol | undefined>;
+/** Dies with a defect when run inside a command turn, where request/reply would wait on a transaction it holds. */
+export declare const outsideTurn: Effect.Effect<undefined, never, never>;
+declare const TurnTypeId: unique symbol;
+/** Type-level identity of one actor's command-turn service, so `X.Turn` names only that actor's turn. */
+export interface Turn<Name extends string> {
+    readonly [TurnTypeId]: Name;
+}
+declare const MintableTypeId: unique symbol;
+/** Type-level mark of an unkeyed actor that declares `createdBy`, so turns can mint it. */
+export interface Mintable<Id extends string = string> {
+    readonly [MintableTypeId]: Id;
+}
+/** The writable context of one command turn, obtained with `yield* X.Turn`. */
+export interface CommandContext<State, Event extends EventClass = never, Tables extends AnyOwnedTable = AnyOwnedTable, Blobs extends AnyBlob = AnyBlob> {
+    readonly id: string;
+    readonly ref: ActorRef;
+    readonly caller: Caller;
+    readonly principal: Option.Option<Principal>;
+    readonly commandId: string;
+    readonly state: Readonly<State> & {
+        readonly set: (patch: Partial<State>) => Effect.Effect<void>;
+    };
+    /** Appends a declared event that is stored, and replayable, only if this turn commits. */
+    readonly emit: (event: Event["Type"]) => Effect.Effect<void>;
+    /** This actor's rows of a declared table, bound to the turn transaction. */
+    readonly rows: <T extends Tables>(table: T) => TurnRows<T>;
+    /** Read-only joins across the actor's placement group, inside the turn transaction. */
+    readonly group: Group;
+    /**
+     * This actor's entries of a declared blob, or its references to declared
+     * content, bound to the turn transaction. Content bytes are never readable in a turn.
+     */
+    readonly blob: <B extends Blobs>(blob: B) => BlobWriteOf<B>;
+    /**
+     * Derives the id of a new `child` from this command id and the number of
+     * earlier mints in the turn; retries of the command mint the same ids. The
+     * turn must stage an intent to the child's `createdBy` command, which alone
+     * can create it.
+     */
+    readonly mint: <Id extends string>(child: Mintable<Id>) => Effect.Effect<Id>;
+}
+/** One committed event and where it sits in its actor's stream. */
+export interface EventEntry<E> {
+    /** Exclusive resume point: pass it as `after` to read the events that follow. */
+    readonly cursor: string;
+    readonly event: E;
+    readonly commandId: string;
+    readonly timestamp: DateTime.Utc;
+}
+/** One executor progress frame of a job this actor enqueued. */
+export interface ProgressEntry<J extends ProgressJob> {
+    readonly jobId: string;
+    /** The job as enqueued. */
+    readonly job: J["Type"];
+    readonly attempt: number;
+    /** Per attempt, from 1; a gap means frames of the attempt were lost. */
+    readonly seq: number;
+    readonly frame: ProgressOf<J>;
+}
+/** The read-only context of one query, obtained with `yield* X.Read`. */
+export interface QueryContext<State, Event extends EventClass = never, Tables extends AnyOwnedTable = AnyOwnedTable, Blobs extends AnyBlob = AnyBlob, Jobs extends AnyJob = never> {
+    readonly id: string;
+    readonly ref: ActorRef;
+    readonly caller: Caller;
+    readonly principal: Option.Option<Principal>;
+    /** The last committed state; never uncommitted writes of a running turn. */
+    readonly state: Readonly<State>;
+    /**
+     * The last event committed when `state` was read: resume `events` after it
+     * to follow on from this state without missing or repeating an event.
+     */
+    readonly cursor: string;
+    /**
+     * Committed events of one declared class after the exclusive `after` cursor
+     * and up to `cursor`, in stream order; omitted, from the start. A cursor this
+     * actor never issued fails with `UnknownCursor`, and pruned history after it
+     * with `RetentionGap`. One call returns at most `limit` entries (default
+     * 1,000, at most 10,000); a full page continues after its last entry's cursor.
+     */
+    readonly events: <E extends Event>(event: E, options?: {
+        readonly after?: string | undefined;
+        readonly limit?: number | undefined;
+    }) => Effect.Effect<ReadonlyArray<EventEntry<E["Type"]>>, UnknownCursor | RetentionGap>;
+    /** This actor's committed rows of a declared table. */
+    readonly rows: <T extends Tables>(table: T) => ScopedRead<T>;
+    /** Read-only joins across the actor's placement group. */
+    readonly group: Group;
+    /** This actor's committed entries of a declared blob, or the content it references. */
+    readonly blob: <B extends Blobs>(blob: B) => BlobReadOf<B>;
+    /**
+     * Committed events of one declared class after the exclusive `after`
+     * cursor, then each one as its turn commits, with no gap or repeat between
+     * the two. Only stream handlers provide `InStream`, so a query that follows
+     * leaves an unsatisfiable requirement; the stream ends with its activation.
+     */
+    readonly follow: <E extends Event>(event: E, options?: {
+        readonly after?: string | undefined;
+    }) => Stream.Stream<EventEntry<E["Type"]>, UnknownCursor | RetentionGap, InStream>;
+    /**
+     * Live executor progress of this actor's jobs of class `job`, from the
+     * moment of the call; it has no history, may skip or coalesce frames, and
+     * ends with the stream. Only stream handlers whose member lists `job` in
+     * `progress.jobs` receive any.
+     */
+    readonly progress: <J extends Extract<Jobs, ProgressJob>>(job: J, options?: {
+        readonly jobId?: string | undefined;
+    }) => Stream.Stream<ProgressEntry<J>, never, InStream>;
+}
+declare const InStream_base: Context.ServiceClass<InStream, "@rikalabs/akter/contexts/command/InStream", {
+    readonly stream: symbol;
+}>;
+/**
+ * Provided only while a stream handler runs. `read.follow` requires it and
+ * `X.toLayer` removes it from stream handler requirements.
+ */
+export declare class InStream extends InStream_base {
+}
+export {};

package/dist/contexts/command.js

@@ -0,0 +1,20 @@
+import { Context, Effect, Option } from "effect";
+/**
+ * The running turn's marker while a command turn executes. Request/reply
+ * calls such as a handle's commands and `Content.upload` refuse to run while
+ * it is set.
+ */
+export const InsideTurn = Context.Reference("akter/InsideTurn", {
+    defaultValue: () => undefined,
+});
+/** Dies with a defect when run inside a command turn, where request/reply would wait on a transaction it holds. */
+export const outsideTurn = Effect.gen(function* () {
+    if ((yield* InsideTurn) !== undefined)
+        return yield* Effect.die(new Error("Request/reply inside a turn"));
+});
+/**
+ * Provided only while a stream handler runs. `read.follow` requires it and
+ * `X.toLayer` removes it from stream handler requirements.
+ */
+export class InStream extends Context.Service()("@rikalabs/akter/contexts/command/InStream") {
+}

package/dist/contexts/connection.d.ts

@@ -0,0 +1,68 @@
+import type { Effect, Option } from "effect";
+import type { RetentionGap, UnknownCursor } from "../errors/events.ts";
+import type { ActorRef, Caller, Principal } from "../identity/caller.ts";
+import type { AnyConnection } from "../members/connection.ts";
+import type { EventClass } from "../members/event.ts";
+import type { EventEntry } from "./command.ts";
+/** Narrows a broadcast: `to` keeps only these connections, `except` removes these. */
+export interface BroadcastOptions {
+    readonly to?: ReadonlyArray<string>;
+    readonly except?: ReadonlyArray<string>;
+}
+/** One open connection of a member. `session` is present only when asked for. */
+export interface ConnectionInfo<Session = unknown> {
+    readonly connectionId: string;
+    readonly caller: Caller;
+    readonly session?: Session;
+}
+/** The per-connection state a member declares with `session`, at most 16 KiB encoded. */
+export interface SessionAccess<Session> {
+    /** The session as last written, or none before the first `set`. */
+    readonly get: Effect.Effect<Option.Option<Session>>;
+    /** Merges `patch` into the session; written once, fenced, after the handler returns. */
+    readonly set: (patch: Partial<Session>) => Effect.Effect<void>;
+}
+/** A frame, or an event entry whose cursor the client deduplicates on. */
+export type FrameOf<Server> = Server | EventEntry<Server>;
+/**
+ * The context of one connection handler, obtained with `yield* X.Connection`.
+ * It reads committed state and sends frames; durable actor changes go through
+ * commands.
+ */
+export interface ConnectionContext<State, Event extends EventClass, Server, Session> {
+    readonly id: string;
+    readonly ref: ActorRef;
+    readonly connectionId: string;
+    readonly member: string;
+    /** The caller authorized when the connection opened, never frame content. */
+    readonly caller: Caller;
+    readonly principal: Option.Option<Principal>;
+    /** The state the activation last committed. */
+    readonly state: Readonly<State>;
+    /** The activation's flushed-through event cursor when the handler started. */
+    readonly cursor: string;
+    /** True when this activation did not run the connection's `open`. */
+    readonly resumed: boolean;
+    readonly session: SessionAccess<Session>;
+    /** Sends a frame to this connection once the handler returns. */
+    readonly send: (frame: FrameOf<Server>) => Effect.Effect<void>;
+    /** Sends a frame to this member's open connections, parked or not, wherever they are held. */
+    readonly broadcast: (frame: FrameOf<Server>, options?: BroadcastOptions) => Effect.Effect<void>;
+    /** At most 1,000 of this member's open connections; `session` only when asked for. */
+    readonly connections: (options?: {
+        readonly session?: boolean;
+    }) => Effect.Effect<ReadonlyArray<ConnectionInfo<Session>>>;
+    /** Closes this connection with `SessionEnded` cause `ServerClosed` once the handler returns. */
+    readonly close: Effect.Effect<void>;
+    /** Committed events of one declared class after the exclusive `after` cursor, in stream order, as `read.events` returns them. */
+    readonly events: <E extends Event>(event: E, options?: {
+        readonly after?: string | undefined;
+        readonly limit?: number;
+    }) => Effect.Effect<ReadonlyArray<EventEntry<E["Type"]>>, UnknownCursor | RetentionGap>;
+}
+/** How a command turn reaches connections; frames go out only after the turn commits. */
+export interface BroadcastContext<Connections extends AnyConnection = AnyConnection> {
+    readonly broadcast: <C extends Connections>(member: C, frame: FrameOf<C["server"]["Type"]>, options?: BroadcastOptions) => Effect.Effect<void>;
+    /** At most 1,000 of the member's open connections, to filter into `to`. */
+    readonly connections: <C extends Connections>(member: C) => Effect.Effect<ReadonlyArray<ConnectionInfo>>;
+}

package/dist/contexts/job.d.ts

@@ -0,0 +1,49 @@
+import type { DateTime, Duration, Effect, Option } from "effect";
+import type { ActorRef, Principal } from "../identity/caller.ts";
+import type { AnyJob, ProgressJob, ProgressOf } from "../members/job.ts";
+/** How `turn.enqueue` names and schedules a job. */
+export interface EnqueueOptions {
+    /**
+     * Names the job within its actor, 1-200 characters. Enqueueing another job
+     * with the same key replaces this one when the turn commits, as
+     * `turn.cancelJob(key)` would.
+     */
+    readonly key?: string;
+    /** Runs no earlier than `after` past the turn's commit. */
+    readonly after?: Duration.Input;
+    /** Runs no earlier than `at`, measured on the database clock. */
+    readonly at?: DateTime.DateTime;
+}
+/** The part of a command turn that stages jobs; see `X.Turn`. */
+export interface EnqueueContext<J extends AnyJob> {
+    /**
+     * Stages `job` in this turn. It is executed only after the turn commits,
+     * and a declared failure or rollback discards it.
+     */
+    readonly enqueue: (job: J["Type"], options?: EnqueueOptions) => Effect.Effect<void>;
+    /**
+     * Cancels this actor's job with `key` when the turn commits. One that never
+     * started is removed; one that started is never attempted again and reports
+     * what is known of it to `onCancelled`.
+     */
+    readonly cancelJob: (key: string) => Effect.Effect<void>;
+}
+/** The context of one executor attempt, obtained with `yield* X.Executor`. */
+export interface ExecutorContext<J extends AnyJob = AnyJob> {
+    /** Stable across every attempt; use it as the provider's idempotency key. */
+    readonly jobId: string;
+    /** 1 on the first attempt; a later attempt may follow one whose outcome is unknown. */
+    readonly attempt: number;
+    /** The principal of the turn that enqueued the job. */
+    readonly principal: Option.Option<Principal>;
+    /** The actor that enqueued the job. */
+    readonly ref: ActorRef;
+    /**
+     * Reports a transient progress frame of the running job `job`. It never
+     * fails or waits and never changes the outcome: a frame that does not
+     * encode, exceeds 4 KiB, names another job, or runs after the attempt ended
+     * is dropped. Frames are coalesced and may be lost; they are never state,
+     * events, or receipts.
+     */
+    progress<P extends Extract<J, ProgressJob>>(job: P, frame: ProgressOf<P>): Effect.Effect<void>;
+}

package/dist/contexts/workflow.d.ts

@@ -0,0 +1,147 @@
+import { Context, Data, type Effect, type Option, Schema } from "effect";
+import type { ActorRef, Principal } from "../identity/caller.ts";
+/** The context of one workflow run, obtained with `yield* X.Workflow`. */
+export interface WorkflowContext {
+    /** The owner actor's id. */
+    readonly id: string;
+    readonly ref: ActorRef;
+    /** The principal recorded when the execution started. */
+    readonly principal: Option.Option<Principal>;
+    readonly executionId: string;
+    readonly key: string;
+    /** The marker value recorded at start; 0 for an execution older than the marker. */
+    readonly version: (name: string) => Effect.Effect<number>;
+}
+/** A step exit as the engine records it: the step's own codecs encode the value. */
+export declare const RecordedExit: Schema.TaggedUnion<{
+    readonly Die: Schema.TaggedStruct<"Die", {
+        readonly message: Schema.String;
+    }>;
+    readonly Failure: Schema.TaggedStruct<"Failure", {
+        readonly error: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>;
+    readonly Success: Schema.TaggedStruct<"Success", {
+        readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>;
+}>;
+/** A step exit as recorded: its encoded value, encoded declared failure, or defect message. */
+export type RecordedExit = typeof RecordedExit.Type;
+/** A finished execution's result: its body's exit, or an interrupt. */
+export declare const StoredResult: Schema.TaggedUnion<{
+    readonly Die: Schema.TaggedStruct<"Die", {
+        readonly message: Schema.String;
+    }>;
+    readonly Failure: Schema.TaggedStruct<"Failure", {
+        readonly error: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>;
+    readonly Interrupt: Schema.TaggedStruct<"Interrupt", {}>;
+    readonly Success: Schema.TaggedStruct<"Success", {
+        readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>;
+}>;
+/** A finished execution's result as stored. */
+export type StoredResult = typeof StoredResult.Type;
+/** What a typed constructor names when it asks the engine to run or replay it. */
+export interface StepIdentity {
+    readonly workflow: string;
+    readonly name: string;
+    readonly kind: "activity" | "clock" | "wait" | "deferred";
+}
+/**
+ * The engine of the run the calling fiber belongs to. Only the runtime
+ * provides it, to a workflow body's fiber; constructors outside a body die.
+ */
+export interface WorkflowSteps {
+    readonly activity: <R>(step: StepIdentity, run: Effect.Effect<RecordedExit, never, R>) => Effect.Effect<RecordedExit, never, R>;
+    readonly sleep: (step: StepIdentity, millis: number) => Effect.Effect<void>;
+    readonly wait: (step: StepIdentity, event: string, 
+    /** The stored value upcast to the event's current version when it matches; none otherwise. */
+    matches: (value: string, version: number) => Effect.Effect<Option.Option<string>>, timeoutMs: number | undefined) => Effect.Effect<Option.Option<string>>;
+    readonly race: <R>(step: StepIdentity, run: Effect.Effect<RecordedExit, never, R>) => Effect.Effect<RecordedExit, never, R>;
+}
+/** The engine of the workflow run the calling fiber belongs to; undefined outside a workflow body. */
+export declare const CurrentWorkflow: Context.Reference<WorkflowSteps | undefined>;
+/**
+ * Where the calling fiber stands for actor calls: outside any workflow, in a
+ * workflow body (where calls die), or inside an activity, which derives each
+ * call's command id.
+ */
+export type CallPhase = Data.TaggedEnum<{
+    None: {};
+    Body: {};
+    Activity: {
+        readonly nextCommandId: Effect.Effect<string>;
+    };
+}>;
+/** Constructors and matchers for `CallPhase`. */
+export declare const CallPhase: {
+    readonly $is: <Tag extends "Activity" | "Body" | "None">(tag: Tag) => (u: unknown) => u is Extract<{
+        readonly _tag: "Activity";
+        readonly nextCommandId: Effect.Effect<string>;
+    }, {
+        readonly _tag: Tag;
+    }> | Extract<{
+        readonly _tag: "Body";
+    }, {
+        readonly _tag: Tag;
+    }> | Extract<{
+        readonly _tag: "None";
+    }, {
+        readonly _tag: Tag;
+    }>;
+    readonly $match: {
+        <Cases extends { readonly [Tag in "Activity" | "Body" | "None"]: (args: Extract<{
+            readonly _tag: "Activity";
+            readonly nextCommandId: Effect.Effect<string>;
+        } | {
+            readonly _tag: "Body";
+        } | {
+            readonly _tag: "None";
+        }, {
+            readonly _tag: Tag;
+        }>) => any; }>(cases: Cases): (value: {
+            readonly _tag: "Activity";
+            readonly nextCommandId: Effect.Effect<string>;
+        } | {
+            readonly _tag: "Body";
+        } | {
+            readonly _tag: "None";
+        }) => import("effect/Unify").Unify<ReturnType<Cases["Activity" | "Body" | "None"]>>;
+        <Cases extends { readonly [Tag in "Activity" | "Body" | "None"]: (args: Extract<{
+            readonly _tag: "Activity";
+            readonly nextCommandId: Effect.Effect<string>;
+        } | {
+            readonly _tag: "Body";
+        } | {
+            readonly _tag: "None";
+        }, {
+            readonly _tag: Tag;
+        }>) => any; }>(value: {
+            readonly _tag: "Activity";
+            readonly nextCommandId: Effect.Effect<string>;
+        } | {
+            readonly _tag: "Body";
+        } | {
+            readonly _tag: "None";
+        }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Activity" | "Body" | "None"]>>;
+    };
+    readonly Activity: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "Activity";
+        readonly nextCommandId: Effect.Effect<string>;
+    }, "_tag">;
+    readonly Body: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "Body";
+    }, "_tag">;
+    readonly None: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "None";
+    }, "_tag">;
+};
+/** The calling fiber's `CallPhase`; `None` by default. */
+export declare const CurrentCallPhase: Context.Reference<{
+    readonly _tag: "Activity";
+    readonly nextCommandId: Effect.Effect<string>;
+} | {
+    readonly _tag: "Body";
+} | {
+    readonly _tag: "None";
+}>;

package/dist/contexts/workflow.js

@@ -0,0 +1,22 @@
+import { Context, Data, Schema } from "effect";
+/** A step exit as the engine records it: the step's own codecs encode the value. */
+export const RecordedExit = Schema.TaggedUnion({
+    Success: { value: Schema.Json },
+    Failure: { error: Schema.Json },
+    Die: { message: Schema.String },
+});
+/** A finished execution's result: its body's exit, or an interrupt. */
+export const StoredResult = Schema.TaggedUnion({
+    Success: { value: Schema.Json },
+    Failure: { error: Schema.Json },
+    Die: { message: Schema.String },
+    Interrupt: {},
+});
+/** The engine of the workflow run the calling fiber belongs to; undefined outside a workflow body. */
+export const CurrentWorkflow = Context.Reference("akter/CurrentWorkflow", { defaultValue: () => undefined });
+/** Constructors and matchers for `CallPhase`. */
+export const CallPhase = Data.taggedEnum();
+/** The calling fiber's `CallPhase`; `None` by default. */
+export const CurrentCallPhase = Context.Reference("akter/CurrentCallPhase", {
+    defaultValue: () => CallPhase.None(),
+});