effect-cf 0.0.4 → 0.2.0

package/src/QueueDefinition.ts

@@ -0,0 +1,129 @@
+import { Effect, Schema as S, type Layer, type Scope } from "effect";
+
+import type { WorkerEnvironment } from "./Environment";
+import * as QueueEntrypoint from "./Queue";
+import * as QueueBinding from "./QueueBinding";
+import type { ExecutionContext, WorkerContext } from "./Worker";
+import * as WorkerEntrypoint from "./Worker";
+import type * as RpcDefinition from "./RpcDefinition";
+
+export interface Definition<
+  Id extends string = string,
+  Message extends RpcDefinition.ServiceFreeSchema = RpcDefinition.ServiceFreeSchema,
+> {
+  readonly id: Id;
+  readonly message: Message;
+}
+
+export namespace Definition {
+  export type Any = Definition<string, RpcDefinition.ServiceFreeSchema>;
+}
+
+declare const BindingServiceTypeId: unique symbol;
+
+export interface BindingService<Id extends string, Self extends Definition.Any> {
+  readonly [BindingServiceTypeId]: {
+    readonly id: Id;
+    readonly definition: Self;
+  };
+}
+
+export type Handler<ROut, Self extends Definition.Any> = (
+  batch: QueueEntrypoint.QueueBatch<S.Schema.Type<Self["message"]>>,
+) => Effect.Effect<
+  void,
+  unknown,
+  ExecutionContext | WorkerEntrypoint.WorkerContext | WorkerEnvironment | Scope.Scope | ROut
+>;
+
+export interface Options<ROut, Self extends Definition.Any> extends Omit<
+  WorkerEntrypoint.WorkerOptions<ROut, Record<never, never>>,
+  "queue" | "rpc"
+> {
+  readonly queue: Handler<ROut, Self>;
+  readonly rpc?: never;
+}
+
+const makeDefinition = <Id extends string, Message extends RpcDefinition.ServiceFreeSchema>(
+  id: Id,
+  definition: { readonly message: Message },
+) => {
+  type SelfDefinition = Definition<Id, Message>;
+  const queueDefinition: SelfDefinition = {
+    id,
+    message: definition.message,
+  };
+
+  return Object.assign(queueDefinition, {
+    make: <ROut, LayerError>(
+      layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>,
+      options: Options<ROut, SelfDefinition>,
+    ) =>
+      WorkerEntrypoint.make(layer, {
+        ...options,
+        queue: wrapHandler(queueDefinition, options.queue),
+      }),
+    Binding:
+      <Self>() =>
+      <BindingId extends string>(
+        bindingId: BindingId,
+        binding: Omit<QueueBinding.QueueBindingDefinition<Message>, "message">,
+      ) =>
+        QueueBinding.Service<Self>()<BindingId, Message>(bindingId, {
+          ...binding,
+          message: definition.message,
+        }),
+    binding: <BindingId extends string>(
+      bindingId: BindingId,
+      binding: Omit<QueueBinding.QueueBindingDefinition<Message>, "message">,
+    ) =>
+      QueueBinding.Service<BindingService<BindingId, SelfDefinition>>()<BindingId, Message>(
+        bindingId,
+        {
+          ...binding,
+          message: definition.message,
+        },
+      ),
+  });
+};
+
+export const make = makeDefinition;
+
+export const Tag =
+  <_Self>() =>
+  <Id extends string, Message extends RpcDefinition.ServiceFreeSchema>(
+    id: Id,
+    definition: { readonly message: Message },
+  ) => {
+    const queueDefinition = makeDefinition(id, definition);
+
+    abstract class QueueDefinitionClass {
+      static readonly id = queueDefinition.id;
+      static readonly message = queueDefinition.message;
+      static readonly make = queueDefinition.make;
+      static readonly Binding = queueDefinition.Binding;
+      static readonly binding = queueDefinition.binding;
+    }
+
+    return QueueDefinitionClass as (abstract new () => object) & typeof queueDefinition;
+  };
+
+export const Queue = Tag;
+
+const wrapHandler = <ROut, const Self extends Definition.Any>(
+  definition: Self,
+  handler: Handler<ROut, Self>,
+): QueueEntrypoint.QueueHandler<ROut> => {
+  const decodeBody = S.decodeUnknownEffect(definition.message);
+
+  return (batch) =>
+    Effect.gen(function* () {
+      const decoded = yield* QueueEntrypoint.decodeBatch(batch.raw, decodeBody);
+      yield* handler(decoded);
+    });
+};
+
+export const implement = <ROut, const Self extends Definition.Any>(
+  _definition: Self,
+  handler: Handler<ROut, Self>,
+): Handler<ROut, Self> => handler;

package/src/Worker.ts

@@ -1,20 +1,13 @@
 import { WorkerEntrypoint as CloudflareWorkerEntrypoint } from "cloudflare:workers";
-import {
-  Cause,
-  ConfigProvider,
-  Context,
-  Effect,
-  Exit,
-  Layer,
-  ManagedRuntime,
-  type Scope,
-} from "effect";
+import { Cause, ConfigProvider, Context, Effect, Layer, ManagedRuntime, type Scope } from "effect";
 import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
 
 import { WorkerConfig, WorkerEnvironment, type WorkerEnv } from "./Environment";
+import { fromMessage, fromMessageBatch, type QueueHandler } from "./Queue";
 import type * as RpcDefinition from "./RpcDefinition";
 import * as WorkerDefinition from "./WorkerDefinition";
 import * as Entrypoint from "./internal/Entrypoint";
+import { fromExecutionContext, type RunWaitUntilEffect } from "./internal/WorkerContext";
 
 export class ExecutionContext extends Context.Service<
   ExecutionContext,
@@ -22,6 +15,7 @@ export class ExecutionContext extends Context.Service<
 >()("effect-cf/ExecutionContext") {}
 
 export interface WorkerContextWaitUntilOptions<E, R> {
+  readonly mode?: "observe" | "propagate";
   readonly onFailure?: (cause: Cause.Cause<E>) => Effect.Effect<void, never, R>;
 }
 
@@ -31,6 +25,10 @@ export interface WorkerContextService {
     effect: Effect.Effect<A, E, R>,
     options?: WorkerContextWaitUntilOptions<E, R2>,
   ): Effect.Effect<void, never, R | R2>;
+  waitUntilPropagating<A, E, R, R2 = never>(
+    effect: Effect.Effect<A, E, R>,
+    options?: Omit<WorkerContextWaitUntilOptions<E, R2>, "mode">,
+  ): Effect.Effect<void, never, R | R2>;
   readonly passThroughOnException: Effect.Effect<void>;
 }
 
@@ -38,60 +36,6 @@ export class WorkerContext extends Context.Service<WorkerContext, WorkerContextS
   "effect-cf/WorkerContext",
 ) {}
 
-type RunWaitUntilEffect = <A, E>(
-  effect: Effect.Effect<A, E, never>,
-) => Promise<Exit.Exit<A, unknown>>;
-
-const fromExecutionContext = (
-  ctx: globalThis.ExecutionContext,
-  runPromiseExit: RunWaitUntilEffect,
-): WorkerContextService => ({
-  raw: ctx,
-  waitUntil: <A, E, R, R2 = never>(
-    effect: Effect.Effect<A, E, R>,
-    options?: WorkerContextWaitUntilOptions<E, R2>,
-  ) =>
-    Effect.context<R | R2>().pipe(
-      Effect.flatMap((context) =>
-        Effect.sync(() => {
-          const observed = Effect.exit(effect).pipe(
-            Effect.flatMap((exit) => {
-              if (Exit.isSuccess(exit)) {
-                return Effect.void;
-              }
-
-              const handleFailure =
-                options?.onFailure?.(exit.cause) ??
-                Effect.logError("WorkerContext.waitUntil failed", Cause.pretty(exit.cause));
-
-              return handleFailure.pipe(
-                Effect.catchCause((handlerCause) =>
-                  Effect.logError(
-                    "WorkerContext.waitUntil failure handler failed",
-                    Cause.pretty(exit.cause),
-                    Cause.pretty(handlerCause),
-                  ),
-                ),
-              );
-            }),
-          );
-
-          ctx.waitUntil(
-            runPromiseExit(Effect.scoped(Effect.provideContext(observed, context))).then((exit) => {
-              if (Exit.isFailure(exit)) {
-                console.error(
-                  "WorkerContext.waitUntil failure handler failed",
-                  Cause.pretty(exit.cause),
-                );
-              }
-            }),
-          );
-        }),
-      ),
-    ),
-  passThroughOnException: Effect.sync(() => ctx.passThroughOnException()),
-});
-
 export class NativeRequest extends Context.Service<NativeRequest, Request>()(
   "effect-cf/NativeRequest",
 ) {}
@@ -103,6 +47,12 @@ export type ReservedMethodName =
   | RpcDefinition.ReservedMethodName
   | "fetch"
   | "connect"
+  | "queue"
+  | "scheduled"
+  | "tail"
+  | "tailStream"
+  | "test"
+  | "trace"
   | "alarm"
   | "webSocketMessage"
   | "webSocketClose"
@@ -113,6 +63,12 @@ const reservedMethodNames = new Set<string>([
   "dup",
   "fetch",
   "connect",
+  "queue",
+  "scheduled",
+  "tail",
+  "tailStream",
+  "test",
+  "trace",
   "alarm",
   "webSocketMessage",
   "webSocketClose",
@@ -169,6 +125,7 @@ export type RpcHandlers<ROut, Api> = {
 
 export interface WorkerOptions<ROut, Rpc extends WorkerRpc<ROut>> {
   readonly fetch?: Effect.Effect<WorkerFetchSuccess, unknown, WorkerFetchContext<ROut>>;
+  readonly queue?: QueueHandler<ROut>;
   readonly rpc?: Rpc;
 }
 
@@ -181,6 +138,7 @@ export type WorkerClass<Rpc extends WorkerRpc<ROut>, ROut> = new (
   env: WorkerEnv,
 ) => CloudflareWorkerEntrypoint<WorkerEnv> & {
   fetch(request: Request): Promise<Response>;
+  queue(batch: globalThis.MessageBatch): Promise<void>;
 } & WorkerRpcShape<Rpc, ROut>;
 
 export interface FetchHandler<Env extends WorkerEnv = WorkerEnv> {
@@ -211,10 +169,29 @@ const renderFetchSuccess = <E, R>(
         ),
   );
 
-export const make = <ROut, LayerError, const Rpc extends WorkerRpc<ROut> = Record<never, never>>(
+const isWorkerOptions = <ROut, Rpc extends WorkerRpc<ROut>>(
+  options: WorkerOptions<ROut, Rpc> | WorkerHandler<ROut>,
+): options is WorkerOptions<ROut, Rpc> =>
+  typeof options === "object" &&
+  options !== null &&
+  ("fetch" in options || "queue" in options || "rpc" in options);
+
+export function make<ROut, LayerError>(
+  layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>,
+  fetch: WorkerHandler<ROut>,
+): WorkerClass<Record<never, never>, ROut>;
+export function make<ROut, LayerError, const Rpc extends WorkerRpc<ROut> = Record<never, never>>(
   layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>,
   options: WorkerOptions<ROut, Rpc>,
-): WorkerClass<Rpc, ROut> => {
+): WorkerClass<Rpc, ROut>;
+export function make<ROut, LayerError, const Rpc extends WorkerRpc<ROut> = Record<never, never>>(
+  layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>,
+  optionsOrFetch: WorkerOptions<ROut, Rpc> | WorkerHandler<ROut>,
+): WorkerClass<Rpc, ROut> {
+  const options = isWorkerOptions(optionsOrFetch)
+    ? optionsOrFetch
+    : ({ fetch: optionsOrFetch } as WorkerOptions<ROut, Rpc>);
+
   class EffectWorker extends CloudflareWorkerEntrypoint<WorkerEnv> {
     readonly runtime: ManagedRuntime.ManagedRuntime<RuntimeContext<ROut>, LayerError>;
 
@@ -222,7 +199,7 @@ export const make = <ROut, LayerError, const Rpc extends WorkerRpc<ROut> = Recor
       super(ctx, env);
 
       let runWaitUntilEffect: RunWaitUntilEffect = () =>
-        Promise.resolve(Exit.die(new Error("WorkerContext runtime is not initialized")));
+        Promise.reject(new Error("WorkerContext runtime is not initialized"));
 
       const services = Layer.mergeAll(
         Layer.succeed(ExecutionContext, ctx),
@@ -269,6 +246,18 @@ export const make = <ROut, LayerError, const Rpc extends WorkerRpc<ROut> = Recor
         >,
       );
     }
+
+    queue(batch: globalThis.MessageBatch): Promise<void> {
+      const queueHandler = options.queue;
+
+      if (queueHandler === undefined) {
+        return Promise.resolve();
+      }
+
+      const messages = batch.messages.map((message) => fromMessage(message, message.body));
+
+      return this[RunSymbol](queueHandler(fromMessageBatch(batch, messages)));
+    }
   }
 
   Entrypoint.defineEntrypointRpcMethods<EffectWorker>(
@@ -280,7 +269,7 @@ export const make = <ROut, LayerError, const Rpc extends WorkerRpc<ROut> = Recor
   );
 
   return Entrypoint.assumeEntrypointClass<WorkerClass<Rpc, ROut>>(EffectWorker);
-};
+}
 
 export const makeFetchHandler = <ROut, LayerError, Env extends WorkerEnv = WorkerEnv>(
   layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>,

package/src/WorkerDefinition.ts

@@ -28,6 +28,12 @@ const reservedMethodNames = new Set<string>([
   "dup",
   "fetch",
   "connect",
+  "queue",
+  "scheduled",
+  "tail",
+  "tailStream",
+  "test",
+  "trace",
   "alarm",
   "webSocketMessage",
   "webSocketClose",

package/src/Workflow.ts

@@ -0,0 +1,279 @@
+import {
+  WorkflowEntrypoint as CloudflareWorkflowEntrypoint,
+  type WorkflowEvent as CloudflareWorkflowEvent,
+  type WorkflowSleepDuration,
+  type WorkflowStep as CloudflareWorkflowStep,
+  type WorkflowStepConfig,
+  type WorkflowStepContext as CloudflareWorkflowStepContext,
+  type WorkflowStepEvent,
+  type WorkflowTimeoutDuration,
+} from "cloudflare:workers";
+import { ConfigProvider, Context, Effect, Layer, ManagedRuntime, type Scope } from "effect";
+
+import { WorkerConfig, WorkerEnvironment, type WorkerEnv } from "./Environment";
+import { ExecutionContext, WorkerContext } from "./Worker";
+import * as WorkflowDefinition from "./WorkflowDefinition";
+import * as Entrypoint from "./internal/Entrypoint";
+import { fromExecutionContext, type RunWaitUntilEffect } from "./internal/WorkerContext";
+
+export interface WorkflowEventService<Payload = unknown> {
+  readonly raw: CloudflareWorkflowEvent<unknown>;
+  readonly payload: Payload;
+  readonly timestamp: Date;
+  readonly instanceId: string;
+}
+
+export class WorkflowEvent extends Context.Service<WorkflowEvent, WorkflowEventService>()(
+  "effect-cf/WorkflowEvent",
+) {}
+
+type RunWorkflowStepEffect = <A, E>(effect: Effect.Effect<A, E, never>) => Promise<A>;
+
+export interface WorkflowStepService {
+  readonly raw: CloudflareWorkflowStep;
+  do<A, E, R>(
+    name: string,
+    effect: Effect.Effect<A, E, R>,
+    config?: WorkflowStepConfig,
+  ): Effect.Effect<A, unknown, Exclude<R, WorkflowStepContext>>;
+  readonly sleep: (name: string, duration: WorkflowSleepDuration) => Effect.Effect<void, unknown>;
+  readonly sleepUntil: (name: string, timestamp: Date | number) => Effect.Effect<void, unknown>;
+  readonly waitForEvent: <Payload>(
+    name: string,
+    options: {
+      readonly type: string;
+      readonly timeout?: WorkflowTimeoutDuration | number;
+    },
+  ) => Effect.Effect<WorkflowStepEvent<Payload>, unknown>;
+}
+
+export class WorkflowStep extends Context.Service<WorkflowStep, WorkflowStepService>()(
+  "effect-cf/WorkflowStep",
+) {}
+
+export class WorkflowStepContext extends Context.Service<
+  WorkflowStepContext,
+  CloudflareWorkflowStepContext
+>()("effect-cf/WorkflowStepContext") {}
+
+const fromWorkflowEvent = <Payload>(
+  event: CloudflareWorkflowEvent<Payload>,
+): WorkflowEventService<Payload> => ({
+  raw: event as CloudflareWorkflowEvent<unknown>,
+  payload: event.payload,
+  timestamp: event.timestamp,
+  instanceId: event.instanceId,
+});
+
+const fromWorkflowStep = (
+  step: CloudflareWorkflowStep,
+  runPromise: RunWorkflowStepEffect,
+): WorkflowStepService => ({
+  raw: step,
+  do: <A, E, R>(name: string, effect: Effect.Effect<A, E, R>, config?: WorkflowStepConfig) =>
+    Effect.context<Exclude<R, WorkflowStepContext>>().pipe(
+      Effect.flatMap((context) =>
+        Effect.tryPromise({
+          try: () => {
+            const run = (stepContext: CloudflareWorkflowStepContext) =>
+              runPromise(
+                Effect.scoped(
+                  Effect.provideService(
+                    Effect.provideContext(
+                      effect as Effect.Effect<A, E, Exclude<R, WorkflowStepContext>>,
+                      context,
+                    ),
+                    WorkflowStepContext,
+                    stepContext,
+                  ),
+                ),
+              );
+            const rawStep = step as {
+              do(
+                name: string,
+                callback: (context: CloudflareWorkflowStepContext) => Promise<A>,
+              ): Promise<A>;
+              do(
+                name: string,
+                config: WorkflowStepConfig,
+                callback: (context: CloudflareWorkflowStepContext) => Promise<A>,
+              ): Promise<A>;
+            };
+
+            return config === undefined ? rawStep.do(name, run) : rawStep.do(name, config, run);
+          },
+          catch: (cause) => cause,
+        }),
+      ),
+    ) as Effect.Effect<A, unknown, Exclude<R, WorkflowStepContext>>,
+  sleep: (name, duration) =>
+    Effect.tryPromise({
+      try: () => step.sleep(name, duration),
+      catch: (cause) => cause,
+    }),
+  sleepUntil: (name, timestamp) =>
+    Effect.tryPromise({
+      try: () => step.sleepUntil(name, timestamp),
+      catch: (cause) => cause,
+    }),
+  waitForEvent: <Payload>(
+    name: string,
+    options: {
+      readonly type: string;
+      readonly timeout?: WorkflowTimeoutDuration | number;
+    },
+  ) =>
+    Effect.tryPromise({
+      try: () => step.waitForEvent(name, options) as Promise<WorkflowStepEvent<Payload>>,
+      catch: (cause) => cause,
+    }),
+});
+
+type RuntimeContext<ROut> = ExecutionContext | WorkerContext | WorkerEnvironment | ROut;
+
+export type WorkflowRunContext<ROut> =
+  | RuntimeContext<ROut>
+  | WorkflowEvent
+  | WorkflowStep
+  | Scope.Scope;
+
+export type WorkflowHandler<ROut, Payload = unknown, Result = unknown> = (
+  payload: Payload,
+) => Effect.Effect<Result, unknown, WorkflowRunContext<ROut>>;
+
+export interface WorkflowOptions<ROut, Payload = unknown, Result = unknown> {
+  readonly run: WorkflowHandler<ROut, Payload, Result>;
+}
+
+export type WorkflowClass<Payload, Result, _ROut> = new (
+  ctx: globalThis.ExecutionContext,
+  env: WorkerEnv,
+) => CloudflareWorkflowEntrypoint<WorkerEnv, Payload> & {
+  run(
+    event: Readonly<CloudflareWorkflowEvent<Payload>>,
+    step: CloudflareWorkflowStep,
+  ): Promise<Result>;
+};
+
+export const make = <ROut, LayerError, Payload = unknown, Result = unknown>(
+  layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>,
+  options: WorkflowOptions<ROut, Payload, Result>,
+): WorkflowClass<Payload, Result, ROut> => {
+  class EffectWorkflow extends CloudflareWorkflowEntrypoint<WorkerEnv, Payload> {
+    readonly runtime: ManagedRuntime.ManagedRuntime<RuntimeContext<ROut>, LayerError>;
+
+    constructor(ctx: globalThis.ExecutionContext, env: WorkerEnv) {
+      super(ctx, env);
+
+      let runWaitUntilEffect: RunWaitUntilEffect = () =>
+        Promise.reject(new Error("WorkerContext runtime is not initialized"));
+
+      const services = Layer.mergeAll(
+        Layer.succeed(ExecutionContext, ctx),
+        ConfigProvider.layer(Effect.succeed(WorkerConfig.providerFromEnv(env))),
+        Layer.succeed(
+          WorkerContext,
+          fromExecutionContext(ctx, (effect) => runWaitUntilEffect(effect)),
+        ),
+        Layer.succeed(WorkerEnvironment, env),
+      ) as Layer.Layer<ExecutionContext | WorkerContext | WorkerEnvironment, never, never>;
+
+      const runtimeLayer = Entrypoint.provideEntrypointServices<
+        ROut,
+        LayerError,
+        ExecutionContext | WorkerContext | WorkerEnvironment
+      >(layer, services);
+
+      this.runtime = ManagedRuntime.make(runtimeLayer);
+      runWaitUntilEffect = <A, E>(effect: Effect.Effect<A, E, never>) =>
+        this.runtime.runPromiseExit(effect as Effect.Effect<A, E, RuntimeContext<ROut>>);
+    }
+
+    run(
+      event: Readonly<CloudflareWorkflowEvent<Payload>>,
+      step: CloudflareWorkflowStep,
+    ): Promise<Result> {
+      const workflowServices = Layer.mergeAll(
+        Layer.succeed(WorkflowEvent, fromWorkflowEvent(event)),
+        Layer.succeed(
+          WorkflowStep,
+          fromWorkflowStep(
+            step,
+            (effect) =>
+              this.runtime.runPromise(
+                effect as Effect.Effect<unknown, unknown, RuntimeContext<ROut>>,
+              ) as never,
+          ),
+        ),
+      );
+
+      return this.runtime.runPromise(
+        Effect.scoped(
+          options.run(event.payload).pipe(Effect.provide(workflowServices)),
+        ) as Effect.Effect<Result, unknown, RuntimeContext<ROut>>,
+      );
+    }
+  }
+
+  return Entrypoint.assumeEntrypointClass<WorkflowClass<Payload, Result, ROut>>(EffectWorkflow);
+};
+
+export const step = <A, E, R>(
+  name: string,
+  effect: Effect.Effect<A, E, R>,
+  config?: WorkflowStepConfig,
+): Effect.Effect<A, unknown, WorkflowStep | Exclude<R, WorkflowStepContext>> =>
+  Effect.flatMap(WorkflowStep.asEffect(), (workflowStep) =>
+    workflowStep.do(name, effect, config),
+  ) as Effect.Effect<A, unknown, WorkflowStep | Exclude<R, WorkflowStepContext>>;
+
+export const sleep = (
+  name: string,
+  duration: WorkflowSleepDuration,
+): Effect.Effect<void, unknown, WorkflowStep> =>
+  Effect.flatMap(WorkflowStep.asEffect(), (workflowStep) => workflowStep.sleep(name, duration));
+
+export const sleepUntil = (
+  name: string,
+  timestamp: Date | number,
+): Effect.Effect<void, unknown, WorkflowStep> =>
+  Effect.flatMap(WorkflowStep.asEffect(), (workflowStep) =>
+    workflowStep.sleepUntil(name, timestamp),
+  );
+
+export const waitForEvent = <Payload>(
+  name: string,
+  options: {
+    readonly type: string;
+    readonly timeout?: WorkflowTimeoutDuration | number;
+  },
+): Effect.Effect<WorkflowStepEvent<Payload>, unknown, WorkflowStep> =>
+  Effect.flatMap(WorkflowStep.asEffect(), (workflowStep) =>
+    workflowStep.waitForEvent<Payload>(name, options),
+  );
+
+export const Tag = WorkflowDefinition.Tag;
+
+export const implement = WorkflowDefinition.implement;
+
+export type Definition<
+  Id extends string = string,
+  Payload extends WorkflowDefinition.Definition.Any["payload"] =
+    WorkflowDefinition.Definition.Any["payload"],
+  Result extends WorkflowDefinition.Definition.Any["result"] =
+    WorkflowDefinition.Definition.Any["result"],
+> = WorkflowDefinition.Definition<Id, Payload, Result>;
+
+export namespace Definition {
+  export type Any = WorkflowDefinition.Definition.Any;
+}
+
+export type Handler<
+  ROut,
+  Self extends WorkflowDefinition.Definition.Any,
+> = WorkflowDefinition.Handler<ROut, Self>;
+
+export type Options<
+  ROut,
+  Self extends WorkflowDefinition.Definition.Any,
+> = WorkflowDefinition.Options<ROut, Self>;