effect-cf 0.1.0 → 0.3.0

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>;

package/src/WorkflowBinding.ts

@@ -0,0 +1,254 @@
+import { Data, Effect, Option, Schema as S } from "effect";
+
+import * as Binding from "./Binding";
+import type * as RpcDefinition from "./RpcDefinition";
+
+const TypeId = "effect-cf/WorkflowBinding" as const;
+
+export type WorkflowInstanceCreateOptions<Payload> = Omit<
+  globalThis.WorkflowInstanceCreateOptions<Payload>,
+  "params"
+>;
+
+export type WorkflowInstanceCreateBatchOptions<Payload, EncodedPayload = unknown> = ReadonlyArray<
+  { readonly payload: Payload } & WorkflowInstanceCreateOptions<EncodedPayload>
+>;
+
+export interface WorkflowInstanceRestartOptions {
+  readonly from?: {
+    readonly name?: string;
+    readonly count?: number;
+    readonly type?: string;
+  };
+}
+
+export type WorkflowInstanceStatusName = globalThis.InstanceStatus["status"];
+
+export interface WorkflowInstanceStatus<Result> {
+  readonly status: WorkflowInstanceStatusName;
+  readonly output: Option.Option<Result>;
+  readonly error: Option.Option<{
+    readonly name: string;
+    readonly message: string;
+  }>;
+}
+
+export interface WorkflowInstance<Result> {
+  readonly raw: globalThis.WorkflowInstance;
+  readonly id: string;
+  readonly pause: Effect.Effect<void, WorkflowOperationError>;
+  readonly resume: Effect.Effect<void, WorkflowOperationError>;
+  readonly terminate: Effect.Effect<void, WorkflowOperationError>;
+  readonly restart: (
+    options?: WorkflowInstanceRestartOptions,
+  ) => Effect.Effect<void, WorkflowOperationError>;
+  readonly status: Effect.Effect<
+    WorkflowInstanceStatus<Result>,
+    WorkflowOperationError | WorkflowResultDecodeError
+  >;
+  readonly sendEvent: (event: WorkflowInstanceEvent) => Effect.Effect<void, WorkflowOperationError>;
+}
+
+export interface WorkflowInstanceEvent {
+  readonly type: string;
+  readonly payload: unknown;
+}
+
+export interface WorkflowBindingDefinition<
+  Payload extends RpcDefinition.ServiceFreeSchema,
+  Result extends RpcDefinition.ServiceFreeSchema,
+> {
+  /** Binding name as configured in `wrangler.jsonc`. */
+  readonly binding: string;
+  /** Codec used to encode payloads passed to `Workflow.create`. */
+  readonly payload: Payload;
+  /** Codec used to decode completed workflow status output. */
+  readonly result: Result;
+}
+
+declare const WorkflowServiceTypeId: unique symbol;
+
+export interface WorkflowService<
+  Id extends string,
+  Payload extends RpcDefinition.ServiceFreeSchema,
+  Result extends RpcDefinition.ServiceFreeSchema,
+> {
+  readonly [WorkflowServiceTypeId]: {
+    readonly id: Id;
+    readonly payload: S.Schema.Type<Payload>;
+    readonly encodedPayload: S.Codec.Encoded<Payload>;
+    readonly result: S.Schema.Type<Result>;
+    readonly encodedResult: S.Codec.Encoded<Result>;
+  };
+}
+
+export class WorkflowOperationError extends Data.TaggedError("WorkflowOperationError")<{
+  readonly binding: string;
+  readonly operation: string;
+  readonly cause: unknown;
+}> {}
+
+export class WorkflowResultDecodeError extends Data.TaggedError("WorkflowResultDecodeError")<{
+  readonly binding: string;
+  readonly instanceId: string;
+  readonly cause: unknown;
+}> {}
+
+const workflowError = (binding: string, operation: string, cause: unknown) =>
+  new WorkflowOperationError({ binding, operation, cause });
+
+const tryWorkflowPromise = <A>(
+  binding: string,
+  operation: string,
+  evaluate: () => Promise<A>,
+): Effect.Effect<A, WorkflowOperationError> =>
+  Effect.tryPromise({
+    try: evaluate,
+    catch: (cause) => workflowError(binding, operation, cause),
+  });
+
+const isWorkflow = <Payload>(value: unknown): value is globalThis.Workflow<Payload> => {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+
+  const resource = value as Record<string, unknown>;
+
+  return (
+    typeof resource.create === "function" &&
+    typeof resource.createBatch === "function" &&
+    typeof resource.get === "function"
+  );
+};
+
+export const make = <
+  Id extends string,
+  Payload extends RpcDefinition.ServiceFreeSchema,
+  Result extends RpcDefinition.ServiceFreeSchema,
+>(
+  id: Id,
+  definition: WorkflowBindingDefinition<Payload, Result>,
+) => Service<WorkflowService<Id, Payload, Result>>()<Id, Payload, Result>(id, definition);
+
+export const Service =
+  <Self>() =>
+  <
+    Id extends string,
+    Payload extends RpcDefinition.ServiceFreeSchema,
+    Result extends RpcDefinition.ServiceFreeSchema,
+  >(
+    id: Id,
+    definition: WorkflowBindingDefinition<Payload, Result>,
+  ) => {
+    type PayloadValue = S.Schema.Type<Payload>;
+    type EncodedPayload = S.Codec.Encoded<Payload>;
+    type ResultValue = S.Schema.Type<Result>;
+
+    const tag = Binding.Service<Self>()(
+      id,
+      definition.binding,
+      (value): value is globalThis.Workflow<EncodedPayload> => isWorkflow<EncodedPayload>(value),
+    );
+
+    const encodePayload = S.encodeEffect(definition.payload);
+    const decodeResult = S.decodeUnknownEffect(definition.result);
+
+    const wrapInstance = (raw: globalThis.WorkflowInstance): WorkflowInstance<ResultValue> => {
+      const operation = <A>(name: string, evaluate: () => Promise<A>) =>
+        tryWorkflowPromise(definition.binding, name, evaluate);
+
+      return {
+        raw,
+        id: raw.id,
+        pause: operation("pause", () => raw.pause()),
+        resume: operation("resume", () => raw.resume()),
+        terminate: operation("terminate", () => raw.terminate()),
+        restart: (options) =>
+          operation("restart", () =>
+            (raw as { restart(options?: WorkflowInstanceRestartOptions): Promise<void> }).restart(
+              options,
+            ),
+          ),
+        status: operation("status", () => raw.status()).pipe(
+          Effect.flatMap((status) =>
+            Effect.gen(function* () {
+              const output =
+                status.output === undefined
+                  ? Option.none<ResultValue>()
+                  : Option.some(
+                      yield* decodeResult(status.output).pipe(
+                        Effect.mapError(
+                          (cause) =>
+                            new WorkflowResultDecodeError({
+                              binding: definition.binding,
+                              instanceId: raw.id,
+                              cause,
+                            }),
+                        ),
+                      ),
+                    );
+
+              return {
+                status: status.status,
+                output,
+                error: status.error === undefined ? Option.none() : Option.some(status.error),
+              };
+            }),
+          ),
+        ),
+        sendEvent: (event) => operation("sendEvent", () => raw.sendEvent(event)),
+      };
+    };
+
+    const create = Effect.fnUntraced(function* (
+      payload: PayloadValue,
+      options?: WorkflowInstanceCreateOptions<EncodedPayload>,
+    ) {
+      const workflow = yield* tag;
+      const encoded = yield* encodePayload(payload);
+      const raw = yield* tryWorkflowPromise(definition.binding, "create", () =>
+        workflow.create({ ...options, params: encoded }),
+      );
+
+      return wrapInstance(raw);
+    });
+
+    const createBatch = Effect.fnUntraced(function* (
+      batch: WorkflowInstanceCreateBatchOptions<PayloadValue, EncodedPayload>,
+    ) {
+      const workflow = yield* tag;
+      const encodedBatch: Array<globalThis.WorkflowInstanceCreateOptions<EncodedPayload>> = [];
+
+      for (const item of batch) {
+        const { payload, ...options } = item;
+
+        encodedBatch.push({
+          ...options,
+          params: yield* encodePayload(payload),
+        });
+      }
+
+      const rawInstances = yield* tryWorkflowPromise(definition.binding, "createBatch", () =>
+        workflow.createBatch(encodedBatch),
+      );
+
+      return rawInstances.map(wrapInstance);
+    });
+
+    const get = Effect.fnUntraced(function* (instanceId: string) {
+      const workflow = yield* tag;
+      const raw = yield* tryWorkflowPromise(definition.binding, "get", () =>
+        workflow.get(instanceId),
+      );
+
+      return wrapInstance(raw);
+    });
+
+    return Object.assign(tag, {
+      [TypeId]: TypeId,
+      binding: definition.binding,
+      create,
+      createBatch,
+      get,
+    });
+  };

package/src/WorkflowDefinition.ts

@@ -0,0 +1,167 @@
+import { Effect, Schema as S, type Layer } from "effect";
+
+import type { WorkerEnvironment } from "./Environment";
+import type { ExecutionContext, WorkerContext } from "./Worker";
+import type * as RpcDefinition from "./RpcDefinition";
+import * as WorkflowBinding from "./WorkflowBinding";
+import * as WorkflowEntrypoint from "./Workflow";
+
+export interface Definition<
+  Id extends string = string,
+  Payload extends RpcDefinition.ServiceFreeSchema = RpcDefinition.ServiceFreeSchema,
+  Result extends RpcDefinition.ServiceFreeSchema = RpcDefinition.ServiceFreeSchema,
+> {
+  readonly id: Id;
+  readonly payload: Payload;
+  readonly result: Result;
+}
+
+export namespace Definition {
+  export type Any = Definition<
+    string,
+    RpcDefinition.ServiceFreeSchema,
+    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> = (
+  payload: S.Schema.Type<Self["payload"]>,
+) => Effect.Effect<
+  S.Schema.Type<Self["result"]>,
+  unknown,
+  WorkflowEntrypoint.WorkflowRunContext<ROut>
+>;
+
+export interface Options<ROut, Self extends Definition.Any> {
+  readonly run: Handler<ROut, Self>;
+}
+
+const makeDefinition = <
+  Id extends string,
+  Payload extends RpcDefinition.ServiceFreeSchema,
+  Result extends RpcDefinition.ServiceFreeSchema,
+>(
+  id: Id,
+  definition: {
+    readonly payload: Payload;
+    readonly result: Result;
+  },
+) => {
+  type SelfDefinition = Definition<Id, Payload, Result>;
+  const workflowDefinition: SelfDefinition = {
+    id,
+    payload: definition.payload,
+    result: definition.result,
+  };
+
+  return Object.assign(workflowDefinition, {
+    make: <ROut, LayerError>(
+      layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>,
+      options: Options<ROut, SelfDefinition>,
+    ) =>
+      WorkflowEntrypoint.make(layer, {
+        run: wrapHandler(workflowDefinition, options.run),
+      }),
+    Binding:
+      <Self>() =>
+      <BindingId extends string>(
+        bindingId: BindingId,
+        binding: Omit<
+          WorkflowBinding.WorkflowBindingDefinition<Payload, Result>,
+          "payload" | "result"
+        >,
+      ) =>
+        WorkflowBinding.Service<Self>()<BindingId, Payload, Result>(bindingId, {
+          ...binding,
+          payload: definition.payload,
+          result: definition.result,
+        }),
+    binding: <BindingId extends string>(
+      bindingId: BindingId,
+      binding: Omit<
+        WorkflowBinding.WorkflowBindingDefinition<Payload, Result>,
+        "payload" | "result"
+      >,
+    ) =>
+      WorkflowBinding.Service<BindingService<BindingId, SelfDefinition>>()<
+        BindingId,
+        Payload,
+        Result
+      >(bindingId, {
+        ...binding,
+        payload: definition.payload,
+        result: definition.result,
+      }),
+  });
+};
+
+export const make = makeDefinition;
+
+export const Tag =
+  <_Self>() =>
+  <
+    Id extends string,
+    Payload extends RpcDefinition.ServiceFreeSchema,
+    Result extends RpcDefinition.ServiceFreeSchema,
+  >(
+    id: Id,
+    definition: {
+      readonly payload: Payload;
+      readonly result: Result;
+    },
+  ) => {
+    const workflowDefinition = makeDefinition(id, definition);
+
+    abstract class WorkflowDefinitionClass {
+      static readonly id = workflowDefinition.id;
+      static readonly payload = workflowDefinition.payload;
+      static readonly result = workflowDefinition.result;
+      static readonly make = workflowDefinition.make;
+      static readonly Binding = workflowDefinition.Binding;
+      static readonly binding = workflowDefinition.binding;
+    }
+
+    return WorkflowDefinitionClass as (abstract new () => object) & typeof workflowDefinition;
+  };
+
+export const Workflow = Tag;
+
+const wrapHandler = <ROut, const Self extends Definition.Any>(
+  definition: Self,
+  handler: Handler<ROut, Self>,
+): WorkflowEntrypoint.WorkflowHandler<
+  ROut,
+  S.Codec.Encoded<Self["payload"]>,
+  S.Codec.Encoded<Self["result"]>
+> => {
+  const decodePayload = S.decodeUnknownEffect(definition.payload);
+  const encodeResult = S.encodeEffect(definition.result);
+
+  return (payload) =>
+    Effect.gen(function* () {
+      const decodedPayload = yield* decodePayload(payload);
+      const event = yield* WorkflowEntrypoint.WorkflowEvent;
+      const decodedEvent = {
+        ...event,
+        payload: decodedPayload,
+      } as WorkflowEntrypoint.WorkflowEventService<S.Schema.Type<Self["payload"]>>;
+      const result = yield* handler(decodedPayload as S.Schema.Type<Self["payload"]>).pipe(
+        Effect.provideService(WorkflowEntrypoint.WorkflowEvent, decodedEvent),
+      );
+      return yield* encodeResult(result as S.Schema.Type<Self["result"]>);
+    });
+};
+
+export const implement = <ROut, const Self extends Definition.Any>(
+  _definition: Self,
+  handler: Handler<ROut, Self>,
+): Handler<ROut, Self> => handler;