effect 4.0.0-beta.103 → 4.0.0-beta.105

package/src/unstable/observability/OtlpMetrics.ts

@@ -71,8 +71,8 @@ export type AggregationTemporality = "cumulative" | "delta"
  *
  * The exporter snapshots registered Effect metrics on the configured interval, serializes them with the selected aggregation temporality, and flushes during scope finalization up to `shutdownTimeout`.
  * Manual flushing also triggers a snapshot. With delta temporality, each
- * snapshot advances the previous-export state, so frequent flushes narrow the
- * delta aggregation windows.
+ * successful export advances the previous-export state, so frequent successful
+ * flushes narrow the delta aggregation windows.
  *
  * @category constructors
  * @since 4.0.0
@@ -108,15 +108,22 @@ export const make: (options: {
 
   // State for delta temporality tracking
   let previousExportTimeNanos: bigint = startTimeNanos
-  const previousCounterState = new Map<string, number | bigint>()
-  const previousHistogramState = new Map<string, PreviousHistogramState>()
-  const previousFrequencyState = new Map<string, Map<string, number>>()
-  const previousSummaryState = new Map<string, PreviousSummaryState>()
-
-  const snapshot = (): HttpBody => {
+  let previousCounterState = new Map<string, number | bigint>()
+  let previousHistogramState = new Map<string, PreviousHistogramState>()
+  let previousFrequencyState = new Map<string, Map<string, number>>()
+  let previousSummaryState = new Map<string, PreviousSummaryState>()
+  let snapshotSequence = 0
+  let committedSnapshotSequence = -1
+
+  const snapshot = (): readonly [body: HttpBody, onSuccess: Effect.Effect<void>] => {
     const snapshot = Metric.snapshotUnsafe(services)
+    const currentSnapshotSequence = snapshotSequence++
     const nowNanos = clock.currentTimeNanosUnsafe()
     const nowTime = String(nowNanos)
+    const nextCounterState = new Map(previousCounterState)
+    const nextHistogramState = new Map(previousHistogramState)
+    const nextFrequencyState = new Map(previousFrequencyState)
+    const nextSummaryState = new Map(previousSummaryState)
     const metricData: Array<IMetric> = []
     const metricDataByName = new Map<string, IMetric>()
     const addMetricData = (data: IMetric) => {
@@ -162,7 +169,7 @@ export const make: (options: {
                 }
               }
             }
-            previousCounterState.set(metricKey, currentCount)
+            nextCounterState.set(metricKey, currentCount)
           }
 
           const dataPoint: INumberDataPoint = {
@@ -253,7 +260,7 @@ export const make: (options: {
               // Note: This is a limitation - true delta min/max would require tracking
               // observations within each interval
             }
-            previousHistogramState.set(metricKey, {
+            nextHistogramState.set(metricKey, {
               count: state.state.count,
               sum: state.state.sum,
               bucketCounts: currentBuckets.counts.slice(),
@@ -314,7 +321,7 @@ export const make: (options: {
           }
 
           if (isDelta) {
-            previousFrequencyState.set(metricKey, currentOccurrences)
+            nextFrequencyState.set(metricKey, currentOccurrences)
           }
 
           if (metricDataByName.has(state.id)) {
@@ -366,7 +373,7 @@ export const make: (options: {
               reportCount = state.state.count - previousState.count
               reportSum = state.state.sum - previousState.sum
             }
-            previousSummaryState.set(metricKey, {
+            nextSummaryState.set(metricKey, {
               count: state.state.count,
               sum: state.state.sum
             })
@@ -426,12 +433,7 @@ export const make: (options: {
       }
     }
 
-    // Update the previous export time for delta calculations
-    if (isDelta) {
-      previousExportTimeNanos = nowNanos
-    }
-
-    return serialization.metrics({
+    const body = serialization.metrics({
       resourceMetrics: [{
         resource,
         scopeMetrics: [{
@@ -440,6 +442,18 @@ export const make: (options: {
         }]
       }]
     })
+    const onSuccess = isDelta
+      ? Effect.sync(() => {
+        if (currentSnapshotSequence < committedSnapshotSequence) return
+        previousCounterState = nextCounterState
+        previousHistogramState = nextHistogramState
+        previousFrequencyState = nextFrequencyState
+        previousSummaryState = nextSummaryState
+        previousExportTimeNanos = nowNanos
+        committedSnapshotSequence = currentSnapshotSequence
+      })
+      : Effect.void
+    return [body, onSuccess]
   }
 
   yield* Exporter.make({

package/src/unstable/observability/OtlpTracer.ts

@@ -83,7 +83,7 @@ export const make: (
           }]
         }]
       }
-      return serialization.traces(data)
+      return [serialization.traces(data), Effect.void]
     },
     shutdownTimeout: options.shutdownTimeout ?? Duration.seconds(3)
   })

package/src/unstable/persistence/PersistedQueue.ts

@@ -217,7 +217,7 @@ export type ErrorTypeId = "~@effect/experimental/PersistedQueue/PersistedQueueEr
  * @category errors
  * @since 4.0.0
  */
-export class PersistedQueueError extends Schema.ErrorClass<PersistedQueueError>(
+export class PersistedQueueError extends Schema.Error<PersistedQueueError>(
   "effect/persistence/PersistedQueue/PersistedQueueError"
 )({
   _tag: Schema.tag("PersistedQueueError"),
@@ -294,9 +294,9 @@ export const layerStoreMemory: Layer.Layer<
     attempts: number
     readonly element: unknown
   }
-  const ids = new Set<string>()
   const queues = new Map<string, {
     latch: Latch.Latch
+    ids: Set<string>
     items: Set<Entry>
   }>()
   const getOrCreateQueue = (name: string) => {
@@ -304,6 +304,7 @@ export const layerStoreMemory: Layer.Layer<
     if (!queue) {
       queue = {
         latch: Latch.makeUnsafe(false),
+        ids: new Set(),
         items: new Set()
       }
       queues.set(name, queue)
@@ -314,9 +315,9 @@ export const layerStoreMemory: Layer.Layer<
   return PersistedQueueStore.of({
     offer: (options) =>
       Effect.sync(() => {
-        if (ids.has(options.id)) return
-        ids.add(options.id)
         const queue = getOrCreateQueue(options.name)
+        if (queue.ids.has(options.id)) return
+        queue.ids.add(options.id)
         queue.items.add({ id: options.id, attempts: 0, element: options.element })
         queue.latch.openUnsafe()
       }),
@@ -857,9 +858,11 @@ export const makeStoreSql: (
   yield* sql.onDialectOrElse({
     mssql: () =>
       sql`IF NOT EXISTS (SELECT * FROM sys.indexes WHERE name = N'idx_${tableName}_id')
-        CREATE UNIQUE INDEX idx_${tableNameSql}_id ON ${tableNameSql} (id)`,
-    mysql: () => sql`CREATE UNIQUE INDEX ${sql(`idx_${tableName}_id`)} ON ${tableNameSql} (id)`.pipe(Effect.ignore),
-    orElse: () => sql`CREATE UNIQUE INDEX IF NOT EXISTS ${sql(`idx_${tableName}_id`)} ON ${tableNameSql} (id)`
+        CREATE UNIQUE INDEX idx_${tableNameSql}_id ON ${tableNameSql} (id, queue_name)`,
+    mysql: () =>
+      sql`CREATE UNIQUE INDEX ${sql(`idx_${tableName}_id`)} ON ${tableNameSql} (id, queue_name)`.pipe(Effect.ignore),
+    orElse: () =>
+      sql`CREATE UNIQUE INDEX IF NOT EXISTS ${sql(`idx_${tableName}_id`)} ON ${tableNameSql} (id, queue_name)`
   })
 
   yield* sql.onDialectOrElse({
@@ -894,7 +897,7 @@ export const makeStoreSql: (
       sql`
         INSERT INTO ${tableNameSql} (id, queue_name, element, completed, attempts, created_at, updated_at)
         VALUES (${id}, ${name}, ${element}, FALSE, 0, ${sqlNow}, ${sqlNow})
-        ON CONFLICT (id) DO NOTHING
+        ON CONFLICT (id, queue_name) DO NOTHING
       `,
     mysql: () => (id: string, name: string, element: string) =>
       sql`
@@ -903,7 +906,7 @@ export const makeStoreSql: (
       `,
     mssql: () => (id: string, name: string, element: string) =>
       sql`
-        IF NOT EXISTS (SELECT 1 FROM ${tableNameSql} WHERE id = ${id})
+        IF NOT EXISTS (SELECT 1 FROM ${tableNameSql} WHERE id = ${id} AND queue_name = ${name})
         BEGIN
           INSERT INTO ${tableNameSql} (id, queue_name, element, completed, attempts, created_at, updated_at)
           VALUES (${id}, ${name}, ${element}, 0, 0, ${sqlNow}, ${sqlNow})

package/src/unstable/persistence/Persistence.ts

@@ -35,7 +35,7 @@ const ErrorTypeId = "~effect/persistence/Persistence/PersistenceError" as const
  * @category errors
  * @since 4.0.0
  */
-export class PersistenceError extends Schema.ErrorClass<PersistenceError>(ErrorTypeId)({
+export class PersistenceError extends Schema.Error<PersistenceError>(ErrorTypeId)({
   _tag: Schema.tag("PersistenceError"),
   message: Schema.String,
   cause: Schema.optional(Schema.Defect())
@@ -304,7 +304,8 @@ export const layerBackingSqlMultiTable: Layer.Layer<
   return BackingPersistence.of({
     make: Effect.fnUntraced(function*(storeId) {
       const clock = yield* Clock.Clock
-      const table = sql(`effect_persistence_${storeId}`)
+      const tableName = `effect_persistence_${storeId}`
+      const table = sql(tableName)
       yield* sql.onDialectOrElse({
         mysql: () =>
           sql`
@@ -324,7 +325,7 @@ export const layerBackingSqlMultiTable: Layer.Layer<
           `,
         mssql: () =>
           sql`
-            IF NOT EXISTS (SELECT * FROM sysobjects WHERE name=${table} AND xtype='U')
+            IF NOT EXISTS (SELECT * FROM sysobjects WHERE name=${tableName} AND xtype='U')
             CREATE TABLE ${table} (
               id NVARCHAR(450) PRIMARY KEY,
               value NVARCHAR(MAX) NOT NULL,
@@ -362,6 +363,20 @@ export const layerBackingSqlMultiTable: Layer.Layer<
             INSERT INTO ${table} ${sql.insert(entries)}
             ON DUPLICATE KEY UPDATE value=VALUES(value), expires=VALUES(expires)
           `.unprepared,
+        mssql: (): UpsertFn => (entries) =>
+          Effect.forEach(
+            entries,
+            (entry) =>
+              sql`
+                MERGE ${table} AS target
+                USING (SELECT ${entry.id} AS id, ${entry.value} AS value, ${entry.expires} AS expires) AS source
+                ON target.id = source.id
+                WHEN MATCHED THEN UPDATE SET value = source.value, expires = source.expires
+                WHEN NOT MATCHED THEN INSERT (id, value, expires)
+                VALUES (source.id, source.value, source.expires);
+              `,
+            { discard: true }
+          ),
         // sqlite
         orElse: (): UpsertFn => (entries) =>
           sql`
@@ -538,7 +553,7 @@ export const layerBackingSql: Layer.Layer<
       `,
     mssql: () =>
       sql`
-        IF NOT EXISTS (SELECT * FROM sysobjects WHERE name=${table} AND xtype='U')
+        IF NOT EXISTS (SELECT * FROM sysobjects WHERE name=${"effect_persistence"} AND xtype='U')
         CREATE TABLE ${table} (
           store_id NVARCHAR(191) NOT NULL,
           id NVARCHAR(191) NOT NULL,
@@ -928,7 +943,13 @@ export const layerBackingRedis: Layer.Layer<
             Effect.mapError(
               ttl === undefined
                 ? redis.send("SET", prefixed(key), JSON.stringify(value))
-                : redis.send("SET", prefixed(key), JSON.stringify(value), "PX", String(Duration.toMillis(ttl))),
+                : redis.send(
+                  "SET",
+                  prefixed(key),
+                  JSON.stringify(value),
+                  "PX",
+                  String(Math.ceil(Duration.toMillis(ttl)))
+                ),
               ({ cause }) =>
                 new PersistenceError({
                   message: `Failed to set key ${key} in Redis`,
@@ -943,7 +964,7 @@ export const layerBackingRedis: Layer.Layer<
                 const pkey = prefixed(key)
                 sets.set(pkey, JSON.stringify(value))
                 if (ttl) {
-                  expires.set(pkey, Duration.toMillis(ttl))
+                  expires.set(pkey, Math.ceil(Duration.toMillis(ttl)))
                 }
               }
               return Effect.mapError(
@@ -1090,7 +1111,6 @@ export const layerBackingKvs: Layer.Layer<
           setMany: (entries) =>
             Effect.forEach(entries, ([key, value, ttl]) => {
               const expires = unsafeTtlToExpires(clock, ttl)
-              if (expires === null) return Effect.void
               const encoded = JSON.stringify([value, expires])
               return store.set(key, encoded)
             }, { concurrency: "unbounded", discard: true }).pipe(

package/src/unstable/persistence/RateLimiter.ts

@@ -285,7 +285,7 @@ export const makeWithRateLimiter: Effect.Effect<
 )
 
 /**
- * Accesses a function that sleeps when the rate limit is exceeded.
+ * Sleeps when the rate limit is exceeded.
  *
  * **Example** (Sleeping until rate limit permits)
  *
@@ -294,52 +294,75 @@ export const makeWithRateLimiter: Effect.Effect<
  * import { RateLimiter } from "effect/unstable/persistence"
  *
  * const program = Effect.gen(function*() {
- *   // Access the `sleep` function from the RateLimiter module
- *   const sleep = yield* RateLimiter.makeSleep
- *
- *   // Use the `sleep` function with specific rate limiting parameters.
- *   // This will only sleep if the rate limit has been exceeded.
- *   const result = yield* sleep({
- *     key: "some-key",
+ *   const limiter = yield* RateLimiter.RateLimiter
+ *   const partiallyApplied = RateLimiter.sleep(limiter)
+ *   const partial = yield* partiallyApplied({
+ *     key: "partial",
+ *     limit: 10,
+ *     window: "5 seconds",
+ *     algorithm: "fixed-window"
+ *   })
+ *   const direct = yield* RateLimiter.sleep(limiter, {
+ *     key: "direct",
  *     limit: 10,
  *     window: "5 seconds",
  *     algorithm: "fixed-window"
  *   })
- *   return result.remaining
+ *   return [partial.remaining, direct.remaining]
  * }).pipe(
  *   Effect.provide(RateLimiter.layer.pipe(Layer.provide(RateLimiter.layerStoreMemory)))
  * )
  *
- * await Effect.runPromise(program) // => 9
+ * await Effect.runPromise(program) // => [9, 9]
  * ```
  *
  * @category accessors
  * @since 4.0.0
  */
-export const makeSleep: Effect.Effect<
-  ((options: {
+export function sleep(self: RateLimiter): (options: {
+  readonly algorithm?: "fixed-window" | "token-bucket" | undefined
+  readonly window: Duration.Input
+  readonly limit: number
+  readonly key: string
+  readonly tokens?: number | undefined
+}) => Effect.Effect<ConsumeResult, RateLimiterError>
+export function sleep(self: RateLimiter, options: {
+  readonly algorithm?: "fixed-window" | "token-bucket" | undefined
+  readonly window: Duration.Input
+  readonly limit: number
+  readonly key: string
+  readonly tokens?: number | undefined
+}): Effect.Effect<ConsumeResult, RateLimiterError>
+export function sleep(self: RateLimiter, options?: {
+  readonly algorithm?: "fixed-window" | "token-bucket" | undefined
+  readonly window: Duration.Input
+  readonly limit: number
+  readonly key: string
+  readonly tokens?: number | undefined
+}):
+  | Effect.Effect<ConsumeResult, RateLimiterError>
+  | ((options: {
     readonly algorithm?: "fixed-window" | "token-bucket" | undefined
     readonly window: Duration.Input
     readonly limit: number
     readonly key: string
     readonly tokens?: number | undefined
-  }) => Effect.Effect<ConsumeResult, RateLimiterError>),
-  never,
-  RateLimiter
-> = RateLimiter.use((limiter) =>
-  Effect.succeed((options) =>
-    Effect.flatMap(
-      limiter.consume({
-        ...options,
-        onExceeded: "delay"
-      }),
-      (result) => {
-        if (Duration.isZero(result.delay)) return Effect.succeed(result)
-        return Effect.as(Effect.sleep(result.delay), result)
-      }
-    )
+  }) => Effect.Effect<ConsumeResult, RateLimiterError>)
+{
+  if (options === undefined) {
+    return (options) => sleep(self, options)
+  }
+  return Effect.flatMap(
+    self.consume({
+      ...options,
+      onExceeded: "delay"
+    }),
+    (result) => {
+      if (Duration.isZero(result.delay)) return Effect.succeed(result)
+      return Effect.as(Effect.sleep(result.delay), result)
+    }
   )
-)
+}
 
 /**
  * Runtime type identifier for `RateLimiterError`.
@@ -367,7 +390,7 @@ export type ErrorTypeId = "~@effect/experimental/RateLimiter/RateLimiterError"
  * @category errors
  * @since 4.0.0
  */
-export class RateLimitExceeded extends Schema.ErrorClass<RateLimitExceeded>(
+export class RateLimitExceeded extends Schema.Error<RateLimitExceeded>(
   "effect/persistence/RateLimiter/RateLimitExceeded"
 )({
   _tag: Schema.tag("RateLimitExceeded"),
@@ -392,7 +415,7 @@ export class RateLimitExceeded extends Schema.ErrorClass<RateLimitExceeded>(
  * @category errors
  * @since 4.0.0
  */
-export class RateLimitStoreError extends Schema.ErrorClass<RateLimitStoreError>(
+export class RateLimitStoreError extends Schema.Error<RateLimitStoreError>(
   "effect/persistence/RateLimiter/RateLimitStoreError"
 )({
   _tag: Schema.tag("RateLimitStoreError"),
@@ -426,7 +449,7 @@ export const RateLimiterErrorReason: Schema.Union<[
  * @category errors
  * @since 4.0.0
  */
-export class RateLimiterError extends Schema.ErrorClass<RateLimiterError>(ErrorTypeId)({
+export class RateLimiterError extends Schema.Error<RateLimiterError>(ErrorTypeId)({
   _tag: Schema.tag("RateLimiterError"),
   reason: RateLimiterErrorReason
 }) {

package/src/unstable/persistence/Redis.ts

@@ -100,7 +100,7 @@ const ErrorTypeId: ErrorTypeId = "~effect/persistence/Redis/RedisError"
  * @category errors
  * @since 4.0.0
  */
-export class RedisError extends Schema.ErrorClass<RedisError>(ErrorTypeId)({
+export class RedisError extends Schema.Error<RedisError>(ErrorTypeId)({
   _tag: Schema.tag("RedisError"),
   cause: Schema.Defect()
 }) {

package/src/unstable/reactivity/AsyncResult.ts

@@ -1101,7 +1101,7 @@ export const Schema = <
     [success_, Schema_.Cause(error, Schema_.Defect())],
     ([value, cause]) => (input, ast, options) => {
       if (!isAsyncResult(input)) {
-        return Effect.fail(new SchemaIssue.InvalidType(ast))
+        return Effect.fail(new SchemaIssue.InvalidType(ast, input, options))
       }
       switch (input._tag) {
         case "Initial":
@@ -1111,7 +1111,7 @@ export const Schema = <
             SchemaParser.decodeUnknownEffect(value)(input.value, options),
             {
               onSuccess: (value) => success(value, input),
-              onFailure: (issue) => new SchemaIssue.Composite(ast, [new SchemaIssue.Pointer(["value"], issue)])
+              onFailure: (issue) => SchemaIssue.makeCompositeAtKey(ast, "value", issue, input, options)
             }
           )
         case "Failure": {
@@ -1122,9 +1122,14 @@ export const Schema = <
                 {
                   onSuccess: (value) => Option.some(success<A["Type"], E["Type"]>(value, ps)),
                   onFailure: (issue) =>
-                    new SchemaIssue.Composite(ast, [
-                      new SchemaIssue.Pointer(["previousSuccess", "value"], issue)
-                    ])
+                    new SchemaIssue.Composite(
+                      ast,
+                      [
+                        new SchemaIssue.Pointer(["previousSuccess", "value"], issue)
+                      ],
+                      input,
+                      options
+                    )
                 }
               )
             ),
@@ -1132,7 +1137,7 @@ export const Schema = <
           )
           const causeEffect = Effect.mapErrorEager(
             SchemaParser.decodeUnknownEffect(cause)(input.cause, options),
-            (issue) => new SchemaIssue.Composite(ast, [new SchemaIssue.Pointer(["cause"], issue)])
+            (issue) => SchemaIssue.makeCompositeAtKey(ast, "cause", issue, input, options)
           )
           return Effect.flatMapEager(
             prevSuccessEffect,

package/src/unstable/reactivity/Atom.ts

@@ -790,7 +790,7 @@ export interface AtomRuntime<R, ER = never> extends Atom<AsyncResult.AsyncResult
 }
 
 /**
- * Factory for `AtomRuntime` values that share a `Layer.MemoMap` and a set of global layers.
+ * Factory for `AtomRuntime` values that share a set of global layers.
  *
  * @category models
  * @since 4.0.0
@@ -801,7 +801,6 @@ export interface RuntimeFactory {
       | Layer.Layer<R, E, AtomRegistry | Reactivity.Reactivity>
       | ((get: AtomContext) => Layer.Layer<R, E, AtomRegistry | Reactivity.Reactivity>)
   ): AtomRuntime<R, E>
-  readonly memoMap: Layer.MemoMap
   readonly addGlobalLayer: <A, E>(layer: Layer.Layer<A, E, AtomRegistry | Reactivity.Reactivity>) => void
 
   /**
@@ -814,14 +813,40 @@ export interface RuntimeFactory {
 }
 
 /**
- * Creates a `RuntimeFactory` backed by the supplied `Layer.MemoMap`.
+ * A `RuntimeFactory` backed by an atom whose memo map is scoped to each registry.
  *
- * @category constructors
+ * @category models
  * @since 4.0.0
  */
-export const context: (options: {
+export interface RegistryRuntimeFactory extends RuntimeFactory {
+  readonly memoMap: Atom<Layer.MemoMap>
+}
+
+/**
+ * A `RuntimeFactory` backed by a concrete memo map shared across registries.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface SharedRuntimeFactory extends RuntimeFactory {
   readonly memoMap: Layer.MemoMap
-}) => RuntimeFactory = (options) => {
+}
+
+/**
+ * Creates a `RuntimeFactory` backed by a registry-scoped memo map by default,
+ * or by the supplied atom or concrete `Layer.MemoMap`.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export function context(): RegistryRuntimeFactory
+export function context(options: { readonly memoMap: Atom<Layer.MemoMap> }): RegistryRuntimeFactory
+export function context(options: { readonly memoMap: Layer.MemoMap }): SharedRuntimeFactory
+export function context(options?: {
+  readonly memoMap: Atom<Layer.MemoMap> | Layer.MemoMap
+}): RegistryRuntimeFactory | SharedRuntimeFactory {
+  const memoMap = options?.memoMap ?? removeTtl(make(() => Layer.makeMemoMapUnsafe()))
+  const resolveMemoMap = (get: AtomContext): Layer.MemoMap => isAtom(memoMap) ? get(memoMap) : memoMap
   let globalLayer: Layer.Layer<any, any, AtomRegistry> = Reactivity.layer
   function factory<E, R>(
     create:
@@ -843,23 +868,25 @@ export const context: (options: {
 
     self.read = function read(get: AtomContext) {
       const layer = get(layerAtom)
-      const build = Effect.flatMap(Effect.scope, (scope) => Layer.buildWithMemoMap(layer, options.memoMap, scope))
+      const build = Effect.flatMap(Effect.scope, (scope) => Layer.buildWithMemoMap(layer, resolveMemoMap(get), scope))
       return effect(get, build, { uninterruptible: true })
     }
 
     return self
   }
-  factory.memoMap = options.memoMap
+  factory.memoMap = memoMap
   factory.addGlobalLayer = (layer: Layer.Layer<any, any, AtomRegistry | Reactivity.Reactivity>) => {
     globalLayer = Layer.provideMerge(globalLayer, Layer.provide(layer, Reactivity.layer))
   }
-  const reactivityAtom = removeTtl(make(
-    Effect.contextWith((services: Context.Context<Scope.Scope>) =>
-      Layer.buildWithMemoMap(Reactivity.layer, options.memoMap, Context.get(services, Scope.Scope))
-    ).pipe(
-      Effect.map(Context.get(Reactivity.Reactivity))
+  const reactivityAtom = removeTtl(
+    make((get) =>
+      Effect.contextWith((services: Context.Context<Scope.Scope>) =>
+        Layer.buildWithMemoMap(Reactivity.layer, resolveMemoMap(get), Context.get(services, Scope.Scope))
+      ).pipe(
+        Effect.map(Context.get(Reactivity.Reactivity))
+      )
     )
-  ))
+  )
   factory.withReactivity =
     (keys: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>>) =>
     <A extends Atom<any>>(atom: A): A =>
@@ -871,24 +898,16 @@ export const context: (options: {
         get.subscribe(atom, (value) => get.setSelf(value))
         return get.once(atom)
       }, { initialValueTarget: atom }) as any as A
-  return factory
+  return factory as any
 }
 
 /**
- * Default `Layer.MemoMap` used by the module-level `runtime` factory.
- *
- * @category context
- * @since 4.0.0
- */
-export const defaultMemoMap: Layer.MemoMap = Layer.makeMemoMapUnsafe()
-
-/**
- * Default `RuntimeFactory` created with `defaultMemoMap`.
+ * Default registry-scoped `RuntimeFactory`.
  *
  * @category context
  * @since 4.0.0
  */
-export const runtime: RuntimeFactory = context({ memoMap: defaultMemoMap })
+export const runtime: RegistryRuntimeFactory = context()
 
 /**
  * Returns `Rx.runtime.withReactivity` for refreshing an atom whenever the