effect 4.0.0-beta.2 → 4.0.0-beta.21

package/src/unstable/observability/Otlp.ts

@@ -28,13 +28,13 @@ export const layer = (options: {
   readonly headers?: Headers.Input | undefined
   readonly maxBatchSize?: number | undefined
   readonly tracerContext?: (<X>(primitive: Tracer.EffectPrimitive<X>, span: Tracer.AnySpan) => X) | undefined
-  readonly loggerExportInterval?: Duration.DurationInput | undefined
+  readonly loggerExportInterval?: Duration.Input | undefined
   readonly loggerExcludeLogSpans?: boolean | undefined
   readonly loggerMergeWithExisting?: boolean | undefined
-  readonly metricsExportInterval?: Duration.DurationInput | undefined
+  readonly metricsExportInterval?: Duration.Input | undefined
   readonly metricsTemporality?: AggregationTemporality | undefined
-  readonly tracerExportInterval?: Duration.DurationInput | undefined
-  readonly shutdownTimeout?: Duration.DurationInput | undefined
+  readonly tracerExportInterval?: Duration.Input | undefined
+  readonly shutdownTimeout?: Duration.Input | undefined
 }): Layer.Layer<never, never, HttpClient.HttpClient | OtlpSerialization.OtlpSerialization> => {
   const base = HttpClientRequest.get(options.baseUrl)
   const url = (path: string) => HttpClientRequest.appendUrl(base, path).url
@@ -83,13 +83,13 @@ export const layerJson: (options: {
   readonly headers?: Headers.Input | undefined
   readonly maxBatchSize?: number | undefined
   readonly tracerContext?: (<X>(primitive: Tracer.EffectPrimitive<X>, span: Tracer.AnySpan) => X) | undefined
-  readonly loggerExportInterval?: Duration.DurationInput | undefined
+  readonly loggerExportInterval?: Duration.Input | undefined
   readonly loggerExcludeLogSpans?: boolean | undefined
   readonly loggerMergeWithExisting?: boolean | undefined
-  readonly metricsExportInterval?: Duration.DurationInput | undefined
+  readonly metricsExportInterval?: Duration.Input | undefined
   readonly metricsTemporality?: AggregationTemporality | undefined
-  readonly tracerExportInterval?: Duration.DurationInput | undefined
-  readonly shutdownTimeout?: Duration.DurationInput | undefined
+  readonly tracerExportInterval?: Duration.Input | undefined
+  readonly shutdownTimeout?: Duration.Input | undefined
 }) => Layer.Layer<never, never, HttpClient.HttpClient> = flow(layer, Layer.provide(OtlpSerialization.layerJson))
 
 /**
@@ -106,11 +106,11 @@ export const layerProtobuf: (options: {
   readonly headers?: Headers.Input | undefined
   readonly maxBatchSize?: number | undefined
   readonly tracerContext?: (<X>(primitive: Tracer.EffectPrimitive<X>, span: Tracer.AnySpan) => X) | undefined
-  readonly loggerExportInterval?: Duration.DurationInput | undefined
+  readonly loggerExportInterval?: Duration.Input | undefined
   readonly loggerExcludeLogSpans?: boolean | undefined
   readonly loggerMergeWithExisting?: boolean | undefined
-  readonly metricsExportInterval?: Duration.DurationInput | undefined
+  readonly metricsExportInterval?: Duration.Input | undefined
   readonly metricsTemporality?: AggregationTemporality | undefined
-  readonly tracerExportInterval?: Duration.DurationInput | undefined
-  readonly shutdownTimeout?: Duration.DurationInput | undefined
+  readonly tracerExportInterval?: Duration.Input | undefined
+  readonly shutdownTimeout?: Duration.Input | undefined
 }) => Layer.Layer<never, never, HttpClient.HttpClient> = flow(layer, Layer.provide(OtlpSerialization.layerProtobuf))

package/src/unstable/observability/OtlpExporter.ts

@@ -40,10 +40,10 @@ export const make: (
     readonly url: string
     readonly headers: Headers.Input | undefined
     readonly label: string
-    readonly exportInterval: Duration.DurationInput
+    readonly exportInterval: Duration.Input
     readonly maxBatchSize: number | "disabled"
     readonly body: (data: Array<any>) => HttpBody
-    readonly shutdownTimeout: Duration.DurationInput
+    readonly shutdownTimeout: Duration.Input
   }
 ) => Effect.Effect<
   { readonly push: (data: unknown) => void },
@@ -54,7 +54,7 @@ export const make: (
   const clock = ServiceMap.get(services, Clock)
   const scope = ServiceMap.get(services, Scope.Scope)
   const runFork = Effect.runForkWith(services)
-  const exportInterval = Duration.max(Duration.fromDurationInputUnsafe(options.exportInterval), Duration.zero)
+  const exportInterval = Duration.max(Duration.fromInputUnsafe(options.exportInterval), Duration.zero)
   let disabledUntil: number | undefined = undefined
 
   const client = HttpClient.filterStatusOk(ServiceMap.get(services, HttpClient.HttpClient)).pipe(

package/src/unstable/observability/OtlpLogger.ts

@@ -3,6 +3,7 @@
  */
 import * as Arr from "../../Array.ts"
 import * as Cause from "../../Cause.ts"
+import { Clock } from "../../Clock.ts"
 import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import type * as Layer from "../../Layer.ts"
@@ -30,9 +31,9 @@ export const make: (
       readonly attributes?: Record<string, unknown>
     } | undefined
     readonly headers?: Headers.Input | undefined
-    readonly exportInterval?: Duration.DurationInput | undefined
+    readonly exportInterval?: Duration.Input | undefined
     readonly maxBatchSize?: number | undefined
-    readonly shutdownTimeout?: Duration.DurationInput | undefined
+    readonly shutdownTimeout?: Duration.Input | undefined
     readonly excludeLogSpans?: boolean | undefined
   }
 ) => Effect.Effect<
@@ -66,7 +67,8 @@ export const make: (
   })
 
   const opts = {
-    excludeLogSpans: options.excludeLogSpans ?? false
+    excludeLogSpans: options.excludeLogSpans ?? false,
+    clock: yield* Clock
   }
   return Logger.make((options) => {
     exporter.push(makeLogRecord(options, opts))
@@ -85,9 +87,9 @@ export const layer = (options: {
     readonly attributes?: Record<string, unknown>
   } | undefined
   readonly headers?: Headers.Input | undefined
-  readonly exportInterval?: Duration.DurationInput | undefined
+  readonly exportInterval?: Duration.Input | undefined
   readonly maxBatchSize?: number | undefined
-  readonly shutdownTimeout?: Duration.DurationInput | undefined
+  readonly shutdownTimeout?: Duration.Input | undefined
   readonly excludeLogSpans?: boolean | undefined
   readonly mergeWithExisting?: boolean | undefined
 }): Layer.Layer<never, never, HttpClient.HttpClient | OtlpSerialization> =>
@@ -104,11 +106,13 @@ export interface LogsData {
 
 // internal
 
-const makeLogRecord = (options: Logger.Logger.Options<unknown>, opts: {
+const makeLogRecord = (options: Logger.Options<unknown>, opts: {
   readonly excludeLogSpans: boolean
+  readonly clock: Clock
 }): ILogRecord => {
-  const now = options.date.getTime()
-  const nanosString = `${now}000000`
+  const now = opts.clock.currentTimeNanosUnsafe()
+  const nanosString = now.toString()
+  const nowMillis = options.date.getTime()
 
   const attributes = OtlpResource.entriesToAttributes(Object.entries(options.fiber.getRef(CurrentLogAnnotations)))
   attributes.push({
@@ -119,7 +123,7 @@ const makeLogRecord = (options: Logger.Logger.Options<unknown>, opts: {
     for (const [label, startTime] of options.fiber.getRef(CurrentLogSpans)) {
       attributes.push({
         key: `logSpan.${label}`,
-        value: { stringValue: `${now - startTime}ms` }
+        value: { stringValue: `${nowMillis - startTime}ms` }
       })
     }
   }

package/src/unstable/observability/OtlpMetrics.ts

@@ -60,8 +60,8 @@ export const make: (options: {
     readonly attributes?: Record<string, unknown>
   } | undefined
   readonly headers?: Headers.Input | undefined
-  readonly exportInterval?: Duration.DurationInput | undefined
-  readonly shutdownTimeout?: Duration.DurationInput | undefined
+  readonly exportInterval?: Duration.Input | undefined
+  readonly shutdownTimeout?: Duration.Input | undefined
   readonly temporality?: AggregationTemporality | undefined
 }) => Effect.Effect<
   void,
@@ -440,8 +440,8 @@ export const layer = (options: {
     readonly attributes?: Record<string, unknown>
   } | undefined
   readonly headers?: Headers.Input | undefined
-  readonly exportInterval?: Duration.DurationInput | undefined
-  readonly shutdownTimeout?: Duration.DurationInput | undefined
+  readonly exportInterval?: Duration.Input | undefined
+  readonly shutdownTimeout?: Duration.Input | undefined
   readonly temporality?: AggregationTemporality | undefined
 }): Layer.Layer<never, never, HttpClient.HttpClient | OtlpSerialization> => Layer.effectDiscard(make(options))
 

package/src/unstable/observability/OtlpTracer.ts

@@ -32,10 +32,10 @@ export const make: (
       readonly attributes?: Record<string, unknown>
     } | undefined
     readonly headers?: Headers.Input | undefined
-    readonly exportInterval?: Duration.DurationInput | undefined
+    readonly exportInterval?: Duration.Input | undefined
     readonly maxBatchSize?: number | undefined
     readonly context?: (<X>(primitive: Tracer.EffectPrimitive<X>, span: Tracer.AnySpan) => X) | undefined
-    readonly shutdownTimeout?: Duration.DurationInput | undefined
+    readonly shutdownTimeout?: Duration.Input | undefined
   }
 ) => Effect.Effect<
   Tracer.Tracer,
@@ -109,10 +109,10 @@ export const layer: (options: {
     readonly attributes?: Record<string, unknown>
   } | undefined
   readonly headers?: Headers.Input | undefined
-  readonly exportInterval?: Duration.DurationInput | undefined
+  readonly exportInterval?: Duration.Input | undefined
   readonly maxBatchSize?: number | undefined
   readonly context?: (<X>(primitive: Tracer.EffectPrimitive<X>, span: Tracer.AnySpan) => X) | undefined
-  readonly shutdownTimeout?: Duration.DurationInput | undefined
+  readonly shutdownTimeout?: Duration.Input | undefined
 }) => Layer.Layer<never, never, OtlpSerialization | HttpClient.HttpClient> = flow(make, Layer.effect(Tracer.Tracer))
 
 // internal

package/src/unstable/persistence/KeyValueStore.ts

@@ -3,7 +3,7 @@
  */
 import * as Data from "../../Data.ts"
 import * as Effect from "../../Effect.ts"
-import * as Base64 from "../../encoding/Base64.ts"
+import * as Encoding from "../../Encoding.ts"
 import * as FileSystem from "../../FileSystem.ts"
 import { dual, identity, type LazyArg } from "../../Function.ts"
 import * as Layer from "../../Layer.ts"
@@ -225,7 +225,7 @@ export const makeStringOnly = (
     getUint8Array: (key) =>
       options.get(key).pipe(
         Effect.map(UndefinedOr.map((value) =>
-          Result.match(Base64.decode(value), {
+          Result.match(Encoding.decodeBase64(value), {
             onFailure: () => encoder.encode(value),
             onSuccess: identity
           })
@@ -234,7 +234,7 @@ export const makeStringOnly = (
     set: (key, value) =>
       typeof value === "string"
         ? options.set(key, value)
-        : Effect.suspend(() => options.set(key, Base64.encode(value)))
+        : Effect.suspend(() => options.set(key, Encoding.encodeBase64(value)))
   })
 }
 
@@ -276,7 +276,7 @@ export const layerMemory: Layer.Layer<KeyValueStore> = Layer.sync(KeyValueStore)
     get: (key: string) =>
       Effect.sync(() => {
         const value = store.get(key)
-        return value === undefined ? undefined : typeof value === "string" ? value : Base64.encode(value)
+        return value === undefined ? undefined : typeof value === "string" ? value : Encoding.encodeBase64(value)
       }),
     getUint8Array: (key: string) =>
       Effect.sync(() => {
@@ -312,7 +312,7 @@ export const layerFileSystem = (
           fs.readFileString(keyPath(key)),
           "PlatformError",
           (cause) =>
-            cause.reason._tag === "SystemError" && cause.reason.kind === "NotFound" ? Effect.undefined : Effect.fail(
+            cause.reason._tag === "NotFound" ? Effect.undefined : Effect.fail(
               new KeyValueStoreError({
                 method: "get",
                 key,
@@ -326,7 +326,7 @@ export const layerFileSystem = (
           fs.readFile(keyPath(key)),
           "PlatformError",
           (cause) =>
-            cause.reason._tag === "SystemError" && cause.reason.kind === "NotFound" ? Effect.undefined : Effect.fail(
+            cause.reason._tag === "NotFound" ? Effect.undefined : Effect.fail(
               new KeyValueStoreError({
                 method: "getUint8Array",
                 key,

package/src/unstable/persistence/Persistable.ts

@@ -1,7 +1,7 @@
 /**
  * @since 4.0.0
  */
-import type { DurationInput } from "../../Duration.ts"
+import type * as Duration from "../../Duration.ts"
 import type * as Effect from "../../Effect.ts"
 import type * as Exit from "../../Exit.ts"
 import * as PrimaryKey from "../../PrimaryKey.ts"
@@ -87,7 +87,7 @@ export type Services<A extends Any> =
  * @since 4.0.0
  * @category Models
  */
-export type TimeToLiveFn<K extends Any> = (exit: Exit.Exit<Success<K>, Error<K>>, request: K) => DurationInput
+export type TimeToLiveFn<K extends Any> = (exit: Exit.Exit<Success<K>, Error<K>>, request: K) => Duration.Input
 
 /**
  * @since 4.0.0

package/src/unstable/persistence/PersistedCache.ts

@@ -17,18 +17,18 @@ const TypeId = "~effect/persistence/PersistedCache" as const
  * @since 4.0.0
  * @category Models
  */
-export interface PersistedCache<K extends Persistable.Any> {
+export interface PersistedCache<K extends Persistable.Any, out R = never> {
   readonly [TypeId]: typeof TypeId
   readonly inMemory: Cache.Cache<
     K,
     Persistable.Success<K>,
     Persistable.Error<K> | Persistence.PersistenceError | Schema.SchemaError,
-    Persistable.Services<K>
+    Persistable.Services<K> | R
   >
   readonly get: (key: K) => Effect.Effect<
     Persistable.Success<K>,
     Persistable.Error<K> | Persistence.PersistenceError | Schema.SchemaError,
-    Persistable.Services<K>
+    Persistable.Services<K> | R
   >
   readonly invalidate: (key: K) => Effect.Effect<void, Persistence.PersistenceError>
 }
@@ -37,22 +37,32 @@ export interface PersistedCache<K extends Persistable.Any> {
  * @since 4.0.0
  * @category Constructors
  */
-export const make: <K extends Persistable.Any, R>(options: {
+export const make: <
+  K extends Persistable.Any,
+  R = never,
+  ServiceMode extends "lookup" | "construction" = never
+>(options: {
   readonly storeId: string
   readonly lookup: (key: K) => Effect.Effect<Persistable.Success<K>, Persistable.Error<K>, R>
   readonly timeToLive: Persistable.TimeToLiveFn<K>
   readonly inMemoryCapacity?: number | undefined
   readonly inMemoryTTL?: Persistable.TimeToLiveFn<K> | undefined
+  readonly requireServicesAt?: ServiceMode | undefined
 }) => Effect.Effect<
-  PersistedCache<K>,
+  PersistedCache<K, "lookup" extends ServiceMode ? R : never>,
   never,
-  R | Persistence.Persistence | Scope.Scope
-> = Effect.fnUntraced(function*<K extends Persistable.Any, R>(options: {
+  ("lookup" extends ServiceMode ? never : R) | Persistence.Persistence | Scope.Scope
+> = Effect.fnUntraced(function*<
+  K extends Persistable.Any,
+  R = never,
+  ServiceMode extends "lookup" | "construction" = never
+>(options: {
   readonly storeId: string
   readonly lookup: (key: K) => Effect.Effect<Persistable.Success<K>, Persistable.Error<K>, R>
   readonly timeToLive: Persistable.TimeToLiveFn<K>
   readonly inMemoryCapacity?: number | undefined
   readonly inMemoryTTL?: Persistable.TimeToLiveFn<K> | undefined
+  readonly requireServicesAt?: ServiceMode | undefined
 }) {
   const store = yield* (yield* Persistence.Persistence).make({
     storeId: options.storeId,
@@ -69,9 +79,10 @@ export const make: <K extends Persistable.Any, R>(options: {
       return yield* result
     }),
     timeToLive: options.inMemoryTTL ?? constant(Duration.seconds(10)),
-    capacity: options.inMemoryCapacity ?? 1024
+    capacity: options.inMemoryCapacity ?? 1024,
+    requireServicesAt: options.requireServicesAt
   })
-  return identity<PersistedCache<K>>({
+  return identity<PersistedCache<K, "lookup" extends ServiceMode ? R : never>>({
     [TypeId]: TypeId,
     inMemory,
     get: (key) => Cache.get(inMemory, key),

package/src/unstable/persistence/PersistedQueue.ts

@@ -9,6 +9,7 @@ import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
 import { flow } from "../../Function.ts"
 import * as Iterable from "../../Iterable.ts"
+import * as Latch from "../../Latch.ts"
 import * as Layer from "../../Layer.ts"
 import * as MutableRef from "../../MutableRef.ts"
 import * as Queue from "../../Queue.ts"
@@ -235,14 +236,14 @@ export const layerStoreMemory: Layer.Layer<
   }
   const ids = new Set<string>()
   const queues = new Map<string, {
-    latch: Effect.Latch
+    latch: Latch.Latch
     items: Set<Entry>
   }>()
   const getOrCreateQueue = (name: string) => {
     let queue = queues.get(name)
     if (!queue) {
       queue = {
-        latch: Effect.makeLatchUnsafe(false),
+        latch: Latch.makeUnsafe(false),
         items: new Set()
       }
       queues.set(name, queue)
@@ -294,26 +295,26 @@ export const layerStoreMemory: Layer.Layer<
 export const makeStoreRedis = Effect.fnUntraced(function*(
   options?: {
     readonly prefix?: string | undefined
-    readonly pollInterval?: Duration.DurationInput | undefined
-    readonly lockRefreshInterval?: Duration.DurationInput | undefined
-    readonly lockExpiration?: Duration.DurationInput | undefined
+    readonly pollInterval?: Duration.Input | undefined
+    readonly lockRefreshInterval?: Duration.Input | undefined
+    readonly lockExpiration?: Duration.Input | undefined
   }
 ) {
   const redis = yield* Redis.Redis
 
   const pollInterval = Duration.max(
-    options?.pollInterval ? Duration.fromDurationInputUnsafe(options.pollInterval) : Duration.seconds(1),
+    options?.pollInterval ? Duration.fromInputUnsafe(options.pollInterval) : Duration.seconds(1),
     Duration.millis(1)
   )
   const lockRefreshMillis = Math.max(
     options?.lockRefreshInterval
-      ? Duration.toMillis(Duration.fromDurationInputUnsafe(options.lockRefreshInterval))
+      ? Duration.toMillis(Duration.fromInputUnsafe(options.lockRefreshInterval))
       : 30_000,
     1
   )
   const lockExpirationMillis = Math.max(
     options?.lockExpiration
-      ? Duration.toMillis(Duration.fromDurationInputUnsafe(options.lockExpiration))
+      ? Duration.toMillis(Duration.fromInputUnsafe(options.lockExpiration))
       : 90_000,
     1
   )
@@ -345,8 +346,8 @@ export const makeStoreRedis = Effect.fnUntraced(function*(
       const pendingKey = keyPending(name)
       const queue = yield* Queue.make<Element>()
       const takers = MutableRef.make(0)
-      const pollLatch = Effect.makeLatchUnsafe()
-      const takenLatch = Effect.makeLatchUnsafe()
+      const pollLatch = Latch.makeUnsafe()
+      const takenLatch = Latch.makeUnsafe()
 
       yield* Effect.addFinalizer(() =>
         Effect.orDie(
@@ -653,9 +654,9 @@ end
 export const layerStoreRedis: (
   options?: {
     readonly prefix?: string | undefined
-    readonly pollInterval?: Duration.DurationInput | undefined
-    readonly lockRefreshInterval?: Duration.DurationInput | undefined
-    readonly lockExpiration?: Duration.DurationInput | undefined
+    readonly pollInterval?: Duration.Input | undefined
+    readonly lockRefreshInterval?: Duration.Input | undefined
+    readonly lockExpiration?: Duration.Input | undefined
   } | undefined
 ) => Layer.Layer<
   PersistedQueueStore,
@@ -670,9 +671,9 @@ export const layerStoreRedis: (
 export const makeStoreSql: (
   options?: {
     readonly tableName?: string | undefined
-    readonly pollInterval?: Duration.DurationInput | undefined
-    readonly lockRefreshInterval?: Duration.DurationInput | undefined
-    readonly lockExpiration?: Duration.DurationInput | undefined
+    readonly pollInterval?: Duration.Input | undefined
+    readonly lockRefreshInterval?: Duration.Input | undefined
+    readonly lockExpiration?: Duration.Input | undefined
   } | undefined
 ) => Effect.Effect<
   PersistedQueueStore["Service"],
@@ -683,15 +684,15 @@ export const makeStoreSql: (
   const tableName = options?.tableName ?? "effect_queue"
   const tableNameSql = sql(tableName)
   const pollInterval = Duration.max(
-    options?.pollInterval ? Duration.fromDurationInputUnsafe(options.pollInterval) : Duration.millis(1000),
+    options?.pollInterval ? Duration.fromInputUnsafe(options.pollInterval) : Duration.millis(1000),
     Duration.millis(1)
   )
   const lockRefreshInterval = Duration.max(
-    options?.lockRefreshInterval ? Duration.fromDurationInputUnsafe(options.lockRefreshInterval) : Duration.seconds(30),
+    options?.lockRefreshInterval ? Duration.fromInputUnsafe(options.lockRefreshInterval) : Duration.seconds(30),
     Duration.millis(1)
   )
   const lockExpiration = Duration.max(
-    options?.lockExpiration ? Duration.fromDurationInputUnsafe(options.lockExpiration) : Duration.minutes(2),
+    options?.lockExpiration ? Duration.fromInputUnsafe(options.lockExpiration) : Duration.minutes(2),
     Duration.millis(1)
   )
   const lockExpirationSql = sql.literal(Math.ceil(Duration.toSeconds(lockExpiration)).toString())
@@ -930,8 +931,8 @@ export const makeStoreSql: (
     lookup: Effect.fnUntraced(function*({ maxAttempts, name }: QueueKey) {
       const queue = yield* Queue.make<Element>()
       const takers = MutableRef.make(0)
-      const pollLatch = Effect.makeLatchUnsafe()
-      const takenLatch = Effect.makeLatchUnsafe()
+      const pollLatch = Latch.makeUnsafe()
+      const takenLatch = Latch.makeUnsafe()
 
       yield* Effect.addFinalizer(() =>
         Effect.flatMap(Queue.clear(queue), (elements) => {
@@ -1098,9 +1099,9 @@ class QueueKey extends Data.Class<{
 export const layerStoreSql: (
   options?: {
     readonly tableName?: string | undefined
-    readonly pollInterval?: Duration.DurationInput | undefined
-    readonly lockRefreshInterval?: Duration.DurationInput | undefined
-    readonly lockExpiration?: Duration.DurationInput | undefined
+    readonly pollInterval?: Duration.Input | undefined
+    readonly lockRefreshInterval?: Duration.Input | undefined
+    readonly lockExpiration?: Duration.Input | undefined
   } | undefined
 ) => Layer.Layer<
   PersistedQueueStore,

package/src/unstable/persistence/Persistence.ts

@@ -42,7 +42,7 @@ export class PersistenceError extends Schema.ErrorClass(ErrorTypeId)({
 export class Persistence extends ServiceMap.Service<Persistence, {
   readonly make: (options: {
     readonly storeId: string
-    readonly timeToLive?: (exit: Exit.Exit<unknown, unknown>, key: Persistable.Any) => Duration.DurationInput
+    readonly timeToLive?: (exit: Exit.Exit<unknown, unknown>, key: Persistable.Any) => Duration.Input
   }) => Effect.Effect<PersistenceStore, never, Scope.Scope>
 }>()("effect/persistence/Persistence") {}
 
@@ -169,7 +169,7 @@ export const layer = Layer.effect(Persistence)(Effect.gen(function*() {
           return out
         }),
         set(key, value) {
-          const ttl = Duration.fromDurationInputUnsafe(timeToLive(value, key))
+          const ttl = Duration.fromInputUnsafe(timeToLive(value, key))
           if (Duration.isZero(ttl) || Duration.isNegative(ttl)) return Effect.void
           return Persistable.serializeExit(key, value).pipe(
             Effect.flatMap((encoded) =>
@@ -180,7 +180,7 @@ export const layer = Layer.effect(Persistence)(Effect.gen(function*() {
         setMany: Effect.fnUntraced(function*(entries) {
           const encodedEntries = Arr.empty<readonly [string, object, Duration.Duration | undefined]>()
           for (const [key, value] of entries) {
-            const ttl = Duration.fromDurationInputUnsafe(timeToLive(value, key))
+            const ttl = Duration.fromInputUnsafe(timeToLive(value, key))
             if (Duration.isZero(ttl) || Duration.isNegative(ttl)) continue
             const encoded = Persistable.serializeExit(key, value)
             const exit = Exit.isExit(encoded)

package/src/unstable/persistence/RateLimiter.ts

@@ -32,7 +32,7 @@ export interface RateLimiter {
   readonly consume: (options: {
     readonly algorithm?: "fixed-window" | "token-bucket" | undefined
     readonly onExceeded?: "delay" | "fail" | undefined
-    readonly window: Duration.DurationInput
+    readonly window: Duration.Input
     readonly limit: number
     readonly key: string
     readonly tokens?: number | undefined
@@ -62,7 +62,7 @@ export const make: Effect.Effect<
       const tokens = options.tokens ?? 1
       const onExceeded = options.onExceeded ?? "fail"
       const algorithm = options.algorithm ?? "fixed-window"
-      const window = Duration.max(Duration.fromDurationInputUnsafe(options.window), Duration.millis(1))
+      const window = Duration.max(Duration.fromInputUnsafe(options.window), Duration.millis(1))
       const windowMillis = Duration.toMillis(window)
       const refillRate = Duration.divideUnsafe(window, options.limit)
       const refillRateMillis = Duration.toMillis(refillRate)
@@ -222,7 +222,7 @@ export const makeWithRateLimiter: Effect.Effect<
   ((options: {
     readonly algorithm?: "fixed-window" | "token-bucket" | undefined
     readonly onExceeded?: "delay" | "fail" | undefined
-    readonly window: Duration.DurationInput
+    readonly window: Duration.Input
     readonly limit: number
     readonly key: string
     readonly tokens?: number | undefined
@@ -266,7 +266,7 @@ export const makeWithRateLimiter: Effect.Effect<
 export const makeSleep: Effect.Effect<
   ((options: {
     readonly algorithm?: "fixed-window" | "token-bucket" | undefined
-    readonly window: Duration.DurationInput
+    readonly window: Duration.Input
     readonly limit: number
     readonly key: string
     readonly tokens?: number | undefined