effect 4.0.0-beta.6 → 4.0.0-beta.7

package/src/Stream.ts

@@ -472,7 +472,7 @@ export const fromEffectSchedule = <A, E, R, X, AS extends A, ES, RS>(
  * @since 2.0.0
  * @category Constructors
  */
-export const tick = (interval: Duration.DurationInput): Stream<void> =>
+export const tick = (interval: Duration.Input): Stream<void> =>
   fromPull(Effect.sync(() => {
     let first = true
     const effect = Effect.succeed(Arr.of<void>(undefined))
@@ -3317,7 +3317,7 @@ export const timeout: {
    * @since 2.0.0
    * @category Rate Limiting
    */
-  (duration: Duration.DurationInput): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>
+  (duration: Duration.Input): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>
   /**
    * Ends the stream if it does not produce a value within the specified duration.
    *
@@ -3341,10 +3341,10 @@ export const timeout: {
    * @since 2.0.0
    * @category Rate Limiting
    */
-  <A, E, R>(self: Stream<A, E, R>, duration: Duration.DurationInput): Stream<A, E, R>
+  <A, E, R>(self: Stream<A, E, R>, duration: Duration.Input): Stream<A, E, R>
 } = dual(
   2,
-  <A, E, R>(self: Stream<A, E, R>, duration: Duration.DurationInput): Stream<A, E, R> =>
+  <A, E, R>(self: Stream<A, E, R>, duration: Duration.Input): Stream<A, E, R> =>
     transformPull(self, (pull, _scope) =>
       Effect.succeed(Effect.timeoutOrElse(pull, {
         duration,
@@ -12175,7 +12175,7 @@ export const debounce: {
    * @since 2.0.0
    * @category Rate Limiting
    */
-  (duration: Duration.DurationInput): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>
+  (duration: Duration.Input): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>
   /**
    * Drops earlier elements within the debounce window and emits only the latest element after the pause.
    *
@@ -12199,15 +12199,15 @@ export const debounce: {
    * @since 2.0.0
    * @category Rate Limiting
    */
-  <A, E, R>(self: Stream<A, E, R>, duration: Duration.DurationInput): Stream<A, E, R>
+  <A, E, R>(self: Stream<A, E, R>, duration: Duration.Input): Stream<A, E, R>
 } = dual(
   2,
-  <A, E, R>(self: Stream<A, E, R>, duration: Duration.DurationInput): Stream<A, E, R> =>
+  <A, E, R>(self: Stream<A, E, R>, duration: Duration.Input): Stream<A, E, R> =>
     transformPull(
       self,
       Effect.fnUntraced(function*(pull, scope) {
         const clock = yield* Clock
-        const durationMs = Duration.toMillis(Duration.fromDurationInputUnsafe(duration))
+        const durationMs = Duration.toMillis(Duration.fromInputUnsafe(duration))
         let lastArr: Arr.NonEmptyReadonlyArray<A> | undefined
         let cause: Cause.Cause<Cause.Done | E> | undefined
         let emitAtMs = Infinity
@@ -12347,7 +12347,7 @@ export const throttleEffect: {
     options: {
       readonly cost: (arr: Arr.NonEmptyReadonlyArray<A>) => Effect.Effect<number, E2, R2>
       readonly units: number
-      readonly duration: Duration.DurationInput
+      readonly duration: Duration.Input
       readonly burst?: number | undefined
       readonly strategy?: "enforce" | "shape" | undefined
     }
@@ -12393,7 +12393,7 @@ export const throttleEffect: {
     options: {
       readonly cost: (arr: Arr.NonEmptyReadonlyArray<A>) => Effect.Effect<number, E2, R2>
       readonly units: number
-      readonly duration: Duration.DurationInput
+      readonly duration: Duration.Input
       readonly burst?: number | undefined
       readonly strategy?: "enforce" | "shape" | undefined
     }
@@ -12405,7 +12405,7 @@ export const throttleEffect: {
     options: {
       readonly cost: (arr: Arr.NonEmptyReadonlyArray<A>) => Effect.Effect<number, E2, R2>
       readonly units: number
-      readonly duration: Duration.DurationInput
+      readonly duration: Duration.Input
       readonly burst?: number | undefined
       readonly strategy?: "enforce" | "shape" | undefined
     }
@@ -12422,12 +12422,12 @@ const throttleEnforceEffect = <A, E, R, E2, R2>(
   self: Stream<A, E, R>,
   cost: (arr: Arr.NonEmptyReadonlyArray<A>) => Effect.Effect<number, E2, R2>,
   units: number,
-  duration: Duration.DurationInput,
+  duration: Duration.Input,
   burst: number
 ): Stream<A, E | E2, R | R2> =>
   transformPull(self, (pull) =>
     Effect.clockWith((clock) => {
-      const durationMs = Duration.toMillis(Duration.fromDurationInputUnsafe(duration))
+      const durationMs = Duration.toMillis(Duration.fromInputUnsafe(duration))
       const max = units + burst < 0 ? Number.POSITIVE_INFINITY : units + burst
       let tokens = units
       let timestampMs = clock.currentTimeMillisUnsafe()
@@ -12458,12 +12458,12 @@ const throttleShapeEffect = <A, E, R, E2, R2>(
   self: Stream<A, E, R>,
   cost: (arr: Arr.NonEmptyReadonlyArray<A>) => Effect.Effect<number, E2, R2>,
   units: number,
-  duration: Duration.DurationInput,
+  duration: Duration.Input,
   burst: number
 ): Stream<A, E | E2, R | R2> =>
   transformPull(self, (pull) =>
     Effect.clockWith((clock) => {
-      const durationMs = Duration.toMillis(Duration.fromDurationInputUnsafe(duration))
+      const durationMs = Duration.toMillis(Duration.fromInputUnsafe(duration))
       const max = units + burst < 0 ? Number.POSITIVE_INFINITY : units + burst
       let tokens = units
       let timestampMs = clock.currentTimeMillisUnsafe()
@@ -12576,7 +12576,7 @@ export const throttle: {
     options: {
       readonly cost: (arr: Arr.NonEmptyReadonlyArray<A>) => number
       readonly units: number
-      readonly duration: Duration.DurationInput
+      readonly duration: Duration.Input
       readonly burst?: number | undefined
       readonly strategy?: "enforce" | "shape" | undefined
     }
@@ -12621,7 +12621,7 @@ export const throttle: {
     options: {
       readonly cost: (arr: Arr.NonEmptyReadonlyArray<A>) => number
       readonly units: number
-      readonly duration: Duration.DurationInput
+      readonly duration: Duration.Input
       readonly burst?: number | undefined
       readonly strategy?: "enforce" | "shape" | undefined
     }
@@ -12633,7 +12633,7 @@ export const throttle: {
     options: {
       readonly cost: (arr: Arr.NonEmptyReadonlyArray<A>) => number
       readonly units: number
-      readonly duration: Duration.DurationInput
+      readonly duration: Duration.Input
       readonly burst?: number | undefined
       readonly strategy?: "enforce" | "shape" | undefined
     }
@@ -12771,7 +12771,7 @@ export const groupedWithin: {
    * @since 2.0.0
    * @category Grouping
    */
-  (chunkSize: number, duration: Duration.DurationInput): <A, E, R>(self: Stream<A, E, R>) => Stream<Array<A>, E, R>
+  (chunkSize: number, duration: Duration.Input): <A, E, R>(self: Stream<A, E, R>) => Stream<Array<A>, E, R>
   /**
    * Partitions the stream into arrays, emitting when the chunk size is reached
    * or the duration passes.
@@ -12795,11 +12795,11 @@ export const groupedWithin: {
    * @since 2.0.0
    * @category Grouping
    */
-  <A, E, R>(self: Stream<A, E, R>, chunkSize: number, duration: Duration.DurationInput): Stream<Array<A>, E, R>
+  <A, E, R>(self: Stream<A, E, R>, chunkSize: number, duration: Duration.Input): Stream<Array<A>, E, R>
 } = dual(3, <A, E, R>(
   self: Stream<A, E, R>,
   chunkSize: number,
-  duration: Duration.DurationInput
+  duration: Duration.Input
 ): Stream<Array<A>, E, R> =>
   aggregateWithin(
     self,
@@ -12874,7 +12874,7 @@ export const groupBy: {
     f: (a: NoInfer<A>) => Effect.Effect<readonly [K, V], E2, R2>,
     options?: {
       readonly bufferSize?: number | undefined
-      readonly idleTimeToLive?: Duration.DurationInput | undefined
+      readonly idleTimeToLive?: Duration.Input | undefined
     }
   ): <E, R>(self: Stream<A, E, R>) => Stream<readonly [K, Stream<V>], E | E2, R | R2>
   /**
@@ -12913,7 +12913,7 @@ export const groupBy: {
     f: (a: NoInfer<A>) => Effect.Effect<readonly [K, V], E2, R2>,
     options?: {
       readonly bufferSize?: number | undefined
-      readonly idleTimeToLive?: Duration.DurationInput | undefined
+      readonly idleTimeToLive?: Duration.Input | undefined
     }
   ): Stream<readonly [K, Stream<V>], E | E2, R | R2>
 } = dual((args) => isStream(args[0]), <A, E, R, K, V, E2, R2>(
@@ -12921,7 +12921,7 @@ export const groupBy: {
   f: (a: NoInfer<A>) => Effect.Effect<readonly [K, V], E2, R2>,
   options?: {
     readonly bufferSize?: number | undefined
-    readonly idleTimeToLive?: Duration.DurationInput | undefined
+    readonly idleTimeToLive?: Duration.Input | undefined
   }
 ): Stream<readonly [K, Stream<V>], E | E2, R | R2> =>
   groupByImpl(
@@ -13003,7 +13003,7 @@ export const groupByKey: {
     f: (a: NoInfer<A>) => K,
     options?: {
       readonly bufferSize?: number | undefined
-      readonly idleTimeToLive?: Duration.DurationInput | undefined
+      readonly idleTimeToLive?: Duration.Input | undefined
     }
   ): <E, R>(self: Stream<A, E, R>) => Stream<readonly [K, Stream<A>], E, R>
   /**
@@ -13040,7 +13040,7 @@ export const groupByKey: {
     f: (a: NoInfer<A>) => K,
     options?: {
       readonly bufferSize?: number | undefined
-      readonly idleTimeToLive?: Duration.DurationInput | undefined
+      readonly idleTimeToLive?: Duration.Input | undefined
     }
   ): Stream<readonly [K, Stream<A>], E, R>
 } = dual((args) => isStream(args[0]), <A, E, R, K>(
@@ -13048,7 +13048,7 @@ export const groupByKey: {
   f: (a: NoInfer<A>) => K,
   options?: {
     readonly bufferSize?: number | undefined
-    readonly idleTimeToLive?: Duration.DurationInput | undefined
+    readonly idleTimeToLive?: Duration.Input | undefined
   }
 ): Stream<readonly [K, Stream<A>], E, R> =>
   suspend(() => {
@@ -13146,7 +13146,7 @@ const groupByImpl = <A, E, R, K, V, E2, R2>(
   ) => Effect.Effect<void, E2, R2>,
   options?: {
     readonly bufferSize?: number | undefined
-    readonly idleTimeToLive?: Duration.DurationInput | undefined
+    readonly idleTimeToLive?: Duration.Input | undefined
   }
 ): Stream<readonly [K, Stream<V>], E | E2, R | R2> =>
   transformPullBracket(
@@ -13880,12 +13880,12 @@ export const share: {
     options: {
       readonly capacity: "unbounded"
       readonly replay?: number | undefined
-      readonly idleTimeToLive?: Duration.DurationInput | undefined
+      readonly idleTimeToLive?: Duration.Input | undefined
     } | {
       readonly capacity: number
       readonly strategy?: "sliding" | "dropping" | "suspend" | undefined
       readonly replay?: number | undefined
-      readonly idleTimeToLive?: Duration.DurationInput | undefined
+      readonly idleTimeToLive?: Duration.Input | undefined
     }
   ): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Stream<A, E>, never, Scope.Scope | R>
   /**
@@ -13924,12 +13924,12 @@ export const share: {
     options: {
       readonly capacity: "unbounded"
       readonly replay?: number | undefined
-      readonly idleTimeToLive?: Duration.DurationInput | undefined
+      readonly idleTimeToLive?: Duration.Input | undefined
     } | {
       readonly capacity: number
       readonly strategy?: "sliding" | "dropping" | "suspend" | undefined
       readonly replay?: number | undefined
-      readonly idleTimeToLive?: Duration.DurationInput | undefined
+      readonly idleTimeToLive?: Duration.Input | undefined
     }
   ): Effect.Effect<Stream<A, E>, never, Scope.Scope | R>
 } = dual(2, <A, E, R>(
@@ -13937,12 +13937,12 @@ export const share: {
   options: {
     readonly capacity: "unbounded"
     readonly replay?: number | undefined
-    readonly idleTimeToLive?: Duration.DurationInput | undefined
+    readonly idleTimeToLive?: Duration.Input | undefined
   } | {
     readonly capacity: number
     readonly strategy?: "sliding" | "dropping" | "suspend" | undefined
     readonly replay?: number | undefined
-    readonly idleTimeToLive?: Duration.DurationInput | undefined
+    readonly idleTimeToLive?: Duration.Input | undefined
   }
 ): Effect.Effect<Stream<A, E>, never, Scope.Scope | R> =>
   Effect.map(

package/src/index.ts

@@ -1137,6 +1137,57 @@ export * as FileSystem from "./FileSystem.ts"
 export * as Filter from "./Filter.ts"
 
 /**
+ * Utilities for converting arbitrary JavaScript values into human-readable
+ * strings, with support for circular references, redaction, and common JS
+ * types that `JSON.stringify` handles poorly.
+ *
+ * Mental model:
+ * - A `Formatter<Value, Format>` is a callable `(value: Value) => Format`.
+ * - {@link format} is the general-purpose pretty-printer: it handles
+ *   primitives, arrays, objects, `BigInt`, `Symbol`, `Date`, `RegExp`,
+ *   `Set`, `Map`, class instances, and circular references.
+ * - {@link formatJson} is a safe `JSON.stringify` wrapper that silently
+ *   drops circular references and applies redaction.
+ * - Both functions accept a `space` option for indentation control.
+ *
+ * Common tasks:
+ * - Pretty-print any value for debugging / logging -> {@link format}
+ * - Serialize to JSON safely (no circular throws) -> {@link formatJson}
+ * - Format a single object property key -> {@link formatPropertyKey}
+ * - Format a property path like `["a"]["b"]` -> {@link formatPath}
+ * - Format a `Date` to ISO string safely -> {@link formatDate}
+ *
+ * Gotchas:
+ * - {@link format} output is **not** valid JSON; use {@link formatJson} when
+ *   you need parseable JSON.
+ * - {@link format} calls `toString()` on objects by default; pass
+ *   `ignoreToString: true` to disable.
+ * - {@link formatJson} silently omits circular references (the key is
+ *   dropped from the output).
+ * - Values implementing the `Redactable` protocol are automatically
+ *   redacted by both {@link format} and {@link formatJson}.
+ *
+ * **Example** (Pretty-print a value)
+ *
+ * ```ts
+ * import { Formatter } from "effect"
+ *
+ * const obj = { name: "Alice", scores: [100, 97] }
+ * console.log(Formatter.format(obj))
+ * // {"name":"Alice","scores":[100,97]}
+ *
+ * console.log(Formatter.format(obj, { space: 2 }))
+ * // {
+ * //   "name": "Alice",
+ * //   "scores": [
+ * //     100,
+ * //     97
+ * //   ]
+ * // }
+ * ```
+ *
+ * See also: {@link Formatter}, {@link format}, {@link formatJson}
+ *
  * @since 4.0.0
  */
 export * as Formatter from "./Formatter.ts"
@@ -1401,6 +1452,89 @@ export * as JsonPatch from "./JsonPatch.ts"
 export * as JsonPointer from "./JsonPointer.ts"
 
 /**
+ * Convert JSON Schema documents between dialects (Draft-07, Draft-2020-12,
+ * OpenAPI 3.0, OpenAPI 3.1). All dialects are normalized to an internal
+ * `Document<"draft-2020-12">` representation before optional conversion to
+ * an output dialect.
+ *
+ * ## Mental model
+ *
+ * - **JsonSchema** — a plain object with string keys; represents any single
+ *   JSON Schema node.
+ * - **Dialect** — one of `"draft-07"`, `"draft-2020-12"`, `"openapi-3.1"`,
+ *   or `"openapi-3.0"`.
+ * - **Document** — a structured container holding a root `schema`, its
+ *   companion `definitions`, and the target `dialect`. Definitions are
+ *   stored separately from the root schema so they can be relocated when
+ *   converting between dialects.
+ * - **MultiDocument** — same as `Document` but carries multiple root
+ *   schemas (at least one). Useful when generating several schemas that
+ *   share a single definitions pool.
+ * - **Definitions** — a `Record<string, JsonSchema>` keyed by definition
+ *   name. The ref pointer prefix depends on the dialect.
+ * - **`from*` functions** — parse a raw JSON Schema object into the
+ *   canonical `Document<"draft-2020-12">`.
+ * - **`to*` functions** — convert from the canonical representation to a
+ *   specific output dialect.
+ *
+ * ## Common tasks
+ *
+ * - Parse a Draft-07 schema → {@link fromSchemaDraft07}
+ * - Parse a Draft-2020-12 schema → {@link fromSchemaDraft2020_12}
+ * - Parse an OpenAPI 3.1 schema → {@link fromSchemaOpenApi3_1}
+ * - Parse an OpenAPI 3.0 schema → {@link fromSchemaOpenApi3_0}
+ * - Convert to Draft-07 output → {@link toDocumentDraft07}
+ * - Convert to OpenAPI 3.1 output → {@link toMultiDocumentOpenApi3_1}
+ * - Resolve a `$ref` against definitions → {@link resolve$ref}
+ * - Inline the root `$ref` of a document → {@link resolveTopLevel$ref}
+ *
+ * ## Gotchas
+ *
+ * - All `from*` functions normalize to `Document<"draft-2020-12">`
+ *   regardless of the input dialect.
+ * - Unsupported or unrecognized JSON Schema keywords are silently dropped
+ *   during conversion.
+ * - Draft-07 tuple syntax (`items` as array + `additionalItems`) is
+ *   converted to 2020-12 form (`prefixItems` + `items`), and vice-versa.
+ * - OpenAPI 3.0 `nullable: true` is expanded into `type` arrays or
+ *   `anyOf` unions. The `nullable` keyword is removed.
+ * - OpenAPI 3.0 singular `example` is converted to `examples` (array).
+ * - {@link resolve$ref} only looks up the last segment of the ref path in
+ *   the definitions map; it does not follow arbitrary JSON Pointer paths.
+ *
+ * ## Quickstart
+ *
+ * **Example** (Parse a Draft-07 schema and convert to Draft-07 output)
+ *
+ * ```ts
+ * import { JsonSchema } from "effect"
+ *
+ * const raw: JsonSchema.JsonSchema = {
+ *   type: "object",
+ *   properties: {
+ *     name: { type: "string" }
+ *   },
+ *   required: ["name"]
+ * }
+ *
+ * // Parse into canonical form
+ * const doc = JsonSchema.fromSchemaDraft07(raw)
+ *
+ * // Convert back to Draft-07
+ * const draft07 = JsonSchema.toDocumentDraft07(doc)
+ *
+ * console.log(draft07.dialect) // "draft-07"
+ * console.log(draft07.schema) // { type: "object", properties: { name: { type: "string" } }, required: ["name"] }
+ * ```
+ *
+ * ## See also
+ *
+ * - {@link Document}
+ * - {@link MultiDocument}
+ * - {@link fromSchemaDraft07}
+ * - {@link toDocumentDraft07}
+ * - {@link resolve$ref}
+ *
  * @since 4.0.0
  */
 export * as JsonSchema from "./JsonSchema.ts"

package/src/internal/dateTime.ts

@@ -12,7 +12,6 @@ import * as Inspectable from "../Inspectable.ts"
 import * as order from "../Order.ts"
 import { pipeArguments } from "../Pipeable.ts"
 import * as Predicate from "../Predicate.ts"
-import * as Result from "../Result.ts"
 import type { Mutable } from "../Types.ts"
 import * as UndefinedOr from "../UndefinedOr.ts"
 import * as effect from "./effect.ts"
@@ -467,32 +466,12 @@ export const setZoneNamedUnsafe: {
 
 /** @internal */
 export const distance: {
-  (other: DateTime.DateTime): (self: DateTime.DateTime) => number
-  (self: DateTime.DateTime, other: DateTime.DateTime): number
-} = dual(2, (self: DateTime.DateTime, other: DateTime.DateTime): number => toEpochMillis(other) - toEpochMillis(self))
-
-/** @internal */
-export const distanceDurationResult: {
-  (other: DateTime.DateTime): (self: DateTime.DateTime) => Result.Result<Duration.Duration, Duration.Duration>
-  (self: DateTime.DateTime, other: DateTime.DateTime): Result.Result<Duration.Duration, Duration.Duration>
-} = dual(
-  2,
-  (self: DateTime.DateTime, other: DateTime.DateTime): Result.Result<Duration.Duration, Duration.Duration> => {
-    const diffMillis = distance(self, other)
-    return diffMillis > 0
-      ? Result.succeed(Duration.millis(diffMillis))
-      : Result.fail(Duration.millis(-diffMillis))
-  }
-)
-
-/** @internal */
-export const distanceDuration: {
   (other: DateTime.DateTime): (self: DateTime.DateTime) => Duration.Duration
   (self: DateTime.DateTime, other: DateTime.DateTime): Duration.Duration
 } = dual(
   2,
   (self: DateTime.DateTime, other: DateTime.DateTime): Duration.Duration =>
-    Duration.millis(Math.abs(distance(self, other)))
+    Duration.millis(toEpochMillis(other) - toEpochMillis(self))
 )
 
 /** @internal */
@@ -911,22 +890,22 @@ export const match: {
 
 /** @internal */
 export const addDuration: {
-  (duration: Duration.DurationInput): <A extends DateTime.DateTime>(self: A) => A
-  <A extends DateTime.DateTime>(self: A, duration: Duration.DurationInput): A
+  (duration: Duration.Input): <A extends DateTime.DateTime>(self: A) => A
+  <A extends DateTime.DateTime>(self: A, duration: Duration.Input): A
 } = dual(
   2,
-  (self: DateTime.DateTime, duration: Duration.DurationInput): DateTime.DateTime =>
-    mapEpochMillis(self, (millis) => millis + Duration.toMillis(Duration.fromDurationInputUnsafe(duration)))
+  (self: DateTime.DateTime, duration: Duration.Input): DateTime.DateTime =>
+    mapEpochMillis(self, (millis) => millis + Duration.toMillis(Duration.fromInputUnsafe(duration)))
 )
 
 /** @internal */
 export const subtractDuration: {
-  (duration: Duration.DurationInput): <A extends DateTime.DateTime>(self: A) => A
-  <A extends DateTime.DateTime>(self: A, duration: Duration.DurationInput): A
+  (duration: Duration.Input): <A extends DateTime.DateTime>(self: A) => A
+  <A extends DateTime.DateTime>(self: A, duration: Duration.Input): A
 } = dual(
   2,
-  (self: DateTime.DateTime, duration: Duration.DurationInput): DateTime.DateTime =>
-    mapEpochMillis(self, (millis) => millis - Duration.toMillis(Duration.fromDurationInputUnsafe(duration)))
+  (self: DateTime.DateTime, duration: Duration.Input): DateTime.DateTime =>
+    mapEpochMillis(self, (millis) => millis - Duration.toMillis(Duration.fromInputUnsafe(duration)))
 )
 
 const addMillis = (date: Date, amount: number): void => {

package/src/internal/effect.ts

@@ -3404,24 +3404,24 @@ export const isSuccess: <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect
 /** @internal */
 export const delay: {
   (
-    duration: Duration.DurationInput
+    duration: Duration.Input
   ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
-    duration: Duration.DurationInput
+    duration: Duration.Input
   ): Effect.Effect<A, E, R>
 } = dual(
   2,
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
-    duration: Duration.DurationInput
+    duration: Duration.Input
   ): Effect.Effect<A, E, R> => andThen(sleep(duration), self)
 )
 
 /** @internal */
 export const timeoutOrElse: {
   <A2, E2, R2>(options: {
-    readonly duration: Duration.DurationInput
+    readonly duration: Duration.Input
     readonly onTimeout: LazyArg<Effect.Effect<A2, E2, R2>>
   }): <A, E, R>(
     self: Effect.Effect<A, E, R>
@@ -3429,7 +3429,7 @@ export const timeoutOrElse: {
   <A, E, R, A2, E2, R2>(
     self: Effect.Effect<A, E, R>,
     options: {
-      readonly duration: Duration.DurationInput
+      readonly duration: Duration.Input
       readonly onTimeout: LazyArg<Effect.Effect<A2, E2, R2>>
     }
   ): Effect.Effect<A | A2, E | E2, R | R2>
@@ -3438,7 +3438,7 @@ export const timeoutOrElse: {
   <A, E, R, A2, E2, R2>(
     self: Effect.Effect<A, E, R>,
     options: {
-      readonly duration: Duration.DurationInput
+      readonly duration: Duration.Input
       readonly onTimeout: LazyArg<Effect.Effect<A2, E2, R2>>
     }
   ): Effect.Effect<A | A2, E | E2, R | R2> =>
@@ -3451,19 +3451,19 @@ export const timeoutOrElse: {
 /** @internal */
 export const timeout: {
   (
-    duration: Duration.DurationInput
+    duration: Duration.Input
   ): <A, E, R>(
     self: Effect.Effect<A, E, R>
   ) => Effect.Effect<A, E | Cause.TimeoutError, R>
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
-    duration: Duration.DurationInput
+    duration: Duration.Input
   ): Effect.Effect<A, E | Cause.TimeoutError, R>
 } = dual(
   2,
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
-    duration: Duration.DurationInput
+    duration: Duration.Input
   ): Effect.Effect<A, E | TimeoutError, R> =>
     timeoutOrElse(self, {
       duration,
@@ -3474,19 +3474,19 @@ export const timeout: {
 /** @internal */
 export const timeoutOption: {
   (
-    duration: Duration.DurationInput
+    duration: Duration.Input
   ): <A, E, R>(
     self: Effect.Effect<A, E, R>
   ) => Effect.Effect<Option.Option<A>, E, R>
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
-    duration: Duration.DurationInput
+    duration: Duration.Input
   ): Effect.Effect<Option.Option<A>, E, R>
 } = dual(
   2,
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
-    duration: Duration.DurationInput
+    duration: Duration.Input
   ): Effect.Effect<Option.Option<A>, E, R> =>
     raceFirst(
       asSome(self),
@@ -3874,19 +3874,19 @@ export const acquireUseRelease = <Resource, E, R, A, E2, R2, E3, R3>(
 
 /** @internal */
 export const cachedInvalidateWithTTL: {
-  (timeToLive: Duration.DurationInput): <A, E, R>(
+  (timeToLive: Duration.Input): <A, E, R>(
     self: Effect.Effect<A, E, R>
   ) => Effect.Effect<[Effect.Effect<A, E, R>, Effect.Effect<void>]>
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
-    timeToLive: Duration.DurationInput
+    timeToLive: Duration.Input
   ): Effect.Effect<[Effect.Effect<A, E, R>, Effect.Effect<void>]>
 } = dual(2, <A, E, R>(
   self: Effect.Effect<A, E, R>,
-  ttl: Duration.DurationInput
+  ttl: Duration.Input
 ): Effect.Effect<[Effect.Effect<A, E, R>, Effect.Effect<void>]> =>
   sync(() => {
-    const ttlMillis = Duration.toMillis(Duration.fromDurationInputUnsafe(ttl))
+    const ttlMillis = Duration.toMillis(Duration.fromInputUnsafe(ttl))
     const isFinite = Number.isFinite(ttlMillis)
     const latch = makeLatchUnsafe(false)
     let expiresAt = 0
@@ -3919,17 +3919,17 @@ export const cachedInvalidateWithTTL: {
 /** @internal */
 export const cachedWithTTL: {
   (
-    timeToLive: Duration.DurationInput
+    timeToLive: Duration.Input
   ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<Effect.Effect<A, E, R>>
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
-    timeToLive: Duration.DurationInput
+    timeToLive: Duration.Input
   ): Effect.Effect<Effect.Effect<A, E, R>>
 } = dual(
   2,
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
-    timeToLive: Duration.DurationInput
+    timeToLive: Duration.Input
   ): Effect.Effect<Effect.Effect<A, E, R>> => map(cachedInvalidateWithTTL(self, timeToLive), (tuple) => tuple[0])
 )
 
@@ -5345,8 +5345,8 @@ export const clockWith = <A, E, R>(f: (clock: Clock.Clock) => Effect.Effect<A, E
   withFiber((fiber) => f(fiber.getRef(ClockRef)))
 
 /** @internal */
-export const sleep = (duration: Duration.DurationInput): Effect.Effect<void> =>
-  clockWith((clock) => clock.sleep(Duration.fromDurationInputUnsafe(duration)))
+export const sleep = (duration: Duration.Input): Effect.Effect<void> =>
+  clockWith((clock) => clock.sleep(Duration.fromInputUnsafe(duration)))
 
 /** @internal */
 export const currentTimeMillis: Effect.Effect<number> = clockWith((clock) => clock.currentTimeMillis)

package/src/internal/random.ts

@@ -0,0 +1,20 @@
+import * as ServiceMap from "../ServiceMap.ts"
+
+/** @internal */
+export interface Random {
+  nextIntUnsafe(): number
+  nextDoubleUnsafe(): number
+}
+
+/** @internal */
+export const Random: ServiceMap.Reference<Random> = ServiceMap.Reference<Random>("effect/Random", {
+  defaultValue: () => ({
+    nextIntUnsafe() {
+      return Math.floor(Math.random() * (Number.MAX_SAFE_INTEGER - Number.MIN_SAFE_INTEGER + 1)) +
+        Number.MIN_SAFE_INTEGER
+    },
+    nextDoubleUnsafe() {
+      return Math.random()
+    }
+  })
+})

package/src/internal/rcRef.ts

@@ -70,7 +70,7 @@ class RcRefImpl<A, E> implements RcRef.RcRef<A, E> {
 /** @internal */
 export const make = <A, E, R>(options: {
   readonly acquire: Effect.Effect<A, E, R>
-  readonly idleTimeToLive?: Duration.DurationInput | undefined
+  readonly idleTimeToLive?: Duration.Input | undefined
 }) =>
   Effect.withFiber<RcRef.RcRef<A, E>, never, R | Scope.Scope>((fiber) => {
     const services = fiber.services as ServiceMap.ServiceMap<R | Scope.Scope>
@@ -79,7 +79,7 @@ export const make = <A, E, R>(options: {
       options.acquire as Effect.Effect<A, E>,
       services,
       scope,
-      options.idleTimeToLive ? Duration.fromDurationInputUnsafe(options.idleTimeToLive) : undefined
+      options.idleTimeToLive ? Duration.fromInputUnsafe(options.idleTimeToLive) : undefined
     )
     return Effect.as(
       Scope.addFinalizerExit(scope, () => {