effect 4.0.7 → 4.1.1

package/src/BigDecimal.ts

@@ -5,6 +5,9 @@
  * divide, round, and format decimal values such as money, quantities, and
  * measurements.
  *
+ * Parsed scales are limited to ±10,000, and operations that align scales throw
+ * a `RangeError` when the scales differ by more than 20,000.
+ *
  * @stability stable
  * @since 2.0.0
  */
@@ -21,6 +24,9 @@ import { type Pipeable, pipeArguments } from "./Pipeable.ts"
 import { hasProperty } from "./Predicate.ts"
 
 const DEFAULT_PRECISION = 100
+const MAX_SCALE = 10_000
+// Allows aligning values parsed at opposite bounds
+const MAX_SCALE_ALIGNMENT = 2 * MAX_SCALE
 const FINITE_INT_REGEXP = /^[+-]?\d+$/
 
 const TypeId = "~effect/BigDecimal"
@@ -211,15 +217,27 @@ export const normalize = (self: BigDecimal): BigDecimal => {
       self.normalized = zero
     } else {
       const digits = `${self.value}`
-      let end = digits.length
-      while (digits[end - 1] === "0") end--
-      self.normalized = makeNormalized(BigInt(digits.slice(0, end)), self.scale - (digits.length - end))
+      const zeros = trailingZeros(digits)
+      self.normalized = makeNormalized(BigInt(digits.slice(0, digits.length - zeros)), self.scale - zeros)
     }
   }
 
   return self.normalized
 }
 
+const trailingZeros = (digits: string): number => {
+  let end = digits.length
+  while (digits[end - 1] === "0") end--
+  return digits.length - end
+}
+
+const powerOfTen = (exponent: number): bigint => {
+  if (exponent > MAX_SCALE_ALIGNMENT) {
+    throw new RangeError(`Scale alignment must not exceed ${MAX_SCALE_ALIGNMENT} digits, got ${exponent}`)
+  }
+  return bigint10 ** BigInt(exponent)
+}
+
 /**
  * Changes a `BigDecimal` to the specified scale.
  *
@@ -233,6 +251,10 @@ export const normalize = (self: BigDecimal): BigDecimal => {
  * digits beyond the target scale by `bigint` division, which truncates toward
  * zero.
  *
+ * **Gotchas**
+ *
+ * Throws a `RangeError` if the scale changes by more than 20,000.
+ *
  * **Example** (Scaling decimal precision)
  *
  * ```ts import.meta.vitest
@@ -269,6 +291,10 @@ export const scale: {
    * digits beyond the target scale by `bigint` division, which truncates toward
    * zero.
    *
+   * **Gotchas**
+   *
+   * Throws a `RangeError` if the scale changes by more than 20,000.
+   *
    * **Example** (Scaling decimal precision)
    *
    * ```ts import.meta.vitest
@@ -305,6 +331,10 @@ export const scale: {
    * digits beyond the target scale by `bigint` division, which truncates toward
    * zero.
    *
+   * **Gotchas**
+   *
+   * Throws a `RangeError` if the scale changes by more than 20,000.
+   *
    * **Example** (Scaling decimal precision)
    *
    * ```ts import.meta.vitest
@@ -330,11 +360,11 @@ export const scale: {
   (self: BigDecimal, scale: number): BigDecimal
 } = dual(2, (self: BigDecimal, scale: number): BigDecimal => {
   if (scale > self.scale) {
-    return make(self.value * bigint10 ** BigInt(scale - self.scale), scale)
+    return make(self.value * powerOfTen(scale - self.scale), scale)
   }
 
   if (scale < self.scale) {
-    return make(self.value / bigint10 ** BigInt(self.scale - scale), scale)
+    return make(self.value / powerOfTen(self.scale - scale), scale)
   }
 
   return self
@@ -348,6 +378,10 @@ export const scale: {
  * Use when you need a decimal addition function for piping or higher-order APIs
  * while preserving decimal precision.
  *
+ * **Gotchas**
+ *
+ * Throws a `RangeError` if the operands' scales differ by more than 20,000.
+ *
  * **Example** (Adding decimals)
  *
  * ```ts import.meta.vitest
@@ -374,6 +408,10 @@ export const sum: {
    * Use when you need a decimal addition function for piping or higher-order APIs
    * while preserving decimal precision.
    *
+   * **Gotchas**
+   *
+   * Throws a `RangeError` if the operands' scales differ by more than 20,000.
+   *
    * **Example** (Adding decimals)
    *
    * ```ts import.meta.vitest
@@ -400,6 +438,10 @@ export const sum: {
    * Use when you need a decimal addition function for piping or higher-order APIs
    * while preserving decimal precision.
    *
+   * **Gotchas**
+   *
+   * Throws a `RangeError` if the operands' scales differ by more than 20,000.
+   *
    * **Example** (Adding decimals)
    *
    * ```ts import.meta.vitest
@@ -446,6 +488,10 @@ export const sum: {
  * Use when you need to aggregate decimal quantities with decimal precision
  * instead of converting through JavaScript numbers.
  *
+ * **Gotchas**
+ *
+ * Throws a `RangeError` if the operands' scales differ by more than 20,000.
+ *
  * **Example** (Adding multiple decimals)
  *
  * ```ts import.meta.vitest
@@ -598,6 +644,10 @@ export const multiplyAll = (collection: Iterable<BigDecimal>): BigDecimal => {
  *
  * Use to subtract one `BigDecimal` value from another.
  *
+ * **Gotchas**
+ *
+ * Throws a `RangeError` if the operands' scales differ by more than 20,000.
+ *
  * **Example** (Subtracting decimals)
  *
  * ```ts import.meta.vitest
@@ -621,6 +671,10 @@ export const subtract: {
    *
    * Use to subtract one `BigDecimal` value from another.
    *
+   * **Gotchas**
+   *
+   * Throws a `RangeError` if the operands' scales differ by more than 20,000.
+   *
    * **Example** (Subtracting decimals)
    *
    * ```ts import.meta.vitest
@@ -644,6 +698,10 @@ export const subtract: {
    *
    * Use to subtract one `BigDecimal` value from another.
    *
+   * **Gotchas**
+   *
+   * Throws a `RangeError` if the operands' scales differ by more than 20,000.
+   *
    * **Example** (Subtracting decimals)
    *
    * ```ts import.meta.vitest
@@ -1818,6 +1876,10 @@ export const negate = (n: BigDecimal): BigDecimal => make(-n.value, n.scale)
  *
  * If the divisor is `0`, the result will be `Option.none()`.
  *
+ * **Gotchas**
+ *
+ * Throws a `RangeError` if the operands' scales differ by more than 20,000.
+ *
  * **Example** (Computing remainders safely)
  *
  * ```ts import.meta.vitest
@@ -1852,6 +1914,10 @@ export const remainder: {
    *
    * If the divisor is `0`, the result will be `Option.none()`.
    *
+   * **Gotchas**
+   *
+   * Throws a `RangeError` if the operands' scales differ by more than 20,000.
+   *
    * **Example** (Computing remainders safely)
    *
    * ```ts import.meta.vitest
@@ -1886,6 +1952,10 @@ export const remainder: {
    *
    * If the divisor is `0`, the result will be `Option.none()`.
    *
+   * **Gotchas**
+   *
+   * Throws a `RangeError` if the operands' scales differ by more than 20,000.
+   *
    * **Example** (Computing remainders safely)
    *
    * ```ts import.meta.vitest
@@ -1927,7 +1997,8 @@ export const remainder: {
  *
  * **Gotchas**
  *
- * Throws a `RangeError` if the divisor is `0`.
+ * Throws a `RangeError` if the divisor is `0` or the operands' scales differ by
+ * more than 20,000.
  *
  * **Example** (Computing remainders unsafely)
  *
@@ -1958,7 +2029,8 @@ export const remainderUnsafe: {
    *
    * **Gotchas**
    *
-   * Throws a `RangeError` if the divisor is `0`.
+   * Throws a `RangeError` if the divisor is `0` or the operands' scales differ by
+   * more than 20,000.
    *
    * **Example** (Computing remainders unsafely)
    *
@@ -1989,7 +2061,8 @@ export const remainderUnsafe: {
    *
    * **Gotchas**
    *
-   * Throws a `RangeError` if the divisor is `0`.
+   * Throws a `RangeError` if the divisor is `0` or the operands' scales differ by
+   * more than 20,000.
    *
    * **Example** (Computing remainders unsafely)
    *
@@ -2245,8 +2318,9 @@ export const fromNumber = (n: number): Option.Option<BigDecimal> => {
  * **Details**
  *
  * Returns `Option.some` for valid decimal or exponent notation and
- * `Option.none` when the string cannot be parsed or would produce an unsafe
- * scale. The empty string parses as zero.
+ * `Option.none` otherwise, including when the scale, before or after removing
+ * trailing zeros, is outside ±10,000 (for example, more than 10,000 fractional
+ * digits). The empty string parses as zero.
  *
  * **Example** (Parsing decimal strings safely)
  *
@@ -2290,6 +2364,9 @@ export const fromString = (s: string): Option.Option<BigDecimal> => {
   if (dot !== -1) {
     const lead = base.slice(0, dot)
     const trail = base.slice(dot + 1)
+    if (!/^\d*$/.test(trail)) {
+      return Option.none()
+    }
     digits = `${lead}${trail}`
     offset = trail.length
   } else {
@@ -2302,11 +2379,14 @@ export const fromString = (s: string): Option.Option<BigDecimal> => {
   }
 
   const scale = offset - exp
-  if (!Number.isSafeInteger(scale)) {
+  const value = BigInt(digits)
+  // Keeps `format` output parseable
+  const normalizedScale = value === bigint0 ? scale : scale - trailingZeros(digits)
+  if (scale > MAX_SCALE || normalizedScale < -MAX_SCALE) {
     return Option.none()
   }
 
-  return Option.some(make(BigInt(digits), scale))
+  return Option.some(make(value, scale))
 }
 
 /**
@@ -2319,8 +2399,9 @@ export const fromString = (s: string): Option.Option<BigDecimal> => {
  *
  * **Details**
  *
- * Accepts the same syntax as `fromString`. Use `fromString` when invalid input
- * should be represented as `Option.none` instead of throwing.
+ * Accepts the same syntax and scale limits as `fromString`. Use `fromString`
+ * when invalid input should be represented as `Option.none` instead of
+ * throwing.
  *
  * **Example** (Parsing decimal strings unsafely)
  *
@@ -2593,6 +2674,15 @@ export type RoundingMode =
  *
  * Use to round a decimal at a requested scale with an explicit rounding mode.
  *
+ * **Details**
+ *
+ * Values already at or below the target scale are returned unchanged.
+ *
+ * **Gotchas**
+ *
+ * Throws a `RangeError` if the value's scale exceeds the target scale by more
+ * than 20,000.
+ *
  * **Example** (Rounding decimals)
  *
  * ```ts import.meta.vitest
@@ -2621,6 +2711,15 @@ export const round: {
    *
    * Use to round a decimal at a requested scale with an explicit rounding mode.
    *
+   * **Details**
+   *
+   * Values already at or below the target scale are returned unchanged.
+   *
+   * **Gotchas**
+   *
+   * Throws a `RangeError` if the value's scale exceeds the target scale by more
+   * than 20,000.
+   *
    * **Example** (Rounding decimals)
    *
    * ```ts import.meta.vitest
@@ -2649,6 +2748,15 @@ export const round: {
    *
    * Use to round a decimal at a requested scale with an explicit rounding mode.
    *
+   * **Details**
+   *
+   * Values already at or below the target scale are returned unchanged.
+   *
+   * **Gotchas**
+   *
+   * Throws a `RangeError` if the value's scale exceeds the target scale by more
+   * than 20,000.
+   *
    * **Example** (Rounding decimals)
    *
    * ```ts import.meta.vitest
@@ -2674,6 +2782,10 @@ export const round: {
   const mode = options?.mode ?? "half-from-zero"
   const scale = options?.scale ?? 0
 
+  if (self.scale <= scale) {
+    return self
+  }
+
   switch (mode) {
     case "ceil":
       return ceil(self, scale)
@@ -2726,6 +2838,11 @@ export const round: {
  * Use when you need to discard fractional digits beyond a scale rather than
  * round half up, half down, or toward an infinity.
  *
+ * **Gotchas**
+ *
+ * Throws a `RangeError` if the value's scale exceeds the target scale by more
+ * than 20,000.
+ *
  * **Example** (Truncating decimals)
  *
  * ```ts import.meta.vitest
@@ -2753,6 +2870,11 @@ export const truncate: {
    * Use when you need to discard fractional digits beyond a scale rather than
    * round half up, half down, or toward an infinity.
    *
+   * **Gotchas**
+   *
+   * Throws a `RangeError` if the value's scale exceeds the target scale by more
+   * than 20,000.
+   *
    * **Example** (Truncating decimals)
    *
    * ```ts import.meta.vitest
@@ -2780,6 +2902,11 @@ export const truncate: {
    * Use when you need to discard fractional digits beyond a scale rather than
    * round half up, half down, or toward an infinity.
    *
+   * **Gotchas**
+   *
+   * Throws a `RangeError` if the value's scale exceeds the target scale by more
+   * than 20,000.
+   *
    * **Example** (Truncating decimals)
    *
    * ```ts import.meta.vitest
@@ -2804,7 +2931,7 @@ export const truncate: {
   }
 
   // BigInt division truncates towards zero
-  return make(self.value / (bigint10 ** BigInt(self.scale - scale)), scale)
+  return make(self.value / powerOfTen(self.scale - scale), scale)
 })
 
 /**
@@ -2820,6 +2947,11 @@ export const truncate: {
  * decimal point, and negative scales round positions to the left of the decimal
  * point.
  *
+ * **Gotchas**
+ *
+ * Throws a `RangeError` if the value's scale exceeds the target scale by more
+ * than 20,000.
+ *
  * @see {@link floor} for rounding toward negative infinity
  * @see {@link truncate} for rounding toward zero
  * @see {@link round} for configurable rounding modes
@@ -2851,6 +2983,11 @@ export const ceil: {
    * decimal point, and negative scales round positions to the left of the decimal
    * point.
    *
+   * **Gotchas**
+   *
+   * Throws a `RangeError` if the value's scale exceeds the target scale by more
+   * than 20,000.
+   *
    * @see {@link floor} for rounding toward negative infinity
    * @see {@link truncate} for rounding toward zero
    * @see {@link round} for configurable rounding modes
@@ -2882,6 +3019,11 @@ export const ceil: {
    * decimal point, and negative scales round positions to the left of the decimal
    * point.
    *
+   * **Gotchas**
+   *
+   * Throws a `RangeError` if the value's scale exceeds the target scale by more
+   * than 20,000.
+   *
    * @see {@link floor} for rounding toward negative infinity
    * @see {@link truncate} for rounding toward zero
    * @see {@link round} for configurable rounding modes
@@ -2939,7 +3081,7 @@ export const digitAt: {
     return bigint0
   }
 
-  const scaled = self.value / (bigint10 ** BigInt(self.scale - scale))
+  const scaled = self.value / powerOfTen(self.scale - scale)
   return scaled % bigint10
 })
 
@@ -2950,6 +3092,11 @@ export const digitAt: {
  *
  * Use to round a decimal toward negative infinity at a requested scale.
  *
+ * **Gotchas**
+ *
+ * Throws a `RangeError` if the value's scale exceeds the target scale by more
+ * than 20,000.
+ *
  * **Example** (Rounding decimals down)
  *
  * ```ts import.meta.vitest
@@ -2975,6 +3122,11 @@ export const floor: {
    *
    * Use to round a decimal toward negative infinity at a requested scale.
    *
+   * **Gotchas**
+   *
+   * Throws a `RangeError` if the value's scale exceeds the target scale by more
+   * than 20,000.
+   *
    * **Example** (Rounding decimals down)
    *
    * ```ts import.meta.vitest
@@ -3000,6 +3152,11 @@ export const floor: {
    *
    * Use to round a decimal toward negative infinity at a requested scale.
    *
+   * **Gotchas**
+   *
+   * Throws a `RangeError` if the value's scale exceeds the target scale by more
+   * than 20,000.
+   *
    * **Example** (Rounding decimals down)
    *
    * ```ts import.meta.vitest

package/src/Channel.ts

@@ -22,7 +22,7 @@ import type * as Filter from "./Filter.ts"
 import type { LazyArg } from "./Function.ts"
 import { constant, constTrue, constVoid, dual, identity as identity_ } from "./Function.ts"
 import * as Count from "./internal/count.ts"
-import { ClockRef, endSpan, findRecoverableError } from "./internal/effect.ts"
+import { ClockRef, endSpan, findRecoverableError, ignoreCauseLogger } from "./internal/effect.ts"
 import { addSpanStackTrace } from "./internal/tracer.ts"
 import * as Iterable from "./Iterable.ts"
 import * as Latch from "./Latch.ts"
@@ -8095,6 +8095,9 @@ export const orDie = <
  * **Details**
  *
  * Use the `log` option to emit the full {@link Cause} when the channel fails.
+ * Set `log: "Unhandled"` to read `References.UnhandledLogLevel` when the
+ * failure occurs; `undefined` disables logging. Minimum log level filtering
+ * still applies.
  *
  * **Gotchas**
  *
@@ -8109,14 +8112,14 @@ export const orDie = <
  */
 export const ignore: <
   Arg extends Channel<any, any, any, any, any, any, any> | {
-    readonly log?: boolean | Severity | undefined
+    readonly log?: boolean | Severity | "Unhandled" | undefined
   } | undefined = {
-    readonly log?: boolean | Severity | undefined
+    readonly log?: boolean | Severity | "Unhandled" | undefined
   }
 >(
   selfOrOptions: Arg,
   options?: {
-    readonly log?: boolean | Severity | undefined
+    readonly log?: boolean | Severity | "Unhandled" | undefined
   } | undefined
 ) => [Arg] extends
   [Channel<infer OutElem, infer _OutErr, infer OutDone, infer InElem, infer InErr, infer InDone, infer Env>]
@@ -8128,13 +8131,13 @@ export const ignore: <
     <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
       self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
       options?: {
-        readonly log?: boolean | Severity | undefined
+        readonly log?: boolean | Severity | "Unhandled" | undefined
       } | undefined
     ): Channel<OutElem, never, OutDone | void, InElem, InErr, InDone, Env> => {
       if (!options?.log) {
         return catch_(self, () => empty)
       }
-      const logEffect = Effect.logWithLevel(options.log === true ? undefined : options.log)
+      const logEffect = ignoreCauseLogger(options.log)
       return catch_(
         tapCause(self, (cause) => Cause.hasFails(cause) ? logEffect(cause) : Effect.void),
         () => empty
@@ -8165,6 +8168,9 @@ const ignoreCause_ = <
  * **Details**
  *
  * Use the `log` option to emit the full {@link Cause} when the channel fails.
+ * Set `log: "Unhandled"` to read `References.UnhandledLogLevel` when the
+ * failure occurs; `undefined` disables logging. Minimum log level filtering
+ * still applies.
  *
  * @stability stable
  * @category error handling
@@ -8172,14 +8178,14 @@ const ignoreCause_ = <
  */
 export const ignoreCause: <
   Arg extends Channel<any, any, any, any, any, any, any> | {
-    readonly log?: boolean | Severity | undefined
+    readonly log?: boolean | Severity | "Unhandled" | undefined
   } | undefined = {
-    readonly log?: boolean | Severity | undefined
+    readonly log?: boolean | Severity | "Unhandled" | undefined
   }
 >(
   selfOrOptions: Arg,
   options?: {
-    readonly log?: boolean | Severity | undefined
+    readonly log?: boolean | Severity | "Unhandled" | undefined
   } | undefined
 ) => [Arg] extends
   [Channel<infer OutElem, infer _OutErr, infer OutDone, infer InElem, infer InErr, infer InDone, infer Env>]
@@ -8190,10 +8196,10 @@ export const ignoreCause: <
     (args) => isChannel(args[0]),
     <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
       self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
-      options?: { readonly log?: boolean | Severity | undefined } | undefined
+      options?: { readonly log?: boolean | Severity | "Unhandled" | undefined } | undefined
     ): Channel<OutElem, never, OutDone | void, InElem, InErr, InDone, Env> => {
       if (!options?.log) return ignoreCause_(self)
-      const logEffect = Effect.logWithLevel(options.log === true ? undefined : options.log)
+      const logEffect = ignoreCauseLogger(options.log)
       return ignoreCause_(tapCause(self, (cause) => logEffect(cause)))
     }
   )

package/src/Config.ts

@@ -1280,6 +1280,8 @@ interface ArrayOptions {
 interface RecordOptions {
   readonly separator?: string | undefined
   readonly keyValueSeparator?: string | undefined
+  readonly trim?: boolean | undefined
+  readonly keepEmptyValues?: boolean | undefined
 }
 
 const isPath = (u: unknown): u is string | Path => Predicate.isString(u) || globalThis.Array.isArray(u)
@@ -1588,7 +1590,11 @@ export function Array<V extends Schema.ConstraintCodec<unknown, unknown>>(
  *
  * Pass a string or `ConfigProvider.Path` as the third argument to set the lookup
  * path. When no path is needed, pass the options object directly. The `separator`
- * defaults to `","` and `keyValueSeparator` defaults to `"="`.
+ * defaults to `","` and `keyValueSeparator` defaults to `"="`. For string input,
+ * set `trim: true` to trim keys and values before entries with an empty key are
+ * skipped, and `keepEmptyValues: true` to keep entries with an empty value as
+ * `""` instead of skipping them. Entries without a `keyValueSeparator` are
+ * always skipped.
  *
  * **Example** (Reading a comma-separated record)
  *

package/src/Context.ts

@@ -642,6 +642,7 @@ interface ContextImpl<in Services> extends Context<Services> {
   overlay: Overlay | undefined
   depth: number
   _flat: ReadonlyMap<string, any> | undefined
+  maxDepth: number
 }
 
 interface Overlay {
@@ -650,7 +651,6 @@ interface Overlay {
   readonly parent: Overlay | undefined
 }
 
-const MaxDepth = 8
 // Keep small bases cheap to read; larger bases are worth copying only after
 // enough fall-throughs to amortize the copy.
 const FlattenAfterBaseHits = 8
@@ -659,7 +659,8 @@ const makeImpl = <Services>(
   cacheRoot: ContextImpl<any> | undefined,
   base: ReadonlyMap<string, any>,
   overlay: Overlay | undefined,
-  depth: number
+  depth: number,
+  maxDepth: number
 ): ContextImpl<Services> => {
   const self: ContextImpl<Services> = Object.create(Proto)
   self.cacheRoot = cacheRoot ?? self
@@ -668,6 +669,7 @@ const makeImpl = <Services>(
   self.depth = depth
   self._flat = undefined
   self.baseHits = 0
+  self.maxDepth = maxDepth
   return self
 }
 
@@ -688,7 +690,7 @@ const flatten = (self: ContextImpl<any>): ReadonlyMap<string, any> => {
 const withFlat = <B>(self: Context<any>, f: (map: Map<string, any>) => void): Context<B> => {
   const map = new Map(self.mapUnsafe)
   f(map)
-  return makeUnsafe(map)
+  return makeImpl(undefined, map, undefined, 0, (self as ContextImpl<any>).maxDepth)
 }
 
 // A private symbol so user code cannot forge a value that reads as absent
@@ -720,8 +722,23 @@ const lookup = (self: Context<any>, key: string): unknown => {
  * Use when constructing a low-level `Context` from a trusted map whose lifecycle
  * you control.
  *
+ * **Details**
+ *
+ * `options.maxDepth` sets how many `add` calls are kept as overlays before the
+ * context is rebased into a flat map (default `8`). Lower values make lookups
+ * cheaper, higher values make additions to a large base cheaper. Invalid
+ * values fall back to the default.
+ *
+ * Contexts derived with `add`, `pick`, `omit`, and `merge` keep the setting
+ * (`merge` from its first non-empty argument). `make`, `empty`, and `mergeAll`
+ * use the default. Layers are combined with `mergeAll`, so apply it to the
+ * final context rather than inside a layer.
+ *
  * **Gotchas**
  *
+ * Excessively large `maxDepth` values can cause stack overflow when overlays
+ * are materialized or rebased. Choose a modest value.
+ *
  * The provided map is retained without copying and must not be mutated after
  * construction. Prefer `empty`, `make`, `add`, or `merge` for normal Context
  * construction.
@@ -744,12 +761,18 @@ const lookup = (self: Context<any>, key: string): unknown => {
  * @category constructors
  * @since 4.0.0
  */
-export const makeUnsafe = <Services = never>(mapUnsafe: ReadonlyMap<string, any>): Context<Services> =>
-  makeImpl(undefined, mapUnsafe, undefined, 0)
+export const makeUnsafe = <Services = never>(
+  mapUnsafe: ReadonlyMap<string, any>,
+  options?: { readonly maxDepth?: number }
+): Context<Services> => {
+  const maxDepth = options?.maxDepth
+  // NaN or Infinity would never trigger a rebase, so fall back to the default
+  return makeImpl(undefined, mapUnsafe, undefined, 0, Number.isInteger(maxDepth) && maxDepth! >= 0 ? maxDepth! : 8)
+}
 
 const Proto: Omit<
   ContextImpl<never>,
-  "cacheRoot" | "base" | "overlay" | "depth" | "_flat" | "baseHits"
+  "cacheRoot" | "base" | "overlay" | "depth" | "_flat" | "baseHits" | "maxDepth"
 > = {
   get mapUnsafe() {
     return flatten(this as any as ContextImpl<any>)
@@ -1032,19 +1055,20 @@ export const addUnsafe = <Services, I, S>(
 ): Context<Services | I> => {
   const impl = self as ContextImpl<Services>
   const cacheRoot = cacheKeys.has(key) ? undefined : impl.cacheRoot
-  if (impl.depth >= MaxDepth) {
+  if (impl.depth >= impl.maxDepth) {
     // Avoid mapUnsafe: it would flatten the parent before copying.
     const map = new Map(impl._flat ?? impl.base)
     if (!impl._flat) applyOverlays(map, impl.overlay)
     map.set(key, service)
-    return makeImpl(cacheRoot, map, undefined, 0)
+    return makeImpl(cacheRoot, map, undefined, 0, impl.maxDepth)
   }
 
   return makeImpl(
     cacheRoot,
     impl.base,
     { key, value: service, parent: impl.overlay },
-    impl.depth + 1
+    impl.depth + 1,
+    impl.maxDepth
   )
 }
 
@@ -1993,7 +2017,7 @@ export const pick = <S extends ReadonlyArray<Key<any, any>>>(
       const value = lookup(self, key)
       if (value !== notFound) map.set(key, value)
     }
-    return makeUnsafe(map)
+    return makeImpl(undefined, map, undefined, 0, (self as ContextImpl<any>).maxDepth)
   }
   const keep = new Set(services.map((key) => key.key))
   return withFlat(self, (map) =>