@typed/fx 2.0.0-beta.2 → 2.0.0-beta.4

package/src/Fx/combinators/scan.ts

@@ -65,7 +65,7 @@ export const scanEffect: {
   ): Fx<S, E | E2, R | R2> =>
     make<S, E | E2, R | R2>(<RSink>(sink: Sink<S, E | E2, RSink>) =>
       Effect.gen(function* () {
-        const services = yield* Effect.services<R | R2 | RSink>();
+        const services = yield* Effect.context<R | R2 | RSink>();
         yield* sink.onSuccess(initial);
         yield* fx.run(
           sinkLoopEffect(sink, initial, (s, a) =>
@@ -73,7 +73,7 @@ export const scanEffect: {
               f(s, a),
               Effect.catchCause((cause) => sink.onFailure(cause).pipe(Effect.as(s))),
               Effect.map((next) => [next, next] as const),
-              Effect.provideServices(services),
+              Effect.provideContext(services),
             ),
           ),
         );

package/src/Fx/combinators/switchMap.ts

@@ -2,7 +2,7 @@ import * as Effect from "effect/Effect";
 import * as Fiber from "effect/Fiber";
 import { dual } from "effect/Function";
 import * as Scope from "effect/Scope";
-import * as ServiceMap from "effect/ServiceMap";
+import * as Context from "effect/Context";
 import * as SyncronizedRef from "effect/SynchronizedRef";
 import { make as makeSink } from "../../Sink/Sink.js";
 import { make } from "../constructors/make.js";
@@ -28,12 +28,12 @@ export const switchMap: FlatMapLike = dual(
   ): Fx<B, E | E2, R | R2 | Scope.Scope> =>
     make<B, E | E2, R | R2 | Scope.Scope>(
       Effect.fn(function* (sink) {
-        const ctx = yield* Effect.services<R2 | Scope.Scope>();
-        const scope = ServiceMap.get(ctx, Scope.Scope);
+        const ctx = yield* Effect.context<R2 | Scope.Scope>();
+        const scope = Context.get(ctx, Scope.Scope);
         const fiberRef = yield* SyncronizedRef.make<Fiber.Fiber<unknown, never> | null>(null);
 
         const next = (value: A) =>
-          Effect.forkIn(Effect.provideServices(f(value).run(sink), ctx), scope, {
+          Effect.forkIn(Effect.provideContext(f(value).run(sink), ctx), scope, {
             startImmediately: false,
             uninterruptible: false,
           });

package/src/Fx/combinators/unwrap.ts

@@ -10,7 +10,7 @@ import type { Fx } from "../Fx.js";
  * @since 1.0.0
  * @category combinators
  */
-export const unwrap = <A, E, R, E2, R2>(
+export const unwrap = <A = never, E = never, R = never, E2 = never, R2 = never>(
   effect: Effect.Effect<Fx<A, E, R>, E2, R2>,
 ): Fx<A, E | E2, R | R2> =>
   make<A, E | E2, R | R2>((sink) =>

package/src/Fx/constructors/make.ts

@@ -75,7 +75,7 @@ export const callback = <A, E = never, R = never>(
         withEarlyExit(
           sink,
           Effect.fn(function* <RSink = never>(sink: Sink.WithEarlyExit<A, E, RSink>) {
-            const services = yield* Effect.services<R | RSink>();
+            const services = yield* Effect.context<R | RSink>();
             const runFork = Effect.runForkWith(services);
             const controller = new AbortController();
             yield* Scope.addFinalizer(
@@ -94,7 +94,7 @@ export const callback = <A, E = never, R = never>(
             };
 
             const effect = run(emit);
-            if (effect) yield* Scope.addFinalizer(scope, Effect.provideServices(effect, services));
+            if (effect) yield* Scope.addFinalizer(scope, Effect.provideContext(effect, services));
             return yield* Effect.never;
           }),
         ),

package/src/Fx/run/observe.ts

@@ -4,11 +4,11 @@ import {
   callback,
   catchCause,
   failCause,
-  forkChild,
+  forkScoped,
   isEffect,
   matchCauseEffect,
   runForkWith,
-  servicesWith,
+  contextWith,
   sync,
   void as void_,
 } from "effect/Effect";
@@ -45,7 +45,7 @@ export const observe: {
     fx: Fx<A, E, R>,
     f: (value: A) => void | Effect<unknown, E2, R2>,
   ): Effect<unknown, E | E2, R | R2> =>
-    servicesWith((services) =>
+    contextWith((services) =>
       callback<void, E | E2, R | R2>((resume) => {
         const onFailure = (cause: Cause<E | E2>) => sync(() => resume(failCause(cause)));
         const onSuccess = (value: A) => {
@@ -84,7 +84,7 @@ export const drain = <A, E, R>(fx: Fx<A, E, R>): Effect<void, E, R> => observe(f
  * @category runners
  */
 export const drainLayer = <A, E, R>(fx: Fx<A, E, R>): Layer<never, E, Exclude<R, Scope>> =>
-  effectDiscard(forkChild(drain(fx)));
+  effectDiscard(forkScoped(drain(fx)));
 
 /**
  * Observes the values of an `Fx` stream using a callback function and returns a `Layer`.
@@ -110,5 +110,5 @@ export const observeLayer: {
   <A, E, R, E2 = never, R2 = never>(
     fx: Fx<A, E, R>,
     f: (value: A) => void | Effect<unknown, E2, R2>,
-  ): Layer<never, E | E2, Exclude<R | R2, Scope>> => effectDiscard(observe(fx, f)),
+  ): Layer<never, E | E2, Exclude<R | R2, Scope>> => effectDiscard(forkScoped(observe(fx, f))),
 );

package/src/Fx.provide-combinators.test.ts

@@ -1,9 +1,9 @@
 import { assert, describe, it } from "vitest";
 import * as Effect from "effect/Effect";
 import { Fx } from "./index.js";
-import * as ServiceMap from "effect/ServiceMap";
+import * as Context from "effect/Context";
 
-const Foo = ServiceMap.Service<{ readonly n: number }>("Test/Foo");
+const Foo = Context.Service<{ readonly n: number }>("Test/Foo");
 
 describe("Fx provideService", () => {
   it("provides a single service and Fx can use it", () =>

package/src/Push/Push.ts

@@ -11,7 +11,7 @@ import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import { pipeArguments } from "effect/Pipeable";
 import type * as Scope from "effect/Scope";
-import * as ServiceMap from "effect/ServiceMap";
+import * as Context from "effect/Context";
 import * as Fx from "../Fx/index.js";
 import { FxTypeId } from "../Fx/TypeId.js";
 import * as Sink from "../Sink.js";
@@ -68,7 +68,7 @@ export namespace Push {
     Self
   > {
     readonly id: Id;
-    readonly service: ServiceMap.Service<Self, Push<A, E, never, B, E2, never>>;
+    readonly service: Context.Service<Self, Push<A, E, never, B, E2, never>>;
     readonly make: <R = never, R2 = never>(
       sink: Sink.Sink<A, E, R>,
       fx: Fx.Fx<B, E2, R2>,
@@ -201,13 +201,20 @@ export const mapInput: {
     f: (c: C) => Sink.Success<P>,
   ): (
     push: P,
-  ) => Push<Sink.Context<P>, Sink.Error<P>, C, Fx.Fx.Services<P>, Fx.Fx.Error<P>, Fx.Fx.Success<P>>;
+  ) => Push<
+    Sink.Services<P>,
+    Sink.Error<P>,
+    C,
+    Fx.Fx.Services<P>,
+    Fx.Fx.Error<P>,
+    Fx.Fx.Success<P>
+  >;
 
   <P extends Push.Any, C>(
     push: P,
     f: (c: C) => Sink.Sink.Success<P>,
   ): Push<
-    Sink.Sink.Context<P>,
+    Sink.Sink.Services<P>,
     Sink.Sink.Error<P>,
     C,
     Fx.Fx.Services<P>,
@@ -215,7 +222,7 @@ export const mapInput: {
     Fx.Fx.Success<P>
   >;
 } = dual(2, function mapInput<P extends Push.Any, C>(push: P, f: (c: C) => Sink.Success<P>): Push<
-  Sink.Context<P>,
+  Sink.Services<P>,
   Sink.Error<P>,
   C,
   Fx.Fx.Services<P>,
@@ -259,7 +266,14 @@ export const filterInput: {
     f: (a: A) => boolean,
   ): <P extends Push.Any>(
     push: P,
-  ) => Push<Sink.Context<P>, Sink.Error<P>, A, Fx.Fx.Services<P>, Fx.Fx.Error<P>, Fx.Fx.Success<P>>;
+  ) => Push<
+    Sink.Services<P>,
+    Sink.Error<P>,
+    A,
+    Fx.Fx.Services<P>,
+    Fx.Fx.Error<P>,
+    Fx.Fx.Success<P>
+  >;
   <A, E, R, B, E2, R2>(
     push: Push<A, E, R, B, E2, R2>,
     f: (a: A) => boolean,
@@ -308,7 +322,14 @@ export const filterMapInput: {
     f: (c: C) => Option.Option<A>,
   ): <P extends Push.Any>(
     push: P,
-  ) => Push<C, Sink.Error<P>, Sink.Context<P>, Fx.Fx.Success<P>, Fx.Fx.Error<P>, Fx.Fx.Services<P>>;
+  ) => Push<
+    C,
+    Sink.Error<P>,
+    Sink.Services<P>,
+    Fx.Fx.Success<P>,
+    Fx.Fx.Error<P>,
+    Fx.Fx.Services<P>
+  >;
   <A, E, R, B, E2, R2, C>(
     push: Push<A, E, R, B, E2, R2>,
     f: (c: C) => Option.Option<A>,
@@ -1015,7 +1036,7 @@ export const mapAccumEffect: {
 
 export function Service<Self, A, E = never, B = never, E2 = never>() {
   return <const Id extends string>(id: Id): Push.Class<Self, Id, A, E, B, E2> => {
-    const service = ServiceMap.Service<Self, Push<A, E, never, B, E2, never>>(id);
+    const service = Context.Service<Self, Push<A, E, never, B, E2, never>>(id);
 
     // eslint-disable-next-line @typescript-eslint/no-extraneous-class
     return class PushService {
@@ -1028,17 +1049,17 @@ export function Service<Self, A, E = never, B = never, E2 = never>() {
       ): Layer.Layer<Self, never, Exclude<R | R2, Scope.Scope>> =>
         Layer.effect(
           service,
-          Effect.services<R | R2>().pipe(
+          Effect.context<R | R2>().pipe(
             Effect.map((services) =>
               make(
                 Sink.make(
-                  (cause) => Effect.provideServices(sink.onFailure(cause), services),
-                  (value) => Effect.provideServices(sink.onSuccess(value), services),
+                  (cause) => Effect.provideContext(sink.onFailure(cause), services),
+                  (value) => Effect.provideContext(sink.onSuccess(value), services),
                 ),
                 Fx.make(<RSink>(sink: Sink.Sink<B, E2, RSink>) =>
-                  Effect.services<RSink>().pipe(
+                  Effect.context<RSink>().pipe(
                     Effect.flatMap((services2) =>
-                      Effect.provideServices(fx.run(sink), ServiceMap.merge(services, services2)),
+                      Effect.provideContext(fx.run(sink), Context.merge(services, services2)),
                     ),
                   ),
                 ),

package/src/RefSubject/RefArray.ts

@@ -14,7 +14,7 @@ import type * as Order from "effect/Order";
 import type * as Scope from "effect/Scope";
 import type * as Fx from "../Fx/index.js";
 import * as RefSubject from "./RefSubject.js";
-import { Filter, Result } from "effect";
+import { Result } from "effect";
 
 /**
  * A RefArray is a RefSubject that is specialized over an array of values.
@@ -211,10 +211,7 @@ export const insertAt: {
   <A, E, R>(ref: RefArray<A, E, R>, index: number, a: A): Effect.Effect<ReadonlyArray<A>, E, R>;
 } = dual(3, function insertAt<A, E, R>(ref: RefArray<A, E, R>, index: number, a: A) {
   return RefSubject.update(ref, (as) =>
-    Option.getOrElse(Option.fromUndefinedOr(ReadonlyArray.insertAt(as, index, a)), () => [
-      ...as,
-      a,
-    ]),
+    Option.getOrElse(ReadonlyArray.insertAt(as, index, a), () => [...as, a]),
   );
 });
 
@@ -292,7 +289,9 @@ export const modifyAt: {
     f: (a: A) => A,
   ): Effect.Effect<ReadonlyArray<A>, E, R>;
 } = dual(3, function modifyAt<A, E, R>(ref: RefArray<A, E, R>, index: number, f: (a: A) => A) {
-  return RefSubject.update(ref, (values) => ReadonlyArray.modify(values, index, f) || values);
+  return RefSubject.update(ref, (values) =>
+    Option.getOrElse(ReadonlyArray.modify(values, index, f), () => values),
+  );
 });
 
 /**
@@ -373,7 +372,9 @@ export const replaceAt: {
   <A>(index: number, a: A): <E, R>(ref: RefArray<A, E, R>) => Effect.Effect<ReadonlyArray<A>, E, R>;
   <A, E, R>(ref: RefArray<A, E, R>, index: number, a: A): Effect.Effect<ReadonlyArray<A>, E, R>;
 } = dual(3, function replaceAt<A, E, R>(ref: RefArray<A, E, R>, index: number, a: A) {
-  return RefSubject.update(ref, (values) => ReadonlyArray.replace(values, index, a) || values);
+  return RefSubject.update(ref, (values) =>
+    Option.getOrElse(ReadonlyArray.replace(values, index, a), () => values),
+  );
 });
 
 /**

package/src/RefSubject/RefChunk.ts

@@ -8,6 +8,7 @@ import type * as Effect from "effect/Effect";
 import { equals } from "effect/Equal";
 import type { Equivalence } from "effect/Equivalence";
 import { dual } from "effect/Function";
+import * as Option from "effect/Option";
 import type * as Order from "effect/Order";
 import type * as Scope from "effect/Scope";
 import type * as Fx from "../Fx/index.js";
@@ -183,7 +184,9 @@ export const modifyAt: {
     f: (a: A) => A,
   ): Effect.Effect<Chunk.Chunk<A>, E, R>;
 } = dual(3, function modifyAt<A, E, R>(ref: RefChunk<A, E, R>, index: number, f: (a: A) => A) {
-  return RefSubject.update(ref, (chunk) => Chunk.modify(chunk, index, f) ?? chunk);
+  return RefSubject.update(ref, (chunk) =>
+    Option.getOrElse(Chunk.modify(chunk, index, f), () => chunk),
+  );
 });
 
 /**
@@ -195,7 +198,9 @@ export const replaceAt: {
   <A>(index: number, a: A): <E, R>(ref: RefChunk<A, E, R>) => Effect.Effect<Chunk.Chunk<A>, E, R>;
   <A, E, R>(ref: RefChunk<A, E, R>, index: number, a: A): Effect.Effect<Chunk.Chunk<A>, E, R>;
 } = dual(3, function replaceAt<A, E, R>(ref: RefChunk<A, E, R>, index: number, a: A) {
-  return RefSubject.update(ref, (chunk) => Chunk.replace(chunk, index, a) ?? chunk);
+  return RefSubject.update(ref, (chunk) =>
+    Option.getOrElse(Chunk.replace(chunk, index, a), () => chunk),
+  );
 });
 
 /**

package/src/RefSubject/RefDateTime.test.ts

@@ -10,21 +10,21 @@ describe("RefDateTime", () => {
       const value = DateTime.nowUnsafe();
       const ref = yield* RefDateTime.make(value);
       const current = yield* ref;
-      expect(current.epochMillis).toBe(value.epochMillis);
+      expect(DateTime.toEpochMillis(current)).toBe(DateTime.toEpochMillis(value));
     }).pipe(Effect.scoped, Effect.runPromise));
 
   it("adds duration", () =>
     Effect.gen(function* () {
       const ref = yield* RefDateTime.make(DateTime.makeUnsafe(0));
       const result = yield* RefDateTime.addDuration(ref, Duration.seconds(5));
-      expect(result.epochMillis).toBe(5000);
+      expect(DateTime.toEpochMillis(result)).toBe(5000);
     }).pipe(Effect.scoped, Effect.runPromise));
 
   it("subtracts duration", () =>
     Effect.gen(function* () {
       const ref = yield* RefDateTime.make(DateTime.makeUnsafe(10000));
       const result = yield* RefDateTime.subtractDuration(ref, Duration.seconds(3));
-      expect(result.epochMillis).toBe(7000);
+      expect(DateTime.toEpochMillis(result)).toBe(7000);
     }).pipe(Effect.scoped, Effect.runPromise));
 
   it("gets epoch milliseconds", () =>

package/src/RefSubject/RefDateTime.ts

@@ -183,10 +183,7 @@ export const subtractDuration: {
     ref: RefDateTime<E, R>,
     duration: Duration.Input,
   ): RefSubject.Computed<DateTime.DateTime, E, R>;
-} = dual(2, function subtractDuration<
-  E,
-  R,
->(ref: RefDateTime<E, R>, duration: Duration.Input) {
+} = dual(2, function subtractDuration<E, R>(ref: RefDateTime<E, R>, duration: Duration.Input) {
   return RefSubject.map(ref, (self) => DateTime.subtractDuration(self, duration));
 });
 
@@ -196,7 +193,7 @@ export const subtractDuration: {
  * @category computed
  */
 export const epochMillis = <E, R>(ref: RefDateTime<E, R>): RefSubject.Computed<number, E, R> =>
-  RefSubject.map(ref, (self) => self.epochMillis);
+  RefSubject.map(ref, (self) => DateTime.toEpochMillis(self));
 
 /**
  * Format the current state of a RefDateTime.

package/src/RefSubject/RefGraph.ts

@@ -7,7 +7,6 @@ import type * as Effect from "effect/Effect";
 import { equals } from "effect/Equal";
 import { dual } from "effect/Function";
 import * as Graph from "effect/Graph";
-import * as Option from "effect/Option";
 import type * as Scope from "effect/Scope";
 import type * as Fx from "../Fx/index.js";
 import * as RefSubject from "./RefSubject.js";
@@ -596,7 +595,7 @@ export const getEdge: {
   Err,
   R,
 >(ref: RefGraph<N, E, T, Err, R>, edgeIndex: Graph.EdgeIndex) {
-  return RefSubject.filterMap(ref, (g) => Option.fromUndefinedOr(Graph.getEdge(g, edgeIndex)));
+  return RefSubject.filterMap(ref, (g) => Graph.getEdge(g, edgeIndex));
 });
 
 /**
@@ -621,7 +620,7 @@ export const findNode: {
   Err,
   R,
 >(ref: RefGraph<N, E, T, Err, R>, predicate: (data: N) => boolean) {
-  return RefSubject.filterMap(ref, (g) => Option.fromUndefinedOr(Graph.findNode(g, predicate)));
+  return RefSubject.filterMap(ref, (g) => Graph.findNode(g, predicate));
 });
 
 /**
@@ -646,5 +645,5 @@ export const findEdge: {
   Err,
   R,
 >(ref: RefGraph<N, E, T, Err, R>, predicate: (edge: E) => boolean) {
-  return RefSubject.filterMap(ref, (g) => Option.fromUndefinedOr(Graph.findEdge(g, predicate)));
+  return RefSubject.filterMap(ref, (g) => Graph.findEdge(g, predicate));
 });

package/src/RefSubject/RefHashMap.ts

@@ -5,7 +5,7 @@
 
 import type * as Effect from "effect/Effect";
 import { equals } from "effect/Equal";
-import { dual, flow } from "effect/Function";
+import { dual } from "effect/Function";
 import * as HashMap from "effect/HashMap";
 import * as Option from "effect/Option";
 import type * as Scope from "effect/Scope";
@@ -470,5 +470,5 @@ export const findFirst: {
   E,
   R,
 >(ref: RefHashMap<K, V, E, R>, predicate: (value: V, key: K) => boolean) {
-  return RefSubject.filterMap(ref, flow(HashMap.findFirst(predicate), Option.fromUndefinedOr));
+  return RefSubject.filterMap(ref, (g) => HashMap.findFirst(g, predicate));
 });

package/src/RefSubject/RefRecord.ts

@@ -100,7 +100,7 @@ export const modify: {
   E,
   R,
 >(ref: RefRecord<K, V, E, R>, key: K, f: (v: V) => V) {
-  return RefSubject.update(ref, (r) => Record.modify(r, key, f) ?? r);
+  return RefSubject.update(ref, (r) => Option.getOrElse(Record.modify(r, key, f), () => r));
 });
 
 /**
@@ -124,7 +124,7 @@ export const replace: {
   E,
   R,
 >(ref: RefRecord<K, V, E, R>, key: K, value: V) {
-  return RefSubject.update(ref, (r) => Record.replace(r, key, value) ?? r);
+  return RefSubject.update(ref, (r) => Option.getOrElse(Record.replace(r, key, value), () => r));
 });
 
 /**
@@ -592,7 +592,7 @@ export const findFirst: {
   E,
   R,
 >(ref: RefRecord<K, V, E, R>, predicate: (value: V, key: K) => boolean) {
-  return RefSubject.filterMap(ref, (r) => Option.fromNullishOr(Record.findFirst(r, predicate)));
+  return RefSubject.filterMap(ref, (r) => Record.findFirst(r, predicate));
 });
 
 /**
@@ -612,8 +612,10 @@ export const pop: {
   ): RefSubject.Filtered<[V, Record.ReadonlyRecord<K, V>], E, R>;
 } = dual(2, function pop<K extends string, V, E, R>(ref: RefRecord<K, V, E, R>, key: K) {
   return RefSubject.filterMap(ref, (r) => {
-    const result = Record.pop(r, key);
-    if (result === undefined) return Option.none();
-    return Option.some([result[0], result[1] as Record.ReadonlyRecord<K, V>]);
+    return Option.map(
+      Record.pop(r, key),
+      ([value, next]) =>
+        [value, next as Record.ReadonlyRecord<K, V>] as [V, Record.ReadonlyRecord<K, V>],
+    );
   });
 });

package/src/RefSubject/RefSubject.ts

@@ -16,7 +16,7 @@ import { sum } from "effect/Number";
 import * as Option from "effect/Option";
 import { pipeArguments } from "effect/Pipeable";
 import * as Scope from "effect/Scope";
-import * as ServiceMap from "effect/ServiceMap";
+import * as Context from "effect/Context";
 import * as Stream from "effect/Stream";
 import { compact as fxCompact } from "../Fx/combinators/compact.js";
 import { continueWith } from "../Fx/combinators/continueWith.js";
@@ -291,7 +291,7 @@ export declare namespace RefSubject {
   export interface Service<Self, Id extends string, A, E> extends RefSubject<A, E, Self> {
     readonly id: Id;
 
-    readonly service: ServiceMap.Service<Self, RefSubject<A, E>>;
+    readonly service: Context.Service<Self, RefSubject<A, E>>;
 
     readonly make: <R = never>(
       value: A | Effect.Effect<A, E, R> | Fx<A, E, R>,
@@ -307,14 +307,12 @@ export declare namespace RefSubject {
     new (): RefSubject.Service<Self, Id, A, E>;
   }
 }
-export const CurrentComputedBehavior = ServiceMap.Reference("@typed/fx/CurrentComputedBehavior", {
+export const CurrentComputedBehavior = Context.Reference("@typed/fx/CurrentComputedBehavior", {
   defaultValue: (): "one" | "multiple" => "multiple",
 });
 
-const checkIsMultiple = (
-  ctx: ServiceMap.ServiceMap<any>,
-): ctx is ServiceMap.ServiceMap<"multiple"> =>
-  ServiceMap.getReferenceUnsafe(ctx, CurrentComputedBehavior) === "multiple";
+const checkIsMultiple = (ctx: Context.Context<any>): ctx is Context.Context<"multiple"> =>
+  Context.getReferenceUnsafe(ctx, CurrentComputedBehavior) === "multiple";
 
 class ComputedImpl<R0, E0, A, E, R, E2, R2, C, E3, R3>
   extends Versioned.VersionedTransform<
@@ -352,7 +350,7 @@ class ComputedImpl<R0, E0, A, E, R, E2, R2, C, E3, R3>
 
     this._computed = Subject.hold(
       unwrap(
-        Effect.map(Effect.services(), (ctx) => {
+        Effect.map(Effect.context(), (ctx) => {
           if (checkIsMultiple(ctx)) {
             return fromYieldable(input).pipe(
               continueWith(() => input),
@@ -426,7 +424,7 @@ class FilteredImpl<R0, E0, A, E, R, E2, R2, C, E3, R3>
 
     this._computed = Subject.hold(
       unwrap(
-        Effect.map(Effect.services(), (ctx) => {
+        Effect.map(Effect.context(), (ctx) => {
           if (checkIsMultiple(ctx)) {
             return fromYieldable(input).pipe(
               continueWith(() => input),
@@ -457,14 +455,14 @@ class FilteredImpl<R0, E0, A, E, R, E2, R2, C, E3, R3>
 class RefSubjectCore<A, E, R, R2> {
   readonly initial: Effect.Effect<A, E, R>;
   readonly subject: Subject.HoldSubjectImpl<A, E>;
-  readonly services: ServiceMap.ServiceMap<R2>;
+  readonly services: Context.Context<R2>;
   readonly scope: Scope.Closeable;
   readonly deferredRef: DeferredRef.DeferredRef<E, A>;
   readonly semaphore: Semaphore.Semaphore;
   constructor(
     initial: Effect.Effect<A, E, R>,
     subject: Subject.HoldSubjectImpl<A, E>,
-    services: ServiceMap.ServiceMap<R2>,
+    services: Context.Context<R2>,
     scope: Scope.Closeable,
     deferredRef: DeferredRef.DeferredRef<E, A>,
     semaphore: Semaphore.Semaphore,
@@ -766,8 +764,8 @@ function makeCore<A, E, R>(
   deferredRef?: DeferredRef.DeferredRef<E, A>,
 ) {
   return Effect.gen(function* () {
-    const services = yield* Effect.services<R | Scope.Scope>();
-    const scope = yield* Scope.fork(ServiceMap.get(services, Scope.Scope));
+    const services = yield* Effect.context<R | Scope.Scope>();
+    const scope = yield* Scope.fork(Context.get(services, Scope.Scope));
     const id = yield* Effect.withFiber((fiber) => Effect.succeed(fiber.id));
     const subject = new Subject.HoldSubjectImpl<A, E>();
     const core = new RefSubjectCore(
@@ -1335,7 +1333,7 @@ const Variance: Fx.Variance<any, any, any> = {
 
 export function Service<Self, A, E = never>() {
   return <const Id extends string>(id: Id): RefSubject.Class<Self, Id, A, E> => {
-    const service = ServiceMap.Service<Self, RefSubject<A, E>>(id);
+    const service = Context.Service<Self, RefSubject<A, E>>(id);
 
     // eslint-disable-next-line @typescript-eslint/no-extraneous-class
     return class RefSubjectService {

package/src/Sink/Sink.ts

@@ -1,11 +1,11 @@
 import type * as Cause from "effect/Cause";
 import type { Effect } from "effect/Effect";
-import { flatMap, map, provide, services } from "effect/Effect";
+import { flatMap, map, provide, context } from "effect/Effect";
 import type { Layer } from "effect/Layer";
 import { effect } from "effect/Layer";
 import type { Ref } from "effect/Ref";
 import type { Scope } from "effect/Scope";
-import * as ServiceMap from "effect/ServiceMap";
+import * as Context from "effect/Context";
 
 /**
  * A Sink is a consumer of values. It consists of two effectful callbacks:
@@ -46,11 +46,11 @@ export declare namespace Sink {
    * @since 1.0.0
    * @category type-level
    */
-  export type Context<T> = T extends Sink<infer _A, infer _E, infer _R> ? _R : never;
+  export type Services<T> = T extends Sink<infer _A, infer _E, infer _R> ? _R : never;
 
   export interface Service<Self, Id extends string, A, E> extends Sink<A, E, Self> {
     readonly id: Id;
-    readonly service: ServiceMap.Service<Self, Sink<A, E>>;
+    readonly service: Context.Service<Self, Sink<A, E>>;
     readonly make: <R = never>(
       onFailure: (cause: Cause.Cause<E>) => Effect<unknown, never, R>,
       onSuccess: (value: A) => Effect<unknown, never, R>,
@@ -64,7 +64,7 @@ export declare namespace Sink {
 
 export type Success<T> = Sink.Success<T>;
 export type Error<T> = Sink.Error<T>;
-export type Context<T> = Sink.Context<T>;
+export type Services<T> = Sink.Services<T>;
 
 /**
  * Creates a Sink from success and failure callbacks.
@@ -124,7 +124,7 @@ export declare namespace Sink {
 
 export function Service<Self, A, E = never>() {
   return <const Id extends string>(id: Id): Sink.Class<Self, Id, A, E> => {
-    const service = ServiceMap.Service<Self, Sink<A, E>>(id);
+    const service = Context.Service<Self, Sink<A, E>>(id);
 
     // eslint-disable-next-line @typescript-eslint/no-extraneous-class
     return class SinkService {
@@ -137,7 +137,7 @@ export function Service<Self, A, E = never>() {
       ): Layer<Self, never, Exclude<R | R2, Scope>> =>
         effect(
           service,
-          map(services<R | R2>(), (context) =>
+          map(context<R | R2>(), (context) =>
             make(
               (cause) => provide(onFailure(cause), context),
               (value) => provide(onSuccess(value), context),

package/src/Sink/combinators.ts

@@ -219,7 +219,7 @@ export function withEarlyExit<A, E, R, R2>(
     params: { signal: AbortSignal; scheduler: Scheduler },
   ) => Effect.Effect<unknown, never, R2>,
 ): Effect.Effect<void, never, R | R2> {
-  return Effect.servicesWith((services) =>
+  return Effect.contextWith((services) =>
     Effect.callback<unknown, never, R2>(function (this: Scheduler, resume, signal) {
       let exited = false;
       const earlyExit = Effect.sync<void>(() => {