effect 4.0.0-beta.5 → 4.0.0-beta.50

package/src/unstable/sql/SqlResolver.ts

@@ -57,9 +57,9 @@ export const request: {
 } = function() {
   if (arguments.length === 1) {
     const resolver = arguments[0]
-    return (payload: any) => Effect.request(SqlRequest(payload), Effect.succeed(resolver))
+    return (payload: any) => Effect.request(SqlRequest(payload), resolver)
   }
-  return Effect.request(SqlRequest(arguments[0]), Effect.succeed(arguments[1]))
+  return Effect.request(SqlRequest(arguments[0]), arguments[1])
 } as any
 
 /**
@@ -104,17 +104,17 @@ export const ordered = <Req extends Schema.Top, Res extends Schema.Top, _, E, R>
     >,
     SqlClient.TransactionConnection["Service"] | undefined
   >({
-    key: (entry) => entry.services.mapUnsafe.get(SqlClient.TransactionConnection.key),
+    key: transactionKey,
     resolver: Effect.fnUntraced(function*(entries) {
       const inputs = yield* partitionRequests(entries, options.Request)
       const results = yield* options.execute(inputs as any).pipe(
-        Effect.provideServices(entries[0].services)
+        Effect.provideContext(entries[0].context)
       )
       if (results.length !== inputs.length) {
-        return yield* Effect.fail(new ResultLengthMismatch({ expected: inputs.length, actual: results.length }))
+        return yield* new ResultLengthMismatch({ expected: inputs.length, actual: results.length })
       }
       const decodedResults = yield* decodeArray(results).pipe(
-        Effect.provideServices(entries[0].services)
+        Effect.provideContext(entries[0].context)
       )
       for (let i = 0; i < entries.length; i++) {
         entries[i].completeUnsafe(Exit.succeed(decodedResults[i]))
@@ -160,15 +160,15 @@ export const grouped = <Req extends Schema.Top, Res extends Schema.Top, K, Row,
     >,
     SqlClient.TransactionConnection["Service"] | undefined
   >({
-    key: (entry) => entry.services.mapUnsafe.get(SqlClient.TransactionConnection.key),
+    key: transactionKey,
     resolver: Effect.fnUntraced(function*(entries) {
       const inputs = yield* partitionRequests(entries, options.Request)
       const resultMap = MutableHashMap.empty<K, Arr.NonEmptyArray<Res["Type"]>>()
       const results = yield* options.execute(inputs as any).pipe(
-        Effect.provideServices(entries[0].services)
+        Effect.provideContext(entries[0].context)
       )
       const decodedResults = yield* decodeResults(results).pipe(
-        Effect.provideServices(entries[0].services)
+        Effect.provideContext(entries[0].context)
       )
       for (let i = 0, len = decodedResults.length; i < len; i++) {
         const result = decodedResults[i]
@@ -226,14 +226,18 @@ export const findById = <Id extends Schema.Top, Res extends Schema.Top, Row, E,
     >,
     SqlClient.TransactionConnection["Service"] | undefined
   >({
-    key: (entry) => entry.services.mapUnsafe.get(SqlClient.TransactionConnection.key),
+    key(entry) {
+      const conn = entry.context.mapUnsafe.get(SqlClient.TransactionConnection.key)
+      if (!conn) return undefined
+      return Equal.byReferenceUnsafe(conn)
+    },
     resolver: Effect.fnUntraced(function*(entries) {
       const [inputs, idMap] = yield* partitionRequestsById(entries, options.Id)
       const results = yield* options.execute(inputs as any).pipe(
-        Effect.provideServices(entries[0].services)
+        Effect.provideContext(entries[0].context)
       )
       const decodedResults = yield* decodeResults(results).pipe(
-        Effect.provideServices(entries[0].services)
+        Effect.provideContext(entries[0].context)
       )
       for (let i = 0; i < decodedResults.length; i++) {
         const result = decodedResults[i]
@@ -279,11 +283,11 @@ const void_ = <Req extends Schema.Top, _, E, R>(
     >,
     SqlClient.TransactionConnection["Service"] | undefined
   >({
-    key: (entry) => entry.services.mapUnsafe.get(SqlClient.TransactionConnection.key),
+    key: transactionKey,
     resolver: Effect.fnUntraced(function*(entries) {
       const inputs = yield* partitionRequests(entries, options.Request)
       yield* options.execute(inputs as any).pipe(
-        Effect.provideServices(entries[0].services)
+        Effect.provideContext(entries[0].context)
       )
       for (let i = 0; i < entries.length; i++) {
         entries[i].completeUnsafe(Exit.void)
@@ -322,7 +326,7 @@ const partitionRequests = function*<In, A, E, R, InE>(
 
   for (let i = 0; i < len; i++) {
     entry = requests[i]
-    yield (Effect.provideServices(handle(encode(entry.request.payload)), entry.services) as Effect.Effect<void>)
+    yield (Effect.provideContext(handle(encode(entry.request.payload)), entry.context) as Effect.Effect<void>)
   }
 
   return inputs
@@ -348,9 +352,15 @@ const partitionRequestsById = function*<In, A, E, R, InE>(
 
   for (let i = 0; i < len; i++) {
     entry = requests[i]
-    yield (Effect.provideServices(handle(encode(entry.request.payload)), entry.services) as Effect.Effect<void>)
+    yield (Effect.provideContext(handle(encode(entry.request.payload)), entry.context) as Effect.Effect<void>)
     MutableHashMap.set(byIdMap, entry.request.payload, entry)
   }
 
   return [inputs, byIdMap] as const
 }
+
+function transactionKey<A>(entry: Request.Entry<A>): SqlClient.TransactionConnection["Service"] | undefined {
+  const conn = entry.context.mapUnsafe.get(SqlClient.TransactionConnection.key)
+  if (!conn) return undefined
+  return Equal.byReferenceUnsafe(conn)
+}

package/src/unstable/sql/SqlSchema.ts

@@ -13,7 +13,7 @@ import * as Schema from "../../Schema.ts"
  * @since 4.0.0
  * @category constructor
  */
-export const findMany = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
+export const findAll = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
   options: {
     readonly Request: Req
     readonly Result: Res
@@ -21,25 +21,41 @@ export const findMany = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
   }
 ) => {
   const encodeRequest = Schema.encodeEffect(options.Request)
-  const decode = Schema.decodeUnknownEffect(Schema.Array(options.Result))
+  const decode = Schema.decodeUnknownEffect(Schema.mutable(Schema.Array(options.Result)))
   return (
-    request: Req["Encoded"]
+    request: Req["Type"]
+  ): Effect.Effect<
+    Array<Res["Type"]>,
+    E | Schema.SchemaError,
+    Req["EncodingServices"] | Res["DecodingServices"] | R
+  > => Effect.flatMap(Effect.flatMap(encodeRequest(request), options.execute), decode)
+}
+
+/**
+ * Run a sql query with a request schema and a result schema.
+ *
+ * @since 4.0.0
+ * @category constructor
+ */
+export const findNonEmpty = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
+  options: {
+    readonly Request: Req
+    readonly Result: Res
+    readonly execute: (request: Req["Encoded"]) => Effect.Effect<ReadonlyArray<unknown>, E, R>
+  }
+) => {
+  const find = findAll(options)
+  return (
+    request: Req["Type"]
   ): Effect.Effect<
     Arr.NonEmptyArray<Res["Type"]>,
     E | Schema.SchemaError | Cause.NoSuchElementError,
     Req["EncodingServices"] | Res["DecodingServices"] | R
   > =>
-    Effect.flatMap(
-      Effect.flatMap(encodeRequest(request), options.execute),
-      (results): Effect.Effect<
-        Arr.NonEmptyArray<Res["Type"]>,
-        Schema.SchemaError | Cause.NoSuchElementError,
-        Req["EncodingServices"] | Res["DecodingServices"]
-      > =>
-        Arr.isReadonlyArrayNonEmpty(results)
-          ? decode(results) as Effect.Effect<Arr.NonEmptyArray<Res["Type"]>, Schema.SchemaError>
-          : Effect.fail(new Cause.NoSuchElementError())
-    )
+    Effect.flatMap(find(request), (results) =>
+      Arr.isArrayNonEmpty(results)
+        ? Effect.succeed(results)
+        : Effect.fail(new Cause.NoSuchElementError()))
 }
 
 const void_ = <Req extends Schema.Top, E, R>(
@@ -65,7 +81,7 @@ export {
 }
 
 /**
- * Run a sql query with a request schema and a result schema and return the first result, if any.
+ * Run a sql query with a request schema and a result schema and return the first result.
  *
  * @since 4.0.0
  * @category constructor
@@ -82,17 +98,17 @@ export const findOne = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
   return (
     request: Req["Type"]
   ): Effect.Effect<
-    Option.Option<Res["Type"]>,
-    E | Schema.SchemaError,
+    Res["Type"],
+    E | Schema.SchemaError | Cause.NoSuchElementError,
     R | Req["EncodingServices"] | Res["DecodingServices"]
   > =>
     Effect.flatMap(
       Effect.flatMap(encodeRequest(request), options.execute),
       (arr): Effect.Effect<
-        Option.Option<Res["Type"]>,
-        Schema.SchemaError,
+        Res["Type"],
+        Schema.SchemaError | Cause.NoSuchElementError,
         Req["EncodingServices"] | Res["DecodingServices"]
-      > => Arr.isReadonlyArrayNonEmpty(arr) ? Effect.asSome(decode(arr[0])) : Effect.succeedNone
+      > => Arr.isReadonlyArrayNonEmpty(arr) ? decode(arr[0]) : Effect.fail(new Cause.NoSuchElementError())
     )
 }
 
@@ -102,7 +118,7 @@ export const findOne = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
  * @since 4.0.0
  * @category constructor
  */
-export const single = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
+export const findOneOption = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
   options: {
     readonly Request: Req
     readonly Result: Res
@@ -114,16 +130,16 @@ export const single = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
   return (
     request: Req["Type"]
   ): Effect.Effect<
-    Res["Type"],
-    E | Schema.SchemaError | Cause.NoSuchElementError,
+    Option.Option<Res["Type"]>,
+    E | Schema.SchemaError,
     R | Req["EncodingServices"] | Res["DecodingServices"]
   > =>
     Effect.flatMap(
       Effect.flatMap(encodeRequest(request), options.execute),
       (arr): Effect.Effect<
-        Res["Type"],
-        Schema.SchemaError | Cause.NoSuchElementError,
+        Option.Option<Res["Type"]>,
+        Schema.SchemaError,
         Req["EncodingServices"] | Res["DecodingServices"]
-      > => Arr.isReadonlyArrayNonEmpty(arr) ? decode(arr[0]) : Effect.fail(new Cause.NoSuchElementError())
+      > => Arr.isReadonlyArrayNonEmpty(arr) ? Effect.asSome(decode(arr[0])) : Effect.succeedNone
     )
 }

package/src/unstable/sql/Statement.ts

@@ -2,6 +2,7 @@
  * @since 4.0.0
  */
 import { Clock } from "../../Clock.ts"
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import type * as Fiber from "../../Fiber.ts"
 import { constUndefined } from "../../Function.ts"
@@ -11,7 +12,6 @@ import * as internalEffect from "../../internal/effect.ts"
 import type { Pipeable } from "../../Pipeable.ts"
 import { hasProperty } from "../../Predicate.ts"
 import { TracerTimingEnabled } from "../../References.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
 import type * as Tracer from "../../Tracer.ts"
 import type { Acquirer, Connection, Row } from "./SqlConnection.ts"
@@ -76,7 +76,7 @@ export type Transformer = (
  * @category transformer
  * @since 4.0.0
  */
-export const CurrentTransformer = ServiceMap.Reference<Transformer | undefined>("effect/sql/CurrentTransformer", {
+export const CurrentTransformer = Context.Reference<Transformer | undefined>("effect/sql/CurrentTransformer", {
   defaultValue: constUndefined
 })
 
@@ -1124,7 +1124,6 @@ const makeUnsafe = <A = Row>(
 }
 
 // TODO: figure out why these diagnostics are emitted
-// @effect-diagnostics-next-line missingEffectContext:off missingEffectError:off
 const StatementProto: Omit<
   StatementImpl<any>,
   "segments" | "acquirer" | "compiler" | "spanAttributes" | "transformRows"

package/src/unstable/workers/Transferable.ts

@@ -1,17 +1,17 @@
 /**
  * @since 1.0.0
  */
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import { dual } from "../../Function.ts"
 import * as Schema from "../../Schema.ts"
 import * as Getter from "../../SchemaGetter.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 
 /**
  * @since 1.0.0
  * @category models
  */
-export class Collector extends ServiceMap.Service<Collector, {
+export class Collector extends Context.Service<Collector, {
   readonly addAll: (
     _: Iterable<globalThis.Transferable>
   ) => Effect.Effect<void>
@@ -60,8 +60,8 @@ export const makeCollector: Effect.Effect<Collector["Service"]> = Effect.sync(ma
 export const addAll = (
   tranferables: Iterable<globalThis.Transferable>
 ): Effect.Effect<void> =>
-  Effect.servicesWith((services) => {
-    const collector = ServiceMap.getOrUndefined(services, Collector)
+  Effect.contextWith((services) => {
+    const collector = Context.getOrUndefined(services, Collector)
     if (!collector) return Effect.void
     collector.addAllUnsafe(tranferables)
     return Effect.void
@@ -75,8 +75,8 @@ export const getterAddAll = <A>(
   f: (_: A) => Iterable<globalThis.Transferable>
 ): Getter.Getter<A, A> =>
   Getter.transformOrFail((e: A) =>
-    Effect.servicesWith((services) => {
-      const collector = ServiceMap.getOrUndefined(services, Collector)
+    Effect.contextWith((services) => {
+      const collector = Context.getOrUndefined(services, Collector)
       if (!collector) return Effect.succeed(e)
       collector.addAllUnsafe(f(e))
       return Effect.succeed(e)
@@ -89,8 +89,8 @@ export const getterAddAll = <A>(
  */
 export interface Transferable<S extends Schema.Top> extends
   Schema.decodeTo<
-    Schema.toType<S["~rebuild.out"]>,
-    S["~rebuild.out"]
+    Schema.toType<S["Rebuild"]>,
+    S["Rebuild"]
   >
 {}
 
@@ -115,16 +115,14 @@ export const schema: {
     self: S,
     f: (_: S["Encoded"]) => Iterable<globalThis.Transferable>
   ): Transferable<S> =>
-    self
-      .annotate({
-        serializerJson: () => passthroughLink
+    self.annotate({
+      toCodecJson: () => passthroughLink
+    }).pipe(
+      Schema.decode({
+        decode: Getter.passthrough(),
+        encode: getterAddAll(f)
       })
-      .pipe(
-        Schema.decode({
-          decode: Getter.passthrough(),
-          encode: getterAddAll(f)
-        })
-      )
+    )
 )
 
 const passthroughLink = Schema.link()(Schema.Any, {
@@ -154,7 +152,7 @@ export const MessagePort: Transferable<Schema.declare<MessagePort>> = schema(
  * @since 1.0.0
  * @category schema
  */
-export const Uint8Array: Transferable<Schema.Uint8Array> = schema(
-  Schema.Uint8Array,
+export const Uint8Array: Transferable<Schema.instanceOf<globalThis.Uint8Array<ArrayBuffer>>> = schema(
+  Schema.Uint8Array as any,
   (_) => [_.buffer]
 )

package/src/unstable/workers/Worker.ts

@@ -1,19 +1,20 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import type * as Deferred from "../../Deferred.ts"
 import * as Effect from "../../Effect.ts"
 import * as FiberSet from "../../FiberSet.ts"
+import * as Latch from "../../Latch.ts"
 import * as Layer from "../../Layer.ts"
 import * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import { WorkerError, WorkerSendError } from "./WorkerError.ts"
 
 /**
  * @since 4.0.0
  * @category models
  */
-export class WorkerPlatform extends ServiceMap.Service<WorkerPlatform, {
+export class WorkerPlatform extends Context.Service<WorkerPlatform, {
   readonly spawn: <O = unknown, I = unknown>(
     id: number
   ) => Effect.Effect<Worker<O, I>, WorkerError, Spawner>
@@ -79,10 +80,10 @@ export interface Spawner {
  * @since 4.0.0
  * @category tags
  */
-export const Spawner: ServiceMap.Service<
+export const Spawner: Context.Service<
   Spawner,
   SpawnerFn<unknown>
-> = ServiceMap.Service("effect/workers/Worker/Spawner")
+> = Context.Service("effect/workers/Worker/Spawner")
 
 /**
  * @since 4.0.0
@@ -149,7 +150,7 @@ export const makePlatform = <W>() =>
                   WorkerError | E
                 >().pipe(Scope.provide(scope))
                 const run = yield* FiberSet.runtime(fiberSet)<R>()
-                const ready = Effect.makeLatchUnsafe()
+                const ready = Latch.makeUnsafe()
                 yield* options.listen({
                   port,
                   scope,

package/src/unstable/workers/WorkerRunner.ts

@@ -1,9 +1,9 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import type * as Effect from "../../Effect.ts"
 import type * as Queue from "../../Queue.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type { WorkerError } from "./WorkerError.ts"
 
 /**
@@ -37,6 +37,6 @@ export type PlatformMessage<I> = readonly [request: 0, I] | readonly [close: 1]
  * @since 4.0.0
  * @category models
  */
-export class WorkerRunnerPlatform extends ServiceMap.Service<WorkerRunnerPlatform, {
+export class WorkerRunnerPlatform extends Context.Service<WorkerRunnerPlatform, {
   readonly start: <O = unknown, I = unknown>() => Effect.Effect<WorkerRunner<O, I>, WorkerError>
 }>()("effect/workers/WorkerRunner/WorkerRunnerPlatform") {}

package/src/unstable/workflow/Activity.ts

@@ -3,13 +3,13 @@
  */
 import type { NonEmptyReadonlyArray } from "../../Array.ts"
 import * as Cause from "../../Cause.ts"
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import { dual } from "../../Function.ts"
 import { PipeInspectableProto, YieldableProto } from "../../internal/core.ts"
 import * as Schedule from "../../Schedule.ts"
 import * as Schema from "../../Schema.ts"
 import type { Scope } from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type * as Types from "../../Types.ts"
 import * as DurableDeferred from "./DurableDeferred.ts"
 import { makeHashDigest } from "./internal/crypto.ts"
@@ -39,6 +39,14 @@ export interface Activity<
   readonly successSchema: Success
   readonly errorSchema: Error
   readonly exitSchema: Schema.Exit<Success, Error, Schema.Defect>
+  readonly annotations: Context.Context<never>
+  annotate<I, S>(
+    key: Context.Key<I, S>,
+    value: S
+  ): Activity<Success, Error, R>
+  annotateMerge<I>(
+    annotations: Context.Context<I>
+  ): Activity<Success, Error, R>
   readonly execute: Effect.Effect<
     Success["Type"],
     Error["Type"],
@@ -73,6 +81,7 @@ export interface Any {
   readonly [TypeId]: typeof TypeId
   readonly name: string
   readonly executeEncoded: Effect.Effect<any, any, any>
+  readonly annotations: Context.Context<never>
 }
 
 /**
@@ -101,6 +110,7 @@ export const make = <
   readonly error?: Error | undefined
   readonly execute: Effect.Effect<Success["Type"], Error["Type"], R>
   readonly interruptRetryPolicy?: Schedule.Schedule<any, Cause.Cause<unknown>> | undefined
+  readonly annotations?: Context.Context<never> | undefined
 }): Activity<Success, Error, Exclude<R, WorkflowInstance | WorkflowEngine | Scope>> => {
   const successSchema = options.success ?? (Schema.Void as any as Success)
   const errorSchema = options.error ?? (Schema.Never as any as Error)
@@ -120,6 +130,19 @@ export const make = <
     successSchema,
     errorSchema,
     exitSchema: Schema.Exit(successSchemaJson, errorSchemaJson, Schema.Defect),
+    annotations: options.annotations ?? Context.empty(),
+    annotate(tag: Context.Key<any, any>, value: any) {
+      return make({
+        ...options,
+        annotations: Context.add(self.annotations, tag, value)
+      })
+    },
+    annotateMerge(context: Context.Context<any>) {
+      return make({
+        ...options,
+        annotations: Context.merge(self.annotations, context)
+      })
+    },
     execute: executeWithoutInterrupt,
     executeEncoded: Effect.matchEffect(executeWithoutInterrupt, {
       onFailure: (error) => Effect.flatMap(Effect.orDie(Schema.encodeEffect(errorSchemaJson)(error)), Effect.fail),
@@ -182,7 +205,7 @@ export const retry: {
  * @since 4.0.0
  * @category Attempts
  */
-export const CurrentAttempt = ServiceMap.Reference<number>(
+export const CurrentAttempt = Context.Reference<number>(
   "effect/workflow/Activity/CurrentAttempt",
   { defaultValue: () => 1 }
 )
@@ -240,10 +263,10 @@ export const raceAll = <const Activities extends NonEmptyReadonlyArray<Any>>(
 // internal
 // -----------------------------------------------------------------------------
 
-const EngineTag = ServiceMap.Service<WorkflowEngine, WorkflowEngine["Service"]>(
+const EngineTag = Context.Service<WorkflowEngine, WorkflowEngine["Service"]>(
   "effect/workflow/WorkflowEngine" satisfies typeof WorkflowEngine.key
 )
-const InstanceTag = ServiceMap.Service<WorkflowInstance, WorkflowInstance["Service"]>(
+const InstanceTag = Context.Service<WorkflowInstance, WorkflowInstance["Service"]>(
   "effect/workflow/WorkflowEngine/WorkflowInstance" satisfies typeof WorkflowInstance.key
 )
 

package/src/unstable/workflow/DurableClock.ts

@@ -1,10 +1,10 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import type * as Schema from "../../Schema.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Activity from "./Activity.ts"
 import * as DurableDeferred from "./DurableDeferred.ts"
 import type { WorkflowEngine, WorkflowInstance } from "./WorkflowEngine.ts"
@@ -28,19 +28,19 @@ export interface DurableClock {
  */
 export const make = (options: {
   readonly name: string
-  readonly duration: Duration.DurationInput
+  readonly duration: Duration.Input
 }): DurableClock => ({
   [TypeId]: TypeId,
   name: options.name,
-  duration: Duration.fromDurationInputUnsafe(options.duration),
+  duration: Duration.fromInputUnsafe(options.duration),
   deferred: DurableDeferred.make(`DurableClock/${options.name}`)
 })
 
-const EngineTag = ServiceMap.Service<WorkflowEngine, WorkflowEngine["Service"]>(
+const EngineTag = Context.Service<WorkflowEngine, WorkflowEngine["Service"]>(
   "effect/workflow/WorkflowEngine" satisfies typeof WorkflowEngine.key
 )
 
-const InstanceTag = ServiceMap.Service<
+const InstanceTag = Context.Service<
   WorkflowInstance,
   WorkflowInstance["Service"]
 >(
@@ -54,14 +54,14 @@ const InstanceTag = ServiceMap.Service<
 export const sleep: (
   options: {
     readonly name: string
-    readonly duration: Duration.DurationInput
+    readonly duration: Duration.Input
     /**
      * If the duration is less than or equal to this threshold, the clock will
      * be executed in memory.
      *
      * Defaults to 60 seconds.
      */
-    readonly inMemoryThreshold?: Duration.DurationInput | undefined
+    readonly inMemoryThreshold?: Duration.Input | undefined
   }
 ) => Effect.Effect<
   void,
@@ -69,16 +69,16 @@ export const sleep: (
   WorkflowEngine | WorkflowInstance
 > = Effect.fnUntraced(function*(options: {
   readonly name: string
-  readonly duration: Duration.DurationInput
-  readonly inMemoryThreshold?: Duration.DurationInput | undefined
+  readonly duration: Duration.Input
+  readonly inMemoryThreshold?: Duration.Input | undefined
 }) {
-  const duration = Duration.fromDurationInputUnsafe(options.duration)
+  const duration = Duration.fromInputUnsafe(options.duration)
   if (Duration.isZero(duration)) {
     return
   }
 
   const inMemoryThreshold = options.inMemoryThreshold
-    ? Duration.fromDurationInputUnsafe(options.inMemoryThreshold)
+    ? Duration.fromInputUnsafe(options.inMemoryThreshold)
     : defaultInMemoryThreshold
 
   if (Duration.isLessThanOrEqualTo(duration, inMemoryThreshold)) {

package/src/unstable/workflow/DurableDeferred.ts

@@ -4,14 +4,14 @@
 import type { NonEmptyReadonlyArray } from "../../Array.ts"
 import type * as Brand from "../../Brand.ts"
 import type * as Cause from "../../Cause.ts"
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
-import * as Base64Url from "../../encoding/Base64Url.ts"
+import * as Encoding from "../../Encoding.ts"
 import * as Exit from "../../Exit.ts"
 import { dual } from "../../Function.ts"
-import * as Predicate from "../../Predicate.ts"
+import * as Option from "../../Option.ts"
 import * as Schema from "../../Schema.ts"
 import * as Getter from "../../SchemaGetter.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type * as Activity from "./Activity.ts"
 import * as Workflow from "./Workflow.ts"
 import type { WorkflowEngine, WorkflowInstance } from "./WorkflowEngine.ts"
@@ -91,18 +91,18 @@ export const make = <
   }
 }
 
-const EngineTag = ServiceMap.Service<WorkflowEngine, WorkflowEngine["Service"]>(
+const EngineTag = Context.Service<WorkflowEngine, WorkflowEngine["Service"]>(
   "effect/workflow/WorkflowEngine" satisfies typeof WorkflowEngine.key
 )
 
-const InstanceTag = ServiceMap.Service<
+const InstanceTag = Context.Service<
   WorkflowInstance,
   WorkflowInstance["Service"]
 >(
   "effect/workflow/WorkflowEngine/WorkflowInstance" satisfies typeof WorkflowInstance.key
 )
 
-const CurrentAttempt = ServiceMap.Reference<number>(
+const CurrentAttempt = Context.Reference<number>(
   "effect/workflow/Activity/CurrentAttempt" satisfies typeof Activity.CurrentAttempt.key,
   { defaultValue: () => 1 }
 )
@@ -124,12 +124,12 @@ const await_: <Success extends Schema.Top, Error extends Schema.Top>(
   const instance = yield* InstanceTag
   const exit = yield* Workflow.wrapActivityResult(
     engine.deferredResult(self),
-    Predicate.isUndefined
+    Option.isNone
   )
-  if (exit === undefined) {
+  if (Option.isNone(exit)) {
     return yield* Workflow.suspend(instance)
   }
-  return yield* exit as Exit.Exit<any, any>
+  return yield* exit.value as Exit.Exit<any, any>
 })
 
 export {
@@ -190,10 +190,10 @@ export const into: {
     | Success["DecodingServices"]
     | Error["DecodingServices"]
   > =>
-    Effect.servicesWith(
-      (services: ServiceMap.ServiceMap<WorkflowEngine | WorkflowInstance>) => {
-        const engine = ServiceMap.get(services, EngineTag)
-        const instance = ServiceMap.get(services, InstanceTag)
+    Effect.contextWith(
+      (context: Context.Context<WorkflowEngine | WorkflowInstance>) => {
+        const engine = Context.get(context, EngineTag)
+        const instance = Context.get(context, InstanceTag)
         return Effect.onExit(
           effect,
           Effect.fnUntraced(function*(exit) {
@@ -241,8 +241,8 @@ export const raceAll = <
   return Effect.gen(function*() {
     const engine = yield* EngineTag
     const exit = yield* engine.deferredResult(deferred)
-    if (exit !== undefined) {
-      return yield* Effect.flatten(exit) as Effect.Effect<any, any, any>
+    if (Option.isSome(exit)) {
+      return yield* Effect.flatten(exit.value) as Effect.Effect<any, any, any>
     }
     return yield* into(Effect.raceAll(options.effects), deferred)
   })
@@ -285,7 +285,7 @@ export class TokenParsed extends Schema.Class<TokenParsed>(
    * @since 4.0.0
    */
   get asToken(): Token {
-    return Base64Url.encode(
+    return Encoding.encodeBase64Url(
       JSON.stringify([this.workflowName, this.executionId, this.deferredName])
     ) as Token
   }