effect 4.0.0-beta.10 → 4.0.0-beta.12

package/src/unstable/http/HttpServerResponse.ts

@@ -2,6 +2,7 @@
  * @since 4.0.0
  */
 import * as Effect from "../../Effect.ts"
+import * as ErrorReporter from "../../ErrorReporter.ts"
 import type * as FileSystem from "../../FileSystem.ts"
 import { dual } from "../../Function.ts"
 import type * as Inspectable from "../../Inspectable.ts"
@@ -28,7 +29,7 @@ const TypeId = "~effect/http/HttpServerResponse"
  * @since 4.0.0
  * @category models
  */
-export interface HttpServerResponse extends Inspectable.Inspectable, Pipeable {
+export interface HttpServerResponse extends Inspectable.Inspectable, Pipeable, ErrorReporter.Reportable {
   readonly [TypeId]: typeof TypeId
   readonly status: number
   readonly statusText?: string | undefined
@@ -834,6 +835,7 @@ const Proto: Omit<
 > = {
   ...PipeInspectableProto,
   [TypeId]: TypeId,
+  [ErrorReporter.ignore]: true,
   toJSON(this: HttpServerResponse) {
     return {
       _id: "HttpServerResponse",

package/src/unstable/http/internal/preResponseHandler.ts

@@ -0,0 +1,15 @@
+import * as Effect from "../../../Effect.ts"
+import type { PreResponseHandler } from "../HttpEffect.ts"
+import type { HttpServerRequest } from "../HttpServerRequest.ts"
+
+/** @internal */
+export const requestPreResponseHandlers = new WeakMap<HttpServerRequest, PreResponseHandler>()
+
+/** @internal */
+export const appendPreResponseHandlerUnsafe = (request: HttpServerRequest, handler: PreResponseHandler): void => {
+  const prev = requestPreResponseHandlers.get(request)
+  const next: PreResponseHandler = prev ?
+    (request, response) => Effect.flatMap(prev(request, response), (response) => handler(request, response))
+    : handler
+  requestPreResponseHandlers.set(request, next)
+}

package/src/unstable/httpapi/HttpApiBuilder.ts

@@ -356,7 +356,7 @@ export const securitySetCookie = (
   self: HttpApiSecurity.ApiKey,
   value: string | Redacted.Redacted,
   options?: Cookie["options"]
-): Effect.Effect<void> =>
+): Effect.Effect<void, never, HttpServerRequest> =>
   HttpEffect.appendPreResponseHandler((_req, response) =>
     Effect.orDie(
       Response.setCookie(response, self.key, stringOrRedacted(value), {
@@ -549,6 +549,7 @@ function handlerToRoute(
       return Response.isHttpServerResponse(response) ? response : yield* encodeSuccess(response)
     })
   ).pipe(
+    Effect.withErrorReporting,
     Effect.catch((error) => {
       if (Schema.isSchemaError(error)) {
         error = HttpApiSchemaError.fromSchemaError(error)

package/src/unstable/httpapi/HttpApiError.ts

@@ -1,6 +1,7 @@
 /**
  * @since 4.0.0
  */
+import * as ErrorReporter from "../../ErrorReporter.ts"
 import * as Schema from "../../Schema.ts"
 import * as HttpApiSchema from "./HttpApiSchema.ts"
 
@@ -21,6 +22,8 @@ export class HttpApiSchemaError extends Schema.ErrorClass<HttpApiSchemaError>("e
   static fromSchemaError(error: Schema.SchemaError): HttpApiSchemaError {
     return new HttpApiSchemaError({ message: error.message })
   }
+
+  override readonly [ErrorReporter.ignore] = true
 }
 
 /**
@@ -32,7 +35,9 @@ export class BadRequest extends Schema.ErrorClass<BadRequest>("effect/HttpApiErr
 }, {
   description: "BadRequest",
   httpApiStatus: 400
-}) {}
+}) {
+  override readonly [ErrorReporter.ignore] = true
+}
 
 /**
  * @category NoContent errors
@@ -51,7 +56,9 @@ export class Unauthorized extends Schema.ErrorClass<Unauthorized>("effect/HttpAp
 }, {
   description: "Unauthorized",
   httpApiStatus: 401
-}) {}
+}) {
+  override readonly [ErrorReporter.ignore] = true
+}
 
 /**
  * @category NoContent errors
@@ -70,7 +77,9 @@ export class Forbidden extends Schema.ErrorClass<Forbidden>("effect/HttpApiError
 }, {
   description: "Forbidden",
   httpApiStatus: 403
-}) {}
+}) {
+  override readonly [ErrorReporter.ignore] = true
+}
 
 /**
  * @category NoContent errors
@@ -89,7 +98,9 @@ export class NotFound extends Schema.ErrorClass<NotFound>("effect/HttpApiError/N
 }, {
   description: "NotFound",
   httpApiStatus: 404
-}) {}
+}) {
+  override readonly [ErrorReporter.ignore] = true
+}
 
 /**
  * @category NoContent errors
@@ -108,7 +119,9 @@ export class MethodNotAllowed extends Schema.ErrorClass<MethodNotAllowed>("effec
 }, {
   description: "MethodNotAllowed",
   httpApiStatus: 405
-}) {}
+}) {
+  override readonly [ErrorReporter.ignore] = true
+}
 
 /**
  * @category NoContent errors
@@ -127,7 +140,9 @@ export class NotAcceptable extends Schema.ErrorClass<NotAcceptable>("effect/Http
 }, {
   description: "NotAcceptable",
   httpApiStatus: 406
-}) {}
+}) {
+  override readonly [ErrorReporter.ignore] = true
+}
 
 /**
  * @category NoContent errors
@@ -146,7 +161,9 @@ export class RequestTimeout extends Schema.ErrorClass<RequestTimeout>("effect/Ht
 }, {
   description: "RequestTimeout",
   httpApiStatus: 408
-}) {}
+}) {
+  override readonly [ErrorReporter.ignore] = true
+}
 
 /**
  * @category NoContent errors
@@ -165,7 +182,9 @@ export class Conflict extends Schema.ErrorClass<Conflict>("effect/HttpApiError/C
 }, {
   description: "Conflict",
   httpApiStatus: 409
-}) {}
+}) {
+  override readonly [ErrorReporter.ignore] = true
+}
 
 /**
  * @since 4.0.0
@@ -184,7 +203,9 @@ export class Gone extends Schema.ErrorClass<Gone>("effect/HttpApiError/Gone")({
 }, {
   description: "Gone",
   httpApiStatus: 410
-}) {}
+}) {
+  override readonly [ErrorReporter.ignore] = true
+}
 
 /**
  * @category NoContent errors

package/src/unstable/observability/OtlpLogger.ts

@@ -3,6 +3,7 @@
  */
 import * as Arr from "../../Array.ts"
 import * as Cause from "../../Cause.ts"
+import { Clock } from "../../Clock.ts"
 import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import type * as Layer from "../../Layer.ts"
@@ -66,7 +67,8 @@ export const make: (
   })
 
   const opts = {
-    excludeLogSpans: options.excludeLogSpans ?? false
+    excludeLogSpans: options.excludeLogSpans ?? false,
+    clock: yield* Clock
   }
   return Logger.make((options) => {
     exporter.push(makeLogRecord(options, opts))
@@ -104,11 +106,13 @@ export interface LogsData {
 
 // internal
 
-const makeLogRecord = (options: Logger.Logger.Options<unknown>, opts: {
+const makeLogRecord = (options: Logger.Options<unknown>, opts: {
   readonly excludeLogSpans: boolean
+  readonly clock: Clock
 }): ILogRecord => {
-  const now = options.date.getTime()
-  const nanosString = `${now}000000`
+  const now = opts.clock.currentTimeNanosUnsafe()
+  const nanosString = now.toString()
+  const nowMillis = options.date.getTime()
 
   const attributes = OtlpResource.entriesToAttributes(Object.entries(options.fiber.getRef(CurrentLogAnnotations)))
   attributes.push({
@@ -119,7 +123,7 @@ const makeLogRecord = (options: Logger.Logger.Options<unknown>, opts: {
     for (const [label, startTime] of options.fiber.getRef(CurrentLogSpans)) {
       attributes.push({
         key: `logSpan.${label}`,
-        value: { stringValue: `${now - startTime}ms` }
+        value: { stringValue: `${nowMillis - startTime}ms` }
       })
     }
   }

package/src/unstable/reactivity/Atom.ts

@@ -2070,7 +2070,7 @@ export const searchParam = <S extends Schema.Codec<any, string> = never>(name: s
         window.removeEventListener("pushstate", handleUpdate)
       })
       const value = new URLSearchParams(window.location.search).get(name) || ""
-      return decode ? Exit.findErrorOption(decode(value)) : value as any
+      return decode ? Exit.getSuccess(decode(value)) : value as any
     },
     (ctx, value: any) => {
       if (typeof window === "undefined") {

package/src/unstable/reactivity/AtomRegistry.ts

@@ -56,6 +56,8 @@ export interface AtomRegistry {
   }) => () => void
   readonly reset: () => void
   readonly dispose: () => void
+  onNodeAdded?: ((node: Node<any>) => void) | undefined
+  onNodeRemoved?: ((node: Node<any>) => void) | undefined
 }
 
 /**
@@ -65,6 +67,10 @@ export interface AtomRegistry {
 export interface Node<A> {
   readonly atom: Atom.Atom<A>
   readonly value: () => A
+  parents: Array<Node<any>>
+  children: Array<Node<any>>
+  listeners: Set<() => void>
+  currentState(): "uninitialized" | "stale" | "valid" | "removed"
 }
 
 /**
@@ -290,6 +296,8 @@ class RegistryImpl implements AtomRegistry {
   readonly defaultIdleTTL: number | undefined
   readonly scheduler: Scheduler
   readonly schedulerAsync: Scheduler
+  onNodeAdded?: ((node: Node<any>) => void) | undefined
+  onNodeRemoved?: ((node: Node<any>) => void) | undefined
 
   constructor(
     initialValues?: Iterable<readonly [Atom.Atom<any>, any]>,
@@ -386,6 +394,7 @@ class RegistryImpl implements AtomRegistry {
     if (node === undefined) {
       node = this.createNode(atom)
       this.nodes.set(key, node)
+      this.onNodeAdded?.(node)
     } else if (this.atomHasTtl(atom)) {
       this.removeNodeTimeout(node)
     }
@@ -436,6 +445,7 @@ class RegistryImpl implements AtomRegistry {
     } else {
       this.nodes.delete(atomKey(node.atom))
       node.remove()
+      this.onNodeRemoved?.(node)
     }
   }
 
@@ -450,6 +460,7 @@ class RegistryImpl implements AtomRegistry {
       if (idleTTL <= 0) {
         this.nodes.delete(atomKey(node.atom))
         node.remove()
+        this.onNodeRemoved?.(node)
         return
       }
     }
@@ -496,6 +507,7 @@ class RegistryImpl implements AtomRegistry {
       }
       this.nodeTimeoutBucket.delete(node)
       this.nodes.delete(atomKey(node.atom))
+      this.onNodeRemoved?.(node)
       this.#currentSweepTTL = node.atom.idleTTL ?? this.defaultIdleTTL!
       node.remove()
       this.#currentSweepTTL = null
@@ -507,7 +519,10 @@ class RegistryImpl implements AtomRegistry {
     this.timeoutBuckets.clear()
     this.nodeTimeoutBucket.clear()
 
-    this.nodes.forEach((node) => node.remove())
+    this.nodes.forEach((node) => {
+      node.remove()
+      this.onNodeRemoved?.(node)
+    })
     this.nodes.clear()
   }
 
@@ -554,6 +569,19 @@ class NodeImpl<A> {
   listeners: Set<() => void> = new Set()
   skipInvalidation = false
 
+  currentState() {
+    switch (this.state) {
+      case NodeState.uninitialized:
+        return "uninitialized"
+      case NodeState.stale:
+        return "stale"
+      case NodeState.valid:
+        return "valid"
+      default:
+        return "removed"
+    }
+  }
+
   get canBeRemoved(): boolean {
     return !this.atom.keepAlive && this.listeners.size === 0 && this.children.length === 0 && this.state !== 0
   }

package/src/unstable/rpc/RpcSchema.ts

@@ -1,9 +1,12 @@
 /**
  * @since 4.0.0
  */
+import * as Cause from "../../Cause.ts"
+import { constUndefined } from "../../Function.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Schema from "../../Schema.ts"
 import type * as AST from "../../SchemaAST.ts"
+import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream_ from "../../Stream.ts"
 
 const StreamSchemaTypeId = "~effect/rpc/RpcSchema/StreamSchema"
@@ -58,3 +61,17 @@ const schema = Schema.declare(Stream_.isStream)
 export function Stream<A extends Schema.Top, E extends Schema.Top>(success: A, error: E): Stream<A, E> {
   return Schema.make(schema.ast, { [StreamSchemaTypeId]: StreamSchemaTypeId, success, error })
 }
+
+/**
+ * @since 4.0.0
+ * @category Cause annotations
+ */
+export class ClientAbort extends ServiceMap.Service<ClientAbort, true>()("effect/rpc/RpcSchema/ClientAbort") {
+  static annotation = this.serviceMap(true).pipe(
+    ServiceMap.add(Cause.StackTrace, {
+      name: "ClientAbort",
+      stack: constUndefined,
+      parent: undefined
+    })
+  )
+}

package/src/unstable/rpc/RpcSerialization.ts

@@ -107,11 +107,7 @@ export const jsonRpc = (options?: {
           return decodeJsonRpcRaw(decoded, batches)
         },
         encode: (response) => {
-          if (Array.isArray(response)) {
-            if (response.length === 0) return undefined
-            return JSON.stringify(response.map(encodeJsonRpcMessage))
-          }
-          const encoded = encodeJsonRpcRaw(response as any, batches)
+          const encoded = encodeJsonRpcResponse(response as any, batches)
           return encoded && JSON.stringify(encoded)
         }
       }
@@ -146,10 +142,7 @@ export const ndJsonRpc = (options?: {
           return messages
         },
         encode: (response) => {
-          if (Array.isArray(response)) {
-            return parser.encode(response.map(encodeJsonRpcMessage))
-          }
-          const encoded = encodeJsonRpcRaw(response as any, batches)
+          const encoded = encodeJsonRpcResponse(response as any, batches)
           return encoded && parser.encode(encoded)
         }
       })
@@ -171,6 +164,7 @@ function decodeJsonRpcRaw(
     const messages: Array<RpcMessage.FromClientEncoded | RpcMessage.FromServerEncoded> = []
     for (let i = 0; i < decoded.length; i++) {
       const message = decodeJsonRpcMessage(decoded[i])
+      messages.push(message)
       if (message._tag === "Request") {
         batch.size++
         batches.set(message.id, batch)
@@ -263,6 +257,47 @@ function encodeJsonRpcRaw(
   return encodeJsonRpcMessage(response)
 }
 
+function encodeJsonRpcResponse(
+  response:
+    | RpcMessage.FromServerEncoded
+    | RpcMessage.FromClientEncoded
+    | Array<RpcMessage.FromServerEncoded | RpcMessage.FromClientEncoded>,
+  batches: Map<string, {
+    readonly size: number
+    readonly responses: Map<string, RpcMessage.FromServerEncoded>
+  }>
+) {
+  if (Array.isArray(response) === false) {
+    return encodeJsonRpcRaw(response, batches)
+  }
+  if (response.length === 0) {
+    return undefined
+  }
+  const encoded: Array<JsonRpcMessage | Array<JsonRpcMessage>> = []
+  for (let i = 0; i < response.length; i++) {
+    const current = encodeJsonRpcRaw(response[i], batches)
+    if (current !== undefined) {
+      encoded.push(current)
+    }
+  }
+  if (encoded.length === 0) {
+    return undefined
+  }
+  if (encoded.length === 1) {
+    return encoded[0]
+  }
+  const messages: Array<JsonRpcMessage> = []
+  for (let i = 0; i < encoded.length; i++) {
+    const current = encoded[i]
+    if (Array.isArray(current)) {
+      messages.push(...current)
+    } else {
+      messages.push(current)
+    }
+  }
+  return messages
+}
+
 function encodeJsonRpcMessage(response: RpcMessage.FromServerEncoded | RpcMessage.FromClientEncoded): JsonRpcMessage {
   switch (response._tag) {
     case "Request":

package/src/unstable/rpc/RpcServer.ts

@@ -8,6 +8,7 @@ import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
 import * as Fiber from "../../Fiber.ts"
 import { constant, constTrue, constVoid, identity } from "../../Function.ts"
+import { reportCauseUnsafe } from "../../internal/effect.ts"
 import * as Latch from "../../Latch.ts"
 import * as Layer from "../../Layer.ts"
 import type * as Option from "../../Option.ts"
@@ -174,17 +175,16 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
           }
           case "Interrupt": {
             const fiber = client.fibers.get(message.requestId)
-            return fiber
-              ? Effect.forkDetach(
-                Fiber.interruptAs(fiber, fiberIdClientInterrupt),
-                { startImmediately: true }
-              )
-              : options.onFromServer({
-                _tag: "Exit",
-                clientId,
-                requestId: message.requestId,
-                exit: Exit.interrupt()
-              })
+            if (fiber) {
+              fiber.interruptUnsafe(requestFiber.id, RpcSchema.ClientAbort.annotation)
+              return Effect.void
+            }
+            return options.onFromServer({
+              _tag: "Exit",
+              clientId,
+              requestId: message.requestId,
+              exit: Exit.interrupt()
+            })
           }
           case "Eof": {
             client.ended = true
@@ -273,6 +273,9 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
           requestId: request.id,
           exit
         })
+      if (exit._tag === "Failure") {
+        reportCauseUnsafe(Fiber.getCurrent()!, exit.cause)
+      }
       return close ? Effect.ensuring(write, close) : write
     })
     if (enableTracing) {
@@ -1278,14 +1281,6 @@ export const layerProtocolWorkerRunner: Layer.Layer<
   WorkerRunner.WorkerRunnerPlatform
 > = Layer.effect(Protocol)(makeProtocolWorkerRunner)
 
-/**
- * Fiber id used to indicate client induced interrupts
- *
- * @since 4.0.0
- * @category Interruption
- */
-export const fiberIdClientInterrupt = -499
-
 // internal
 
 const makeSocketProtocol: Effect.Effect<

package/src/unstable/workflow/WorkflowEngine.ts

@@ -4,7 +4,10 @@
 import type * as Cause from "../../Cause.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
+import * as Fiber from "../../Fiber.ts"
+import * as FiberMap from "../../FiberMap.ts"
 import * as Latch from "../../Latch.ts"
+import * as Layer from "../../Layer.ts"
 import * as Option from "../../Option.ts"
 import * as Schedule from "../../Schedule.ts"
 import * as Schema from "../../Schema.ts"
@@ -498,4 +501,179 @@ const defaultRetrySchedule = Schedule.exponential(200, 1.5).pipe(
   Schedule.either(Schedule.spaced(30000))
 )
 
+/**
+ * @since 4.0.0
+ * @category Layers
+ */
+export const layer: Layer.Layer<WorkflowEngine> = Layer.effect(WorkflowEngine)(
+  Effect.gen(function*() {
+    const scope = yield* Effect.scope
+
+    const workflows = new Map<string, {
+      readonly workflow: Workflow.Any
+      readonly execute: (
+        payload: object,
+        executionId: string
+      ) => Effect.Effect<unknown, unknown, WorkflowInstance | WorkflowEngine>
+      readonly scope: Scope.Scope
+    }>()
+
+    type ExecutionState = {
+      readonly payload: object
+      readonly execute: (
+        payload: object,
+        executionId: string
+      ) => Effect.Effect<unknown, unknown, WorkflowInstance | WorkflowEngine>
+      readonly parent: string | undefined
+      instance: WorkflowInstance["Service"]
+      fiber: Fiber.Fiber<Workflow.Result<unknown, unknown>> | undefined
+    }
+    const executions = new Map<string, ExecutionState>()
+
+    type ActivityState = {
+      exit: Exit.Exit<Workflow.Result<unknown, unknown>> | undefined
+    }
+    const activities = new Map<string, ActivityState>()
+
+    const resume = Effect.fnUntraced(function*(executionId: string): Effect.fn.Return<void> {
+      const state = executions.get(executionId)
+      if (!state) return
+      const exit = state.fiber?.pollUnsafe()
+      if (exit && exit._tag === "Success" && exit.value._tag === "Complete") {
+        return
+      } else if (state.fiber && !exit) {
+        return
+      }
+
+      const entry = workflows.get(state.instance.workflow.name)!
+      const instance = WorkflowInstance.initial(state.instance.workflow, state.instance.executionId)
+      instance.interrupted = state.instance.interrupted
+      state.instance = instance
+      state.fiber = yield* state.execute(state.payload, state.instance.executionId).pipe(
+        Effect.onExit(() => {
+          if (!instance.interrupted) {
+            return Effect.void
+          }
+          instance.suspended = false
+          return Effect.withFiber((fiber) => Effect.interruptible(Fiber.interrupt(fiber)))
+        }),
+        Workflow.intoResult,
+        Effect.provideService(WorkflowInstance, instance),
+        Effect.provideService(WorkflowEngine, engine),
+        Effect.tap((result) => {
+          if (!state.parent || result._tag !== "Complete") {
+            return Effect.void
+          }
+          return Effect.forkIn(resume(state.parent), scope)
+        }),
+        Effect.forkIn(entry.scope)
+      )
+    })
+
+    const deferredResults = new Map<string, Exit.Exit<any, any>>()
+
+    const clocks = yield* FiberMap.make<string>()
+
+    const engine = makeUnsafe({
+      register: Effect.fnUntraced(function*(workflow, execute) {
+        workflows.set(workflow.name, {
+          workflow,
+          execute,
+          scope: yield* Effect.scope
+        })
+      }),
+      execute: Effect.fnUntraced(function*(workflow, options) {
+        const entry = workflows.get(workflow.name)
+        if (!entry) {
+          return yield* Effect.orDie(Effect.fail(`Workflow ${workflow.name} is not registered`))
+        }
+
+        let state = executions.get(options.executionId)
+        if (!state) {
+          state = {
+            payload: options.payload,
+            execute: entry.execute,
+            instance: WorkflowInstance.initial(workflow, options.executionId),
+            fiber: undefined,
+            parent: options.parent?.executionId
+          }
+          executions.set(options.executionId, state)
+          yield* resume(options.executionId)
+        }
+        if (options.discard) return
+        return (yield* Fiber.join(state.fiber!)) as any
+      }),
+      interrupt: Effect.fnUntraced(function*(_workflow, executionId) {
+        const state = executions.get(executionId)
+        if (!state) return
+        state.instance.interrupted = true
+        yield* resume(executionId)
+      }),
+      resume(_workflow, executionId) {
+        return resume(executionId)
+      },
+      activityExecute: Effect.fnUntraced(function*(activity, attempt) {
+        const instance = yield* WorkflowInstance
+        const activityId = `${instance.executionId}/${activity.name}/${attempt}`
+        let state = activities.get(activityId)
+        if (state) {
+          const exit = state.exit
+          if (exit && exit._tag === "Success" && exit.value._tag === "Suspended") {
+            state.exit = undefined
+          } else if (exit) {
+            return yield* exit
+          }
+        } else {
+          state = { exit: undefined }
+          activities.set(activityId, state)
+        }
+        const activityInstance = WorkflowInstance.initial(instance.workflow, instance.executionId)
+        activityInstance.interrupted = instance.interrupted
+        return yield* activity.executeEncoded.pipe(
+          Workflow.intoResult,
+          Effect.provideService(WorkflowInstance, activityInstance),
+          Effect.onExit((exit) => {
+            state.exit = exit
+            return Effect.void
+          })
+        )
+      }),
+      poll: (_workflow, executionId) =>
+        Effect.suspend(() => {
+          const state = executions.get(executionId)
+          if (!state) {
+            return Effect.succeed(undefined)
+          }
+          const exit = state.fiber?.pollUnsafe()
+          return exit ?? Effect.succeed(undefined)
+        }),
+      deferredResult: Effect.fnUntraced(function*(deferred) {
+        const instance = yield* WorkflowInstance
+        const id = `${instance.executionId}/${deferred.name}`
+        return deferredResults.get(id)
+      }),
+      deferredDone: (options) =>
+        Effect.suspend(() => {
+          const id = `${options.executionId}/${options.deferredName}`
+          if (deferredResults.has(id)) return Effect.void
+          deferredResults.set(id, options.exit)
+          return resume(options.executionId)
+        }),
+      scheduleClock: (workflow, options) =>
+        engine.deferredDone(options.clock.deferred, {
+          workflowName: workflow.name,
+          executionId: options.executionId,
+          deferredName: options.clock.deferred.name,
+          exit: Exit.void
+        }).pipe(
+          Effect.delay(options.clock.duration),
+          FiberMap.run(clocks, `${options.executionId}/${options.clock.name}`, { onlyIfMissing: true }),
+          Effect.asVoid
+        )
+    })
+
+    return engine
+  })
+)
+
 const toJsonExit = Exit.map((value: any) => value ?? null)