effect 4.0.0-beta.104 → 4.0.0-beta.105

package/src/unstable/http/HttpClient.ts

@@ -1267,7 +1267,8 @@ export declare namespace WithRateLimiter {
    *
    * **Details**
    *
-   * They define the backing limiter, initial limit window, keying strategy, algorithm, token cost, and whether response headers update future limits.
+   * They define the backing limiter, initial limit window, keying strategy,
+   * algorithm, token cost, retry count, and response header inspection.
    *
    * @category rate limiting
    * @since 4.0.0
@@ -1300,11 +1301,48 @@ export declare namespace WithRateLimiter {
      */
     readonly tokens?: number | ((request: HttpClientRequest.HttpClientRequest) => number) | undefined
     /**
-     * Disable automatic limits updates from response headers.
+     * The maximum number of automatic retries after an HTTP `429` response.
+     * Use a non-negative integer. Defaults to an unlimited number of retries.
+     * Set to `0` to disable automatic retries.
+     */
+    readonly times?: number | undefined
+    /**
+     * Overrides the response header names used for rate limit inspection.
+     * Header names are matched case-insensitively. An omitted field continues
+     * using the built-in names, while a configured field replaces them for
+     * that value. Header value formats are unchanged.
+     */
+    readonly responseHeaders?: {
+      /**
+       * Header containing the maximum number of requests in a window.
+       */
+      readonly limit?: string | undefined
+      /**
+       * Header containing the number of requests remaining in a window.
+       */
+      readonly remaining?: string | undefined
+      /**
+       * Header containing the rate limit reset time.
+       */
+      readonly reset?: string | undefined
+      /**
+       * Header containing the number of seconds until the rate limit resets.
+       */
+      readonly resetAfter?: string | undefined
+      /**
+       * Header containing the retry delay for an HTTP `429` response.
+       */
+      readonly retryAfter?: string | undefined
+    } | undefined
+    /**
+     * Disables automatic limit updates, `Retry-After` delays, and adaptive
+     * feedback from response headers. This does not disable automatic HTTP
+     * `429` retries. Set `times` to `0` to disable them.
      */
     readonly disableResponseInspection?: boolean | undefined
     /**
-     * Disable adaptive learning from `Retry-After` responses.
+     * Disables adaptive learning from `Retry-After` responses. Response
+     * inspection and direct `Retry-After` delays remain enabled.
      */
     readonly disableAdaptiveLearning?: boolean | undefined
   }
@@ -1319,6 +1357,12 @@ export declare namespace WithRateLimiter {
  * automatically retries HTTP `429` responses (or `HttpClientError` values
  * wrapping a `429` response) by forcing the retry back through the limiter.
  *
+ * **Gotchas**
+ *
+ * Automatic HTTP `429` retries are unlimited unless `times` is specified.
+ * Disabling response inspection does not disable retries; set `times` to `0`
+ * to return or fail with the first `429`.
+ *
  * @category rate limiting
  * @since 4.0.0
  */
@@ -1332,6 +1376,12 @@ export const withRateLimiter: {
    * automatically retries HTTP `429` responses (or `HttpClientError` values
    * wrapping a `429` response) by forcing the retry back through the limiter.
    *
+   * **Gotchas**
+   *
+   * Automatic HTTP `429` retries are unlimited unless `times` is specified.
+   * Disabling response inspection does not disable retries; set `times` to `0`
+   * to return or fail with the first `429`.
+   *
    * @category rate limiting
    * @since 4.0.0
    */
@@ -1347,6 +1397,12 @@ export const withRateLimiter: {
    * automatically retries HTTP `429` responses (or `HttpClientError` values
    * wrapping a `429` response) by forcing the retry back through the limiter.
    *
+   * **Gotchas**
+   *
+   * Automatic HTTP `429` retries are unlimited unless `times` is specified.
+   * Disabling response inspection does not disable retries; set `times` to `0`
+   * to return or fail with the first `429`.
+   *
    * @category rate limiting
    * @since 4.0.0
    */
@@ -1371,6 +1427,7 @@ export const withRateLimiter: {
     ? tokensOption
     : constant(tokensOption ?? 1)
   const adaptiveLearningEnabled = !options.disableAdaptiveLearning
+  const headerNames = resolveRateLimiterHeaderNames(options.responseHeaders)
 
   const getState = (key: string): RateLimiterState => {
     const current = states.get(key)
@@ -1385,13 +1442,13 @@ export const withRateLimiter: {
     ? undefined
     : (clock: Clock, key: string, headers: Headers.Headers, tokens: number) => {
       const current = getState(key)
-      const next = parseRateLimiterState(current, clock, headers, tokens)
+      const next = parseRateLimiterState(current, clock, headers, tokens, headerNames)
       if (next.limit !== current.limit || !Duration.equals(next.window, current.window)) {
         states.set(key, next)
       }
     }
 
-  return transform(self, function loop(effect, request): Effect.Effect<
+  return transform(self, function loop(effect, request, retries = 0): Effect.Effect<
     HttpClientResponse.HttpClientResponse,
     E | RateLimiter.RateLimiterError,
     R
@@ -1401,11 +1458,11 @@ export const withRateLimiter: {
     const key = resolveKey(request)
     const tokens = Math.max(resolveTokens(request), 1)
     const current = getState(key)
+    const canRetry = options.times === undefined || retries < options.times
     function retry(retryAfter: Duration.Duration | undefined) {
-      if (options.disableResponseInspection) return loop(effect, request)
       return retryAfter
-        ? Effect.flatMap(Effect.sleep(retryAfter), () => loop(effect, request))
-        : loop(effect, request)
+        ? Effect.flatMap(Effect.sleep(retryAfter), () => loop(effect, request, retries + 1))
+        : loop(effect, request, retries + 1)
     }
     const inspectResponse = (
       response: HttpClientResponse.HttpClientResponse,
@@ -1422,12 +1479,18 @@ export const withRateLimiter: {
          * automatically retries HTTP `429` responses (or `HttpClientError` values
          * wrapping a `429` response) by forcing the retry back through the limiter.
          *
+         * **Gotchas**
+         *
+         * Automatic HTTP `429` retries are unlimited unless `times` is specified.
+         * Disabling response inspection does not disable retries; set `times` to `0`
+         * to return or fail with the first `429`.
+         *
          * @category rate limiting
          * @since 4.0.0
          */
         Duration.Duration | undefined>(undefined);
       }
-      const retryAfter = parseRetryAfter(clock, getHeader(response.headers, "retry-after"))
+      const retryAfter = parseRetryAfter(clock, getHeader(response.headers, ...headerNames.retryAfter))
       if (retryAfter === undefined) {
         return Effect.succeed</**
          * Applies request rate limiting using the `RateLimiter` service.
@@ -1438,12 +1501,18 @@ export const withRateLimiter: {
          * automatically retries HTTP `429` responses (or `HttpClientError` values
          * wrapping a `429` response) by forcing the retry back through the limiter.
          *
+         * **Gotchas**
+         *
+         * Automatic HTTP `429` retries are unlimited unless `times` is specified.
+         * Disabling response inspection does not disable retries; set `times` to `0`
+         * to return or fail with the first `429`.
+         *
          * @category rate limiting
          * @since 4.0.0
          */
         Duration.Duration | undefined>(undefined);
       }
-      const delay = parseRateLimitWindow(clock, response.headers) ?? retryAfter
+      const delay = parseRateLimitWindow(clock, response.headers, headerNames) ?? retryAfter
       if (adaptive === undefined) {
         return Effect.succeed</**
          * Applies request rate limiting using the `RateLimiter` service.
@@ -1454,6 +1523,12 @@ export const withRateLimiter: {
          * automatically retries HTTP `429` responses (or `HttpClientError` values
          * wrapping a `429` response) by forcing the retry back through the limiter.
          *
+         * **Gotchas**
+         *
+         * Automatic HTTP `429` retries are unlimited unless `times` is specified.
+         * Disabling response inspection does not disable retries; set `times` to `0`
+         * to return or fail with the first `429`.
+         *
          * @category rate limiting
          * @since 4.0.0
          */
@@ -1489,7 +1564,7 @@ export const withRateLimiter: {
             const request = Effect.matchEffect(effect, {
               onSuccess(response) {
                 return Effect.flatMap(inspectResponse(response, adaptive), (retryAfter) => {
-                  if (response.status !== 429) return Effect.succeed(response)
+                  if (response.status !== 429 || !canRetry) return Effect.succeed(response)
                   return retry(retryAfter)
                 })
               },
@@ -1497,7 +1572,7 @@ export const withRateLimiter: {
                 if (isTooManyRequestsHttpClientError(error)) {
                   return Effect.flatMap(
                     inspectResponse(error.reason.response, adaptive),
-                    (retryAfter) => retry(retryAfter)
+                    (retryAfter) => canRetry ? retry(retryAfter) : Effect.fail(error)
                   )
                 }
                 return Effect.fail(error)
@@ -1531,6 +1606,34 @@ export const withRateLimiter: {
   });
 })
 
+interface RateLimiterHeaderNames {
+  readonly limit: ReadonlyArray<string>
+  readonly remaining: ReadonlyArray<string>
+  readonly reset: ReadonlyArray<string>
+  readonly resetAfter: ReadonlyArray<string>
+  readonly retryAfter: ReadonlyArray<string>
+}
+
+const resolveRateLimiterHeaderNames = (
+  responseHeaders: WithRateLimiter.Options["responseHeaders"]
+): RateLimiterHeaderNames => ({
+  limit: responseHeaders?.limit === undefined
+    ? ["ratelimit-limit", "x-ratelimit-limit"]
+    : [responseHeaders.limit.toLowerCase()],
+  remaining: responseHeaders?.remaining === undefined
+    ? ["ratelimit-remaining", "x-ratelimit-remaining"]
+    : [responseHeaders.remaining.toLowerCase()],
+  reset: responseHeaders?.reset === undefined
+    ? ["ratelimit-reset", "x-ratelimit-reset"]
+    : [responseHeaders.reset.toLowerCase()],
+  resetAfter: responseHeaders?.resetAfter === undefined
+    ? ["ratelimit-reset-after", "x-ratelimit-reset-after"]
+    : [responseHeaders.resetAfter.toLowerCase()],
+  retryAfter: responseHeaders?.retryAfter === undefined
+    ? ["retry-after"]
+    : [responseHeaders.retryAfter.toLowerCase()]
+})
+
 interface RateLimiterState {
   readonly limit: number
   readonly window: Duration.Duration
@@ -1541,10 +1644,11 @@ const parseRateLimiterState = (
   state: RateLimiterState,
   clock: Clock,
   headers: Headers.Headers,
-  tokens: number
+  tokens: number,
+  headerNames: RateLimiterHeaderNames
 ): RateLimiterState => {
-  const limit = parseRateLimitLimit(state, headers, tokens) ?? state.limit
-  const window = parseRateLimitWindow(clock, headers) ?? state.window
+  const limit = parseRateLimitLimit(state, headers, tokens, headerNames) ?? state.limit
+  const window = parseRateLimitWindow(clock, headers, headerNames) ?? state.window
   if (limit === state.limit && Duration.equals(window, state.window)) {
     return state
   }
@@ -1554,35 +1658,40 @@ const parseRateLimiterState = (
 const parseRateLimitLimit = (
   state: RateLimiterState,
   headers: Headers.Headers,
-  tokens: number
+  tokens: number,
+  headerNames: RateLimiterHeaderNames
 ): number | undefined => {
-  const raw = getHeader(headers, "ratelimit-limit", "x-ratelimit-limit")
+  const raw = getHeader(headers, ...headerNames.limit)
   const value = parseNumberHeader(raw)
   if (value !== undefined && value > 0) {
     return value
   }
-  const remaining = parseRateLimitRemaining(headers)
+  const remaining = parseRateLimitRemaining(headers, headerNames)
   if (remaining === undefined) {
     return undefined
   }
   return state.initial ? remaining + tokens : Math.max(remaining + tokens, state.limit)
 }
 
-const parseRateLimitRemaining = (headers: Headers.Headers): number | undefined => {
-  const raw = getHeader(headers, "ratelimit-remaining", "x-ratelimit-remaining")
+const parseRateLimitRemaining = (
+  headers: Headers.Headers,
+  headerNames: RateLimiterHeaderNames
+): number | undefined => {
+  const raw = getHeader(headers, ...headerNames.remaining)
   const value = parseNumberHeader(raw)
   return value !== undefined && value >= 0 ? value : undefined
 }
 
 const parseRateLimitWindow = (
   clock: Clock,
-  headers: Headers.Headers
+  headers: Headers.Headers,
+  headerNames: RateLimiterHeaderNames
 ): Duration.Duration | undefined => {
-  const resetAfter = parseResetAfter(getHeader(headers, "ratelimit-reset-after", "x-ratelimit-reset-after"))
+  const resetAfter = parseResetAfter(getHeader(headers, ...headerNames.resetAfter))
   if (resetAfter !== undefined) {
     return resetAfter
   }
-  return parseResetHeader(clock, getHeader(headers, "ratelimit-reset", "x-ratelimit-reset"))
+  return parseResetHeader(clock, getHeader(headers, ...headerNames.reset))
 }
 
 const parseRetryAfter = (

package/src/unstable/httpapi/HttpApiBuilder.ts

@@ -1101,10 +1101,10 @@ function toResponseErrorSchema(
     HttpApiSchema.isNoContent(schema.schema.ast)
   )
   const transformation = withHeadersTransformation<HttpApiSchema.withHeaders<unknown, Schema.StringTree>>(
-    (body) =>
-      encodeBody(body).pipe(
+    (body, options) =>
+      encodeBody(body, options).pipe(
         Effect.mapError((error) => error.issue),
-        Effect.flatMap(encodeResponse)
+        Effect.flatMap((body) => encodeResponse(body, options))
       ),
     encodeHeaders
   )
@@ -1167,22 +1167,34 @@ function getResponseTransformation(
   )
 
   return SchemaTransformation.transformOrFail({
-    decode: () => Effect.fail(new SchemaIssue.Forbidden({ message: "Encode only schema" })),
+    decode: (input, options) =>
+      Effect.fail(
+        new SchemaIssue.Forbidden({ message: "Encode only schema" }, input, options)
+      ),
     encode
   })
 }
 
 function withHeadersTransformation<T = unknown>(
-  encodeBody: (body: unknown) => Effect.Effect<Response.HttpServerResponse, SchemaIssue.Issue, unknown>,
-  encodeHeaders: (headers: unknown) => Effect.Effect<unknown, Schema.SchemaError, unknown>
+  encodeBody: (
+    body: unknown,
+    options?: SchemaAST.ParseOptions
+  ) => Effect.Effect<Response.HttpServerResponse, SchemaIssue.Issue, unknown>,
+  encodeHeaders: (
+    headers: unknown,
+    options?: SchemaAST.ParseOptions
+  ) => Effect.Effect<unknown, Schema.SchemaError, unknown>
 ): SchemaTransformation.Transformation<T, Response.HttpServerResponse, never, unknown> {
   return SchemaTransformation.transformOrFail<T, Response.HttpServerResponse, never, unknown>({
-    decode: () => Effect.fail(new SchemaIssue.Forbidden({ message: "Encode only schema" })),
-    encode: (value) => {
+    decode: (input, options) =>
+      Effect.fail(
+        new SchemaIssue.Forbidden({ message: "Encode only schema" }, input, options)
+      ),
+    encode: (value, options) => {
       const pair = value as { readonly body: unknown; readonly headers: unknown }
-      return Effect.flatMap(encodeBody(pair.body), (response) =>
+      return Effect.flatMap(encodeBody(pair.body, options), (response) =>
         Effect.map(
-          encodeHeaders(pair.headers).pipe(Effect.mapError((error) => error.issue)),
+          encodeHeaders(pair.headers, options).pipe(Effect.mapError((error) => error.issue)),
           (headers) => Response.setHeaders(response, headers as any)
         ))
     }
@@ -1193,10 +1205,13 @@ function getResponseEncode<E>(
   status: number,
   encoding: HttpApiSchema.ResponseEncoding,
   isNoContent: boolean
-): (e: E) => Effect.Effect<Response.HttpServerResponse, SchemaIssue.InvalidValue, never> {
+): (
+  e: E,
+  options?: SchemaAST.ParseOptions
+) => Effect.Effect<Response.HttpServerResponse, SchemaIssue.InvalidValue, never> {
   switch (encoding._tag) {
     case "Json": {
-      return ((e) => {
+      return ((e, options) => {
         if (e === undefined || isNoContent) {
           return Effect.succeed(Response.empty({ status }))
         }
@@ -1205,7 +1220,11 @@ function getResponseEncode<E>(
           return Effect.succeed(Response.text(s, { status, contentType: encoding.contentType }))
         } catch {
           return Effect.fail(
-            new SchemaIssue.InvalidValue({ message: "Expected a JSON-serializable response body" })
+            new SchemaIssue.InvalidValue(
+              { expected: "a JSON-serializable response body" },
+              e,
+              options
+            )
           )
         }
       })

package/src/unstable/httpapi/HttpApiClient.ts

@@ -1065,41 +1065,59 @@ function getEncodePayloadSchemaFromBody(
   const out = $HttpBody.pipe(Schema.decodeTo(
     schema,
     SchemaTransformation.transformOrFail<unknown, HttpBody.HttpBody>({
-      decode() {
-        return Effect.fail(new SchemaIssue.Forbidden({ message: "Encode only schema" }))
+      decode(input, options) {
+        return Effect.fail(
+          new SchemaIssue.Forbidden({ message: "Encode only schema" }, input, options)
+        )
       },
-      encode(t) {
+      encode(t, options) {
         switch (encoding._tag) {
           case "Multipart":
-            return Effect.fail(new SchemaIssue.Forbidden({ message: "Payload must be a FormData" }))
+            return Effect.fail(
+              new SchemaIssue.Forbidden(
+                { message: "Payload must be a FormData" },
+                t,
+                options
+              )
+            )
           case "Json": {
             try {
               const body = JSON.stringify(t)
               return Effect.succeed(HttpBody.text(body, encoding.contentType))
             } catch {
               return Effect.fail(
-                new SchemaIssue.InvalidValue({ message: "Expected a JSON-serializable request body" })
+                new SchemaIssue.InvalidValue(
+                  { expected: "a JSON-serializable request body" },
+                  t,
+                  options
+                )
               )
             }
           }
           case "Text": {
             if (typeof t !== "string") {
               return Effect.fail(
-                new SchemaIssue.InvalidValue({ message: "Expected a string" })
+                new SchemaIssue.InvalidValue({ message: "Expected a string" }, t, options)
               )
             }
             return Effect.succeed(HttpBody.text(t, encoding.contentType))
           }
           case "FormUrlEncoded": {
             if (!Predicate.isObject(t)) {
-              return Effect.fail(new SchemaIssue.InvalidValue({ message: "Expected a record" }))
+              return Effect.fail(
+                new SchemaIssue.InvalidValue({ message: "Expected a record" }, t, options)
+              )
             }
             return Effect.succeed(HttpBody.urlParams(UrlParams.fromInput(t as any), encoding.contentType))
           }
           case "Uint8Array": {
             if (!(t instanceof Uint8Array)) {
               return Effect.fail(
-                new SchemaIssue.InvalidValue({ message: "Expected a Uint8Array" })
+                new SchemaIssue.InvalidValue(
+                  { message: "Expected a Uint8Array" },
+                  t,
+                  options
+                )
               )
             }
             return Effect.succeed(HttpBody.uint8Array(t, encoding.contentType))

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

package/src/unstable/rpc/RpcClient.ts

@@ -23,6 +23,7 @@ import * as Latch from "../../Latch.ts"
 import * as Layer from "../../Layer.ts"
 import * as Option from "../../Option.ts"
 import * as Pool from "../../Pool.ts"
+import * as Predicate from "../../Predicate.ts"
 import * as Queue from "../../Queue.ts"
 import * as Result from "../../Result.ts"
 import * as Schedule from "../../Schedule.ts"
@@ -51,6 +52,8 @@ import * as RpcSerialization from "./RpcSerialization.ts"
 import * as RpcWorker from "./RpcWorker.ts"
 import { withRunClient } from "./Utils.ts"
 
+const isRpcClientError = (u: unknown): u is RpcClientError => Predicate.isTagged(u, "RpcClientError")
+
 /**
  * The object-shaped client generated from a union of RPC definitions, with one
  * method per RPC tag.
@@ -974,7 +977,7 @@ export const makeProtocolHttp = (client: HttpClient.HttpClient): Effect.Effect<
             })
           })
         )).pipe(
-          Effect.mapError((cause) => cause instanceof RpcClientError ? cause : httpClientError(cause))
+          Effect.mapError((cause) => isRpcClientError(cause) ? cause : httpClientError(cause))
         )
       if (!hasResponse) {
         return yield* emptyResponseError(request)