@rikalabs/akter 0.1.0-alpha.0

package/dist/actor/handles.js

@@ -0,0 +1,265 @@
+import { Effect, Result, Schema, Semaphore, Stream } from "effect";
+import { outsideTurn } from "../contexts/command.js";
+import { CallPhase, CurrentCallPhase } from "../contexts/workflow.js";
+import { ActorError, InvalidInput } from "../errors/actor.js";
+import { InvalidExecutionId } from "../errors/workflow.js";
+import { Actors } from "../handles/actors.js";
+import { currentStaging, stageIntent } from "../handles/intents.js";
+import { workflowRun } from "../handles/run.js";
+import { ExecutionIdOutput, ExecutionTarget, INTERRUPT, START, StartPayload, } from "../handles/workflow.js";
+import { ActorRef, Caller, CurrentCaller, Tenant } from "../identity/caller.js";
+import { CurrentCommandId } from "../identity/command.js";
+import { CurrentConnectionCommands } from "../identity/connection.js";
+import { checkExecutionKey, decodeExecutionId, encodeExecutionId } from "../identity/execution.js";
+import { isWorkflow } from "../members/workflow.js";
+import { InternalActors } from "../runtime/actors.js";
+import { Outcome, Request } from "../runtime/request.js";
+const decodeCaller = Schema.decodeEffect(Caller);
+const encodeTarget = Schema.encodeEffect(ExecutionTarget);
+const encodeStartPayload = Schema.encodeEffect(StartPayload);
+const decodeExecutionIdOutput = Schema.decodeEffect(ExecutionIdOutput);
+/** Workflow starts staged so far in each turn's staging, numbering keyless starts. */
+const startCounts = new WeakMap();
+const isWatchable = (member) => "watch" in member && member.watch === true;
+const runOf = (descriptor, member, ref, caller, executionId, execute, poll, mint) => workflowRun({
+    executionId,
+    poll: poll(Request.make({ ref, caller, command: member.tag, commandId: "", payload: executionId })),
+    interrupt: Effect.gen(function* () {
+        const commandId = (yield* CurrentCommandId) ?? (yield* mint);
+        const outcome = yield* execute(Request.make({
+            ref,
+            caller,
+            command: INTERRUPT,
+            commandId,
+            payload: yield* encodeTarget({ executionId }).pipe(Effect.orDie),
+        }));
+        if (Outcome.guards.Defect(outcome))
+            return yield* Effect.die(outcome.cause);
+    }),
+    decode: descriptor.workflowExits.get(member.tag).decode,
+});
+/**
+ * The methods of a request/reply handle to `id`, which reach `internal`
+ * commands when `includeInternal` is set. Running a command method's Effect
+ * mints its command id once and reuses it on every rerun, so a retry is
+ * deduplicated by the receipt; a workflow step's call takes the step's id.
+ * Handles never deliver subscriptions, so an acknowledged outcome is a defect.
+ */
+export const handleOf = Effect.fnUntraced(function* (descriptor, id, includeInternal, as, tenant) {
+    yield* outsideTurn;
+    const actors = yield* Actors;
+    const internalActors = yield* InternalActors;
+    const caller = yield* decodeCaller(as ?? (yield* CurrentCaller)).pipe(Effect.orDie);
+    const ref = ActorRef.make({
+        actor: descriptor.name,
+        tenant: tenant ?? (yield* Tenant),
+        id: descriptor.singleton ? "singleton" : yield* descriptor.decodeId(id).pipe(Effect.orDie),
+    });
+    const callable = Effect.gen(function* () {
+        if (CallPhase.$is("Body")(yield* CurrentCallPhase))
+            return yield* Effect.die(new Error("Actor call in a workflow body outside a step"));
+    });
+    const send = (request) => Effect.gen(function* () {
+        if (CallPhase.$is("Activity")(yield* CurrentCallPhase))
+            return yield* internalActors.deliver(request);
+        return (yield* internalActors.execute(request)).outcome;
+    });
+    const callId = (command) => Effect.gen(function* () {
+        const phase = yield* CurrentCallPhase;
+        if (CallPhase.$is("Activity")(phase))
+            return yield* phase.nextCommandId;
+        const explicit = yield* CurrentCommandId;
+        if (explicit !== undefined)
+            return explicit;
+        const connectionCommands = yield* CurrentConnectionCommands;
+        return connectionCommands === undefined
+            ? yield* actors.mintCommandId
+            : yield* connectionCommands(`${ref.tenant}\u0000${ref.actor}\u0000${ref.id}`, command);
+    });
+    const callIdOnce = (command) => {
+        const lock = Semaphore.makeUnsafe(1);
+        let identity;
+        return lock.withPermit(Effect.gen(function* () {
+            if (identity === undefined)
+                identity = yield* callId(command);
+            return identity;
+        }));
+    };
+    const execute = (request) => Effect.map(internalActors.execute(request), (executed) => executed.outcome);
+    const methods = Object.fromEntries((includeInternal ? descriptor.members : Object.values(descriptor.api))
+        .filter((member) => member.kind !== "connection")
+        .map((member) => {
+        const { encodePayload, decodeSuccess, decodeError } = descriptor.codecs.get(member.tag);
+        const decoded = (elements, encoded) => elements.pipe(Stream.mapEffect((element) => Effect.map(decodeSuccess(encoded(element)).pipe(Effect.orDie), (out) => out.value)), Stream.catch((error) => Schema.is(ActorError)(error)
+            ? Stream.fail(error)
+            : Stream.fromEffect(Effect.flatMap(decodeError(error.failure).pipe(Effect.orDie), Effect.fail))));
+        if (member.kind === "stream")
+            return [
+                member.tag,
+                (input) => Stream.unwrap(Effect.gen(function* () {
+                    yield* outsideTurn;
+                    const payload = yield* encodePayload({ value: input }).pipe(Effect.orDie);
+                    return decoded(internalActors.subscribe(Request.make({ ref, caller, command: member.tag, commandId: "", payload })), (value) => value);
+                })),
+            ];
+        if (isWorkflow(member))
+            return [
+                member.tag,
+                (input) => {
+                    const identify = callIdOnce(member.tag);
+                    return Effect.gen(function* () {
+                        yield* outsideTurn;
+                        yield* callable;
+                        if (member.key !== undefined)
+                            yield* checkExecutionKey(member.key(input));
+                        const payload = yield* encodePayload({ value: input }).pipe(Effect.orDie);
+                        const outcome = yield* send(Request.make({
+                            ref,
+                            caller,
+                            command: member.tag,
+                            commandId: yield* identify,
+                            payload,
+                        }));
+                        if (!Outcome.guards.Success(outcome))
+                            return yield* Effect.die(Outcome.guards.Defect(outcome)
+                                ? outcome.cause
+                                : new Error("Workflow start failed"));
+                        const { value: executionId } = yield* decodeExecutionIdOutput(outcome.value).pipe(Effect.orDie);
+                        return runOf(descriptor, member, ref, caller, executionId, execute, internalActors.pollWorkflow, actors.mintCommandId);
+                    });
+                },
+            ];
+        const call = (input) => {
+            const identify = callIdOnce(member.tag);
+            return Effect.gen(function* () {
+                yield* outsideTurn;
+                if (member.kind !== "query")
+                    yield* callable;
+                const payload = yield* encodePayload({ value: input }).pipe(Effect.orDie);
+                const outcome = member.kind === "query"
+                    ? yield* internalActors.query(Request.make({ ref, caller, command: member.tag, commandId: "", payload }), internalActors.observedVersion())
+                    : yield* send(Request.make({
+                        ref,
+                        caller,
+                        command: member.tag,
+                        commandId: yield* identify,
+                        payload,
+                    }));
+                if (Outcome.guards.Defect(outcome))
+                    return yield* Effect.die(outcome.cause);
+                if (Outcome.guards.Failure(outcome))
+                    return yield* yield* decodeError(outcome.value).pipe(Effect.orDie);
+                if (Outcome.guards.Acknowledged(outcome))
+                    return yield* Effect.die(new Error(`Unexpected ${outcome.reason} acknowledgement`));
+                return (yield* decodeSuccess(outcome.value).pipe(Effect.orDie)).value;
+            });
+        };
+        if (!isWatchable(member))
+            return [member.tag, call];
+        const watch = (input) => Stream.unwrap(Effect.gen(function* () {
+            yield* outsideTurn;
+            const payload = yield* encodePayload({ value: input }).pipe(Effect.orDie);
+            const results = yield* internalActors.watch(Request.make({ ref, caller, command: member.tag, commandId: "", payload }), { minVersion: internalActors.observedVersion(), expiresAt: undefined });
+            return decoded(results, ({ value }) => value).pipe(Stream.catchIf((error) => Schema.is(ActorError)(error) && Schema.is(InvalidInput)(error.reason), Stream.die));
+        }));
+        return [member.tag, Object.assign(call, { watch })];
+    }));
+    return { ...methods, ref };
+});
+/**
+ * Mints a new UUIDv7 id and returns its handle. Only an unkeyed actor that is
+ * not parent-placed may be created by a caller; inside a turn it is a defect.
+ */
+export const createOf = (descriptor) => Effect.gen(function* () {
+    yield* outsideTurn;
+    if (!descriptor.minted)
+        return yield* Effect.die(descriptor.parent === undefined
+            ? new Error("Only minted actors use create()")
+            : new Error(`${descriptor.name} is minted only by its parent ${descriptor.parent.name}`));
+    const internalActors = yield* InternalActors;
+    return yield* handleOf(descriptor, yield* internalActors.mintActorId, false);
+});
+/**
+ * Durable intents to actor `id`, staged in the current command turn. The
+ * target shares the sending turn's tenant. A keyless workflow start is keyed
+ * by the turn's command id and its order among the turn's starts, so a
+ * retried turn restages the same executions. Commands that subscriptions
+ * deliver to are left out.
+ */
+export const intentsOf = Effect.fnUntraced(function* (descriptor, id) {
+    const { marker, staging } = yield* currentStaging();
+    const target = ActorRef.make({
+        actor: descriptor.name,
+        tenant: staging.sender.tenant,
+        id: descriptor.singleton ? "singleton" : yield* descriptor.decodeId(id).pipe(Effect.orDie),
+    });
+    const methods = Object.fromEntries(descriptor.commands.flatMap((member) => {
+        if (descriptor.handlerTags.has(member.tag))
+            return [];
+        const { encodePayload } = descriptor.codecs.get(member.tag);
+        return [
+            [
+                member.tag,
+                (input) => Effect.gen(function* () {
+                    const payload = yield* encodePayload({ value: input }).pipe(Effect.orDie);
+                    yield* stageIntent(marker, { target, command: member.tag, payload });
+                }),
+            ],
+        ];
+    }));
+    const starts = Object.fromEntries(descriptor.workflows.map((member) => {
+        const { encodePayload } = descriptor.codecs.get(member.tag);
+        return [
+            member.tag,
+            (input) => Effect.gen(function* () {
+                const { staging: current } = yield* currentStaging(marker);
+                const payload = yield* encodePayload({ value: input }).pipe(Effect.orDie);
+                const ordinal = (startCounts.get(current) ?? 0) + 1;
+                startCounts.set(current, ordinal);
+                const key = member.key === undefined ? `${current.commandId}:${ordinal}` : member.key(input);
+                const executionId = yield* encodeExecutionId({
+                    tenant: target.tenant,
+                    actor: target.actor,
+                    id: target.id,
+                    workflow: member.tag,
+                    key,
+                }).pipe(Effect.orDie);
+                const own = current.sender.actor === target.actor && current.sender.id === target.id;
+                yield* stageIntent(marker, {
+                    target,
+                    command: START,
+                    payload: yield* encodeStartPayload({
+                        workflow: member.tag,
+                        input: payload,
+                        key,
+                        after: own ? current.head : null,
+                    }).pipe(Effect.orDie),
+                });
+                return executionId;
+            }),
+        ];
+    }));
+    return { ...methods, ...starts, ref: target };
+});
+/**
+ * Reattaches to a workflow execution by id without contacting its owner. An
+ * id of another tenant, actor type, or workflow fails `InvalidExecutionId`.
+ */
+export const runOfId = Effect.fnUntraced(function* (descriptor, member, executionId) {
+    yield* outsideTurn;
+    const actors = yield* Actors;
+    const internalActors = yield* InternalActors;
+    const caller = yield* decodeCaller(yield* CurrentCaller).pipe(Effect.orDie);
+    const tenant = yield* Tenant;
+    const invalid = InvalidExecutionId.make({ executionId });
+    const execution = yield* decodeExecutionId(executionId);
+    if (execution.tenant !== tenant ||
+        execution.actor !== descriptor.name ||
+        execution.workflow !== member.tag ||
+        !descriptor.workflows.includes(member))
+        return yield* invalid;
+    const id = descriptor.singleton ? "singleton" : execution.id;
+    if (!descriptor.singleton && Result.isFailure(Schema.decodeResult(descriptor.idSchema)(id)))
+        return yield* invalid;
+    return runOf(descriptor, member, ActorRef.make({ actor: descriptor.name, tenant, id }), caller, executionId, (request) => Effect.map(internalActors.execute(request), (executed) => executed.outcome), internalActors.pollWorkflow, actors.mintCommandId);
+});

package/dist/actor/jobs.d.ts

@@ -0,0 +1,10 @@
+import { type Context, Effect } from "effect";
+import type { RegisteredJob } from "../runtime/members.ts";
+import type { Handler } from "./codecs.ts";
+import type { Descriptor } from "./descriptor.ts";
+/** Every declared job's registration; a job without an executor is a defect of the layer. */
+export declare const jobsOf: ({ descriptor, Executor, executors, }: {
+    readonly descriptor: Descriptor;
+    readonly Executor: Context.Key<object, object>;
+    readonly executors: Readonly<Record<string, Handler>>;
+}) => Effect.Effect<ReadonlyMap<string, RegisteredJob>, never, never>;

package/dist/actor/jobs.js

@@ -0,0 +1,137 @@
+import { Cause, Effect, Exit, Option, Result, Schema } from "effect";
+import { Tenant } from "../identity/caller.js";
+import { CancelledOutcome } from "../members/job.js";
+import { MAX_PROGRESS_BYTES } from "../runtime/jobs/progress.js";
+const utf8 = new TextEncoder();
+/** Encodes a value as a route command's payload. */
+const routeCodec = (command) => {
+    const encode = Schema.encodeEffect(Schema.fromJsonString(Schema.toCodecJson(Schema.Struct({ value: command.payload }))));
+    return (value) => encode({ value }).pipe(Effect.map((payload) => ({ command: command.tag, payload })));
+};
+/**
+ * One job's registration. Only a typed failure proves the provider did not
+ * apply the call; a defect, timeout, or interruption leaves the attempt's
+ * outcome unknown. A result `onSuccess` cannot accept is dead-lettered rather
+ * than executed again, since the provider already applied it, and a
+ * cancelled job's result goes to `onCancelled`, as an unknown outcome when
+ * that route cannot accept it. A stored payload that no longer decodes never
+ * reaches the executor.
+ */
+const jobOf = (Executor, { job, codec, policy }, execute) => {
+    const onSuccess = policy.onSuccess === undefined ? undefined : routeCodec(policy.onSuccess);
+    const onDeadLetter = policy.onDeadLetter === undefined ? undefined : routeCodec(policy.onDeadLetter);
+    const onCancelled = policy.onCancelled === undefined ? undefined : routeCodec(policy.onCancelled);
+    const cancelledRoute = (decoded, letter) => onCancelled === undefined
+        ? Effect.undefined
+        : onCancelled({
+            jobId: letter.jobId,
+            job: decoded,
+            attempts: letter.attempts,
+            outcome: letter.outcome,
+            ambiguous: letter.ambiguous,
+        });
+    const encodeProgress = job.progress === undefined
+        ? undefined
+        : Schema.encodeUnknownEffect(Schema.fromJsonString(Schema.toCodecJson(job.progress)));
+    return {
+        attempts: policy.attempts,
+        backoff: policy.backoff,
+        progressEveryMs: encodeProgress === undefined ? undefined : policy.progressEveryMs,
+        perActor: policy.perActor,
+        routesCancelled: onCancelled !== undefined,
+        execute: Effect.fnUntraced(function* (payload, version, attempt) {
+            const decoded = yield* codec.decode(payload, version).pipe(Effect.mapError((error) => ({
+                cause: error.message,
+                ambiguous: false,
+                notStarted: true,
+            })));
+            const { report, reporting, ...identity } = attempt;
+            const progress = (target, frame) => !reporting()
+                ? Effect.void
+                : target !== job || encodeProgress === undefined
+                    ? Effect.logWarning("Progress frame does not match the running job")
+                    : encodeProgress(frame).pipe(Effect.map((json) => utf8.encode(json)), Effect.matchEffect({
+                        onFailure: (error) => Effect.logWarning("Progress frame did not encode", String(error)),
+                        onSuccess: (bytes) => bytes.length > MAX_PROGRESS_BYTES
+                            ? Effect.logWarning("Progress frame exceeds 4 KiB")
+                            : report(bytes),
+                    }), Effect.catchDefect((defect) => Effect.logWarning("Progress frame did not encode", String(defect))));
+            const context = {
+                jobId: identity.jobId,
+                attempt: identity.attempt,
+                principal: identity.principal,
+                ref: identity.ref,
+                progress,
+            };
+            const exit = yield* execute(decoded).pipe(Effect.timeoutOrElse({
+                duration: policy.timeoutMs,
+                orElse: () => Effect.die(new Error(`Executor timed out after ${policy.timeoutMs} ms`)),
+            }), Effect.provideService(Executor, context), Effect.provideService(Tenant, context.ref.tenant), Effect.exit);
+            if (Exit.isFailure(exit))
+                return yield* Effect.fail({
+                    cause: Cause.pretty(exit.cause),
+                    ambiguous: !Cause.hasFails(exit.cause) ||
+                        Cause.hasDies(exit.cause) ||
+                        Cause.hasInterrupts(exit.cause),
+                });
+            const cancelled = onCancelled === undefined
+                ? undefined
+                : yield* cancelledRoute(decoded, {
+                    jobId: context.jobId,
+                    attempts: context.attempt,
+                    outcome: CancelledOutcome.cases.Succeeded.make({ value: exit.value }),
+                    ambiguous: false,
+                }).pipe(Effect.catch((error) => cancelledRoute(decoded, {
+                    jobId: context.jobId,
+                    attempts: context.attempt,
+                    outcome: CancelledOutcome.cases.Unknown.make({
+                        cause: `The onCancelled route cannot accept the result: ${String(error)}`,
+                    }),
+                    ambiguous: true,
+                })), Effect.orDie);
+            if (onSuccess === undefined)
+                return { success: undefined, cancelled, rejected: undefined };
+            const success = yield* onSuccess(exit.value).pipe(Effect.result);
+            if (Result.isFailure(success))
+                return {
+                    success: undefined,
+                    cancelled,
+                    rejected: {
+                        cause: `The onSuccess route cannot accept the result: ${String(success.failure)}`,
+                        ambiguous: true,
+                        final: true,
+                    },
+                };
+            return { success: success.success, cancelled, rejected: undefined };
+        }),
+        cancelled: Effect.fnUntraced(function* (payload, version, letter) {
+            const decoded = yield* codec.decode(payload, version).pipe(Effect.option);
+            if (Option.isNone(decoded))
+                return undefined;
+            return yield* cancelledRoute(decoded.value, letter);
+        }, Effect.orDie),
+        deadLetter: Effect.fnUntraced(function* (payload, version, letter) {
+            const decoded = yield* codec.decode(payload, version).pipe(Effect.option);
+            if (onDeadLetter === undefined || Option.isNone(decoded))
+                return undefined;
+            return yield* onDeadLetter({
+                jobId: letter.jobId,
+                job: decoded.value,
+                attempts: letter.attempts,
+                cause: letter.cause,
+                ambiguous: letter.ambiguous,
+            });
+        }, Effect.orDie),
+    };
+};
+/** Every declared job's registration; a job without an executor is a defect of the layer. */
+export const jobsOf = ({ descriptor, Executor, executors, }) => Effect.gen(function* () {
+    const registered = new Map();
+    for (const compiled of descriptor.jobs.values()) {
+        const execute = executors[compiled.job.tag];
+        if (execute === undefined)
+            return yield* Effect.die(new Error(`Missing executor ${compiled.job.tag}`));
+        registered.set(compiled.job.tag, jobOf(Executor, compiled, execute));
+    }
+    return registered;
+});

package/dist/actor/layers.d.ts

@@ -0,0 +1,41 @@
+import { Context, Effect, Layer, Scope } from "effect";
+import { InternalActors } from "../runtime/actors.ts";
+import type { Descriptor } from "./descriptor.ts";
+/** The per-actor phase services `Actor.make` creates, which the adapters provide. */
+export interface PhaseServices {
+    readonly Turn: Context.Key<object, object>;
+    readonly Read: Context.Key<object, object>;
+    readonly Connection: Context.Key<object, object>;
+    readonly Workflow: Context.Key<object, object>;
+    readonly Executor: Context.Key<object, object>;
+}
+/**
+ * What a layer constructor receives: the descriptor, its phase services, the
+ * entries or an Effect that builds them, and the Effect that captures the
+ * services the entries require when the layer is built.
+ */
+export interface LayerOptions<H extends object, E, RB, RS> {
+    readonly descriptor: Descriptor;
+    readonly phases: PhaseServices;
+    readonly build: H | Effect.Effect<H, E, RB>;
+    readonly services: Effect.Effect<Context.Context<RS>, never, RS>;
+}
+/**
+ * The owner of an ordinary actor's handlers: the builder runs once, when the
+ * layer is built, and every activation on this runner shares its handlers. A
+ * builder failure fails the layer. Workflow bodies receive the layer's context
+ * without its `Scope`: a body's scope is its run's.
+ */
+export declare const ordinaryLayer: <H extends object, E, RB, RS>({ descriptor, phases, build, services: capture, }: LayerOptions<H, E, RB, RS>) => Layer.Layer<never, E, InternalActors | Exclude<RB, Scope.Scope> | Exclude<RS, Scope.Scope>>;
+/**
+ * The owner of a singleton's handlers: the builder runs once per activation,
+ * in the activation's scope, as the actor with a `System({ source: "actor" })`
+ * caller, so a fiber it forks with `Effect.forkScoped` lives exactly as long
+ * as the one cluster-wide activation. A builder failure fails that activation,
+ * whose commands then fail, rather than the layer.
+ */
+export declare const singletonLayer: <H extends object, E, RB, RS>({ descriptor, phases, build, services: capture, }: LayerOptions<H, E, RB, RS>) => Layer.Layer<never, never, InternalActors | Exclude<RB, Scope.Scope> | Exclude<RS, Scope.Scope>>;
+/** Registers every query's handler; queries run on the caller's node. */
+export declare const queryLayer: <H extends object, E, RB, RS>({ descriptor, phases, build, services: capture, }: LayerOptions<H, E, RB, RS>) => Layer.Layer<never, E, InternalActors | Exclude<RB, Scope.Scope> | Exclude<RS, Scope.Scope>>;
+/** Registers every job's executor; executors run after the enqueueing turn commits. */
+export declare const jobLayer: <H extends object, E, RB, RS>({ descriptor, phases, build, services: capture, }: LayerOptions<H, E, RB, RS>) => Layer.Layer<never, E, InternalActors | Exclude<RB, Scope.Scope> | Exclude<RS, Scope.Scope>>;

package/dist/actor/layers.js

@@ -0,0 +1,177 @@
+import { Context, Effect, Layer, Predicate, Scope } from "effect";
+import { CurrentCaller, System, Tenant } from "../identity/caller.js";
+import { payloadChain } from "../members/payload.js";
+import { InternalActors } from "../runtime/actors.js";
+import { connectionOf } from "./connections.js";
+import { jobsOf } from "./jobs.js";
+import { queriesOf, streamOf } from "./reads.js";
+import { turnsOf } from "./turns.js";
+import { workflowsOf } from "./workflows.js";
+/** The entries themselves, or what the builder builds. */
+const built = (build) => (Effect.isEffect(build) ? build : Effect.succeed(build));
+/** The layer's entries as the adapters read them: by tag, with member types erased. */
+const erased = (entries) => entries;
+const registrationOf = (descriptor, tenant) => ({
+    name: descriptor.name,
+    singleton: descriptor.singleton,
+    mintable: descriptor.mintable,
+    watches: descriptor.watches,
+    tenant,
+    access: descriptor.access,
+    placement: descriptor.placement,
+    policy: descriptor.policy,
+    tables: descriptor.tables,
+    blobs: descriptor.blobs,
+    cron: descriptor.cron,
+    subscriptions: descriptor.registeredSubscriptions,
+    subscribers: descriptor.policy.subscribers,
+    payloads: [
+        ...descriptor.payloads(true),
+        ...descriptor.subscriptions.flatMap((declared) => declared.events.map((event) => ({
+            actorType: declared.source.name,
+            kind: "event",
+            tag: event.identifier,
+            chain: payloadChain(event),
+            writes: false,
+        }))),
+    ],
+    upcastEvent: (tag, version, value) => {
+        const codec = descriptor.eventCodecs.get(tag);
+        return codec === undefined
+            ? Effect.die(new Error(`Undeclared event: ${tag}`))
+            : codec.upcast(value, version).pipe(Effect.orDie);
+    },
+    feeds: descriptor.feeds,
+});
+const connectionsOf = (descriptor, phases, entries, services) => Effect.gen(function* () {
+    const connections = new Map();
+    for (const member of descriptor.connections) {
+        const entry = entries[member.tag];
+        if (entry === undefined ||
+            !Predicate.hasProperty(entry, "open") ||
+            !Predicate.isFunction(entry.open) ||
+            !Predicate.isFunction(entry.frame))
+            return yield* Effect.die(new Error(`Missing connection handlers ${member.tag}`));
+        connections.set(member.tag, connectionOf({ descriptor, Connection: phases.Connection, member, entry, services }));
+    }
+    return connections;
+});
+const streamsOf = (descriptor, phases, entries, services, actors) => Effect.gen(function* () {
+    const streams = new Map();
+    for (const member of descriptor.streams) {
+        const handle = entries[member.tag];
+        if (!Predicate.isFunction(handle))
+            return yield* Effect.die(new Error(`Missing stream handler ${member.tag}`));
+        streams.set(member.tag, streamOf({
+            descriptor,
+            Read: phases.Read,
+            member,
+            handle: handle,
+            services,
+            actors,
+        }));
+    }
+    return streams;
+});
+const handlersOf = (entries) => Object.fromEntries(Object.entries(entries).flatMap(([tag, entry]) => Predicate.isFunction(entry) ? [[tag, entry]] : []));
+/**
+ * The owner of an ordinary actor's handlers: the builder runs once, when the
+ * layer is built, and every activation on this runner shares its handlers. A
+ * builder failure fails the layer. Workflow bodies receive the layer's context
+ * without its `Scope`: a body's scope is its run's.
+ */
+export const ordinaryLayer = ({ descriptor, phases, build, services: capture, }) => Layer.effectDiscard(Effect.gen(function* () {
+    const actors = yield* InternalActors;
+    const registration = registrationOf(descriptor, yield* Tenant);
+    const entries = erased(yield* built(build));
+    const services = (yield* capture);
+    const connections = yield* connectionsOf(descriptor, phases, entries, services);
+    const streams = yield* streamsOf(descriptor, phases, entries, services, actors);
+    const handlers = handlersOf(entries);
+    const commands = yield* turnsOf({
+        descriptor,
+        Turn: phases.Turn,
+        handlers,
+        services,
+        actors,
+    });
+    const workflows = yield* workflowsOf({
+        descriptor,
+        Workflow: phases.Workflow,
+        bodies: handlers,
+        services: services.pipe(Context.omit(Scope.Scope)),
+    });
+    return yield* actors.register({
+        ...registration,
+        workflows,
+        activate: () => Effect.succeed(commands),
+        connections,
+        streams,
+    });
+}));
+/**
+ * The owner of a singleton's handlers: the builder runs once per activation,
+ * in the activation's scope, as the actor with a `System({ source: "actor" })`
+ * caller, so a fiber it forks with `Effect.forkScoped` lives exactly as long
+ * as the one cluster-wide activation. A builder failure fails that activation,
+ * whose commands then fail, rather than the layer.
+ */
+export const singletonLayer = ({ descriptor, phases, build, services: capture, }) => Layer.effectDiscard(Effect.gen(function* () {
+    const actors = yield* InternalActors;
+    const registration = registrationOf(descriptor, yield* Tenant);
+    if (descriptor.connections.length > 0 ||
+        descriptor.streams.length > 0 ||
+        descriptor.feeds.size > 0 ||
+        descriptor.watches.size > 0)
+        return yield* Effect.die(new Error("Singleton actors cannot declare connections, streams, feeds, or watches yet"));
+    const services = (yield* capture);
+    const buildServices = yield* Effect.context();
+    if (descriptor.workflows.length > 0)
+        return yield* Effect.die(new Error(`Singleton actor ${descriptor.name} cannot declare workflows`));
+    yield* actors.register({
+        ...registration,
+        workflows: new Map(),
+        activate: Effect.fnUntraced(function* (ref) {
+            const scope = yield* Scope.Scope;
+            const entries = erased(yield* built(build).pipe(Effect.provideService(Scope.Scope, scope), Effect.provideService(Tenant, ref.tenant), Effect.provideService(CurrentCaller, System.make({ source: "actor", ref })), Effect.provideContext(buildServices), Effect.orDie));
+            return yield* turnsOf({
+                descriptor,
+                Turn: phases.Turn,
+                handlers: handlersOf(entries),
+                services,
+                actors,
+            });
+        }),
+        connections: new Map(),
+        streams: new Map(),
+    });
+}));
+/** Registers every query's handler; queries run on the caller's node. */
+export const queryLayer = ({ descriptor, phases, build, services: capture, }) => Layer.effectDiscard(Effect.gen(function* () {
+    const actors = yield* InternalActors;
+    const handlers = handlersOf(erased(yield* built(build)));
+    const services = (yield* capture);
+    yield* actors.registerQueries({
+        name: descriptor.name,
+        access: descriptor.access,
+        placement: descriptor.placement,
+        timeoutMs: descriptor.policy.executionMs,
+        tables: descriptor.tables,
+        blobs: descriptor.blobs,
+        queries: yield* queriesOf({ descriptor, Read: phases.Read, handlers, services, actors }),
+        payloads: descriptor.payloads(false).filter((declared) => declared.kind === "event"),
+    });
+}));
+/** Registers every job's executor; executors run after the enqueueing turn commits. */
+export const jobLayer = ({ descriptor, phases, build, services: capture, }) => Layer.effectDiscard(Effect.gen(function* () {
+    const actors = yield* InternalActors;
+    const executors = handlersOf(erased(yield* built(build)));
+    const services = (yield* capture);
+    yield* actors.registerJobs({
+        name: descriptor.name,
+        progress: descriptor.progressJobs,
+        services,
+        jobs: yield* jobsOf({ descriptor, Executor: phases.Executor, executors }),
+        payloads: descriptor.payloads(false).filter((declared) => declared.kind === "job"),
+    });
+}));