effect 4.0.0-beta.43 → 4.0.0-beta.45

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)
@@ -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,20 +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>
@@ -80,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

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,13 +39,13 @@ export interface Activity<
   readonly successSchema: Success
   readonly errorSchema: Error
   readonly exitSchema: Schema.Exit<Success, Error, Schema.Defect>
-  readonly annotations: ServiceMap.ServiceMap<never>
+  readonly annotations: Context.Context<never>
   annotate<I, S>(
-    key: ServiceMap.Key<I, S>,
+    key: Context.Key<I, S>,
     value: S
   ): Activity<Success, Error, R>
   annotateMerge<I>(
-    annotations: ServiceMap.ServiceMap<I>
+    annotations: Context.Context<I>
   ): Activity<Success, Error, R>
   readonly execute: Effect.Effect<
     Success["Type"],
@@ -81,7 +81,7 @@ export interface Any {
   readonly [TypeId]: typeof TypeId
   readonly name: string
   readonly executeEncoded: Effect.Effect<any, any, any>
-  readonly annotations: ServiceMap.ServiceMap<never>
+  readonly annotations: Context.Context<never>
 }
 
 /**
@@ -110,7 +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?: ServiceMap.ServiceMap<never> | 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)
@@ -130,17 +130,17 @@ export const make = <
     successSchema,
     errorSchema,
     exitSchema: Schema.Exit(successSchemaJson, errorSchemaJson, Schema.Defect),
-    annotations: options.annotations ?? ServiceMap.empty(),
-    annotate(tag: ServiceMap.Key<any, any>, value: any) {
+    annotations: options.annotations ?? Context.empty(),
+    annotate(tag: Context.Key<any, any>, value: any) {
       return make({
         ...options,
-        annotations: ServiceMap.add(self.annotations, tag, value)
+        annotations: Context.add(self.annotations, tag, value)
       })
     },
-    annotateMerge(context: ServiceMap.ServiceMap<any>) {
+    annotateMerge(context: Context.Context<any>) {
       return make({
         ...options,
-        annotations: ServiceMap.merge(self.annotations, context)
+        annotations: Context.merge(self.annotations, context)
       })
     },
     execute: executeWithoutInterrupt,
@@ -205,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 }
 )
@@ -263,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"
@@ -36,11 +36,11 @@ export const make = (options: {
   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"]
 >(

package/src/unstable/workflow/DurableDeferred.ts

@@ -4,6 +4,7 @@
 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 Encoding from "../../Encoding.ts"
 import * as Exit from "../../Exit.ts"
@@ -11,7 +12,6 @@ import { dual } from "../../Function.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 }
 )
@@ -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) {

package/src/unstable/workflow/Workflow.ts

@@ -2,6 +2,7 @@
  * @since 4.0.0
  */
 import * as Cause from "../../Cause.ts"
+import * as Context from "../../Context.ts"
 import * as Data from "../../Data.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
@@ -16,7 +17,6 @@ import * as Issue from "../../SchemaIssue.ts"
 import * as Parser from "../../SchemaParser.ts"
 import * as Tranformation from "../../SchemaTransformation.ts"
 import * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type { ExitEncoded } from "../rpc/RpcMessage.ts"
 import { makeHashDigest } from "./internal/crypto.ts"
 import type { WorkflowEngine, WorkflowInstance } from "./WorkflowEngine.ts"
@@ -38,13 +38,13 @@ export interface Workflow<
   readonly payloadSchema: Payload
   readonly successSchema: Success
   readonly errorSchema: Error
-  readonly annotations: ServiceMap.ServiceMap<never>
+  readonly annotations: Context.Context<never>
 
   /**
    * Add an annotation to the workflow.
    */
   annotate<I, S>(
-    key: ServiceMap.Key<I, S>,
+    key: Context.Key<I, S>,
     value: S
   ): Workflow<Name, Payload, Success, Error>
 
@@ -52,7 +52,7 @@ export interface Workflow<
    * Merge multiple annotations into the workflow.
    */
   annotateMerge<I>(
-    annotations: ServiceMap.ServiceMap<I>
+    annotations: Context.Context<I>
   ): Workflow<Name, Payload, Success, Error>
 
   /**
@@ -191,7 +191,7 @@ export interface Any {
   readonly payloadSchema: AnyStructSchema
   readonly successSchema: Schema.Top
   readonly errorSchema: Schema.Top
-  readonly annotations: ServiceMap.ServiceMap<never>
+  readonly annotations: Context.Context<never>
 }
 
 /**
@@ -256,11 +256,11 @@ export type RequirementsHandler<Workflows extends Any> = Workflows extends Workf
     | _Error["EncodingServices"]
   : never
 
-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"]
 >(
@@ -286,7 +286,7 @@ export const make = <
   readonly success?: Success
   readonly error?: Error
   readonly suspendedRetrySchedule?: Schedule.Schedule<any, unknown> | undefined
-  readonly annotations?: ServiceMap.ServiceMap<never>
+  readonly annotations?: Context.Context<never>
 }): Workflow<
   Name,
   Payload extends Schema.Struct.Fields ? Schema.Struct<Payload> : Payload,
@@ -302,22 +302,22 @@ export const make = <
       : Schema.Struct(options.payload as any),
     successSchema: options.success ?? (Schema.Void as any),
     errorSchema: options.error ?? (Schema.Never as any),
-    annotations: options.annotations ?? ServiceMap.empty(),
+    annotations: options.annotations ?? Context.empty(),
     annotate(tag, value) {
       return make({
         ...options,
-        annotations: ServiceMap.add(self.annotations, tag, value)
+        annotations: Context.add(self.annotations, tag, value)
       })
     },
     annotateMerge(context) {
       return make({
         ...options,
-        annotations: ServiceMap.merge(self.annotations, context)
+        annotations: Context.merge(self.annotations, context)
       })
     },
     execute: Effect.fnUntraced(
       function*(fields: any, opts) {
-        const payload = self.payloadSchema.makeUnsafe(fields)
+        const payload = self.payloadSchema.make(fields)
         const engine = yield* EngineTag
         const executionId = yield* makeExecutionId(payload)
         yield* Effect.annotateCurrentSpan({ executionId })
@@ -376,7 +376,7 @@ export const make = <
       ),
     executionId: (payload) =>
       Effect.flatMap(
-        Effect.sync(() => self.payloadSchema.makeUnsafe(payload)),
+        Effect.sync(() => self.payloadSchema.make(payload)),
         makeExecutionId
       ),
     withCompensation
@@ -554,10 +554,10 @@ export const intoResult = <A, E, R>(
   never,
   Exclude<R, Scope.Scope> | WorkflowInstance
 > =>
-  Effect.servicesWith((services: ServiceMap.ServiceMap<WorkflowInstance>) => {
-    const instance = ServiceMap.get(services, InstanceTag)
-    const captureDefects = ServiceMap.get(instance.workflow.annotations, CaptureDefects)
-    const suspendOnFailure = ServiceMap.get(instance.workflow.annotations, SuspendOnFailure)
+  Effect.contextWith((context: Context.Context<WorkflowInstance>) => {
+    const instance = Context.get(context, InstanceTag)
+    const captureDefects = Context.get(instance.workflow.annotations, CaptureDefects)
+    const suspendOnFailure = Context.get(instance.workflow.annotations, SuspendOnFailure)
     return effect.pipe(
       // so we can use external interruption to suspend the workflow
       Effect.forkChild({ startImmediately: true }),
@@ -604,8 +604,8 @@ export const wrapActivityResult = <A, E, R>(
   effect: Effect.Effect<A, E, R>,
   isSuspend: (value: A) => boolean
 ): Effect.Effect<A, E, R | WorkflowInstance> =>
-  Effect.servicesWith((services: ServiceMap.ServiceMap<WorkflowInstance>) => {
-    const instance = ServiceMap.get(services, InstanceTag)
+  Effect.contextWith((context: Context.Context<WorkflowInstance>) => {
+    const instance = Context.get(context, InstanceTag)
     const state = instance.activityState
     if (instance.suspended) {
       return waitForZero(instance).pipe(
@@ -694,8 +694,8 @@ export const addFinalizer: <R>(
   f: (exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void, never, R>
 ) {
   const scope = (yield* InstanceTag).scope
-  const services = yield* Effect.services<R>()
-  yield* Scope.addFinalizerExit(scope, (exit) => Effect.provideServices(f(exit), services))
+  const services = yield* Effect.context<R>()
+  yield* Scope.addFinalizerExit(scope, (exit) => Effect.provideContext(f(exit), services))
 })
 
 /**
@@ -772,7 +772,7 @@ export const suspend = (instance: WorkflowInstance["Service"]): Effect.Effect<ne
  * @since 4.0.0
  * @category Annotations
  */
-export const CaptureDefects = ServiceMap.Reference<boolean>(
+export const CaptureDefects = Context.Reference<boolean>(
   "effect/workflow/Workflow/CaptureDefects",
   {
     defaultValue: constTrue
@@ -789,7 +789,7 @@ export const CaptureDefects = ServiceMap.Reference<boolean>(
  * @since 4.0.0
  * @category Annotations
  */
-export const SuspendOnFailure = ServiceMap.Reference<boolean>(
+export const SuspendOnFailure = Context.Reference<boolean>(
   "effect/workflow/Workflow/SuspendOnFailure",
   {
     defaultValue: constFalse

package/src/unstable/workflow/WorkflowEngine.ts

@@ -2,6 +2,7 @@
  * @since 4.0.0
  */
 import type * as Cause from "../../Cause.ts"
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
 import * as Fiber from "../../Fiber.ts"
@@ -12,7 +13,6 @@ import * as Option from "../../Option.ts"
 import * as Schedule from "../../Schedule.ts"
 import * as Schema from "../../Schema.ts"
 import * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type * as Activity from "./Activity.ts"
 import type { DurableClock } from "./DurableClock.ts"
 import type * as DurableDeferred from "./DurableDeferred.ts"
@@ -22,7 +22,7 @@ import * as Workflow from "./Workflow.ts"
  * @since 4.0.0
  * @category Services
  */
-export class WorkflowEngine extends ServiceMap.Service<
+export class WorkflowEngine extends Context.Service<
   WorkflowEngine,
   {
     /**
@@ -199,7 +199,7 @@ export class WorkflowEngine extends ServiceMap.Service<
  * @since 4.0.0
  * @category Services
  */
-export class WorkflowInstance extends ServiceMap.Service<
+export class WorkflowInstance extends Context.Service<
   WorkflowInstance,
   {
     /**
@@ -336,13 +336,13 @@ export interface Encoded {
 export const makeUnsafe = (options: Encoded): WorkflowEngine["Service"] =>
   WorkflowEngine.of({
     register: Effect.fnUntraced(function*(workflow, execute) {
-      const services = yield* Effect.services<WorkflowEngine>()
+      const services = yield* Effect.context<WorkflowEngine>()
       yield* options.register(workflow, (payload, executionId) =>
         Effect.suspend(() =>
           execute(payload, executionId)
         ).pipe(
-          Effect.updateServices(
-            (input) => ServiceMap.merge(services, input) as ServiceMap.ServiceMap<any>
+          Effect.updateContext(
+            (input) => Context.merge(services, input) as Context.Context<any>
           )
         ))
     }),

package/src/unstable/workflow/WorkflowProxyServer.ts

@@ -2,9 +2,9 @@
  * @since 4.0.0
  */
 import type { NonEmptyReadonlyArray } from "../../Array.ts"
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Layer from "../../Layer.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type * as HttpApi from "../httpapi/HttpApi.ts"
 import * as HttpApiBuilder from "../httpapi/HttpApiBuilder.ts"
 import type * as HttpApiGroup from "../httpapi/HttpApiGroup.ts"
@@ -90,8 +90,8 @@ export const layerRpcHandlers = <
   never,
   WorkflowEngine | Workflow.RequirementsHandler<Workflows[number]>
 > =>
-  Layer.effectServices(Effect.gen(function*() {
-    const services = yield* Effect.services<never>()
+  Layer.effectContext(Effect.gen(function*() {
+    const services = yield* Effect.context<never>()
     const prefix = options?.prefix ?? ""
     const handlers = new Map<string, Rpc.Handler<string>>()
     for (const workflow_ of workflows) {
@@ -118,7 +118,7 @@ export const layerRpcHandlers = <
         handler: (payload: any) => workflow.resume(payload.executionId) as any
       } as any)
     }
-    return ServiceMap.makeUnsafe(handlers)
+    return Context.makeUnsafe(handlers)
   }))
 
 /**