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

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

package/src/unstable/process/ChildProcess.ts

@@ -283,7 +283,7 @@ export interface KillOptions {
    * Defaults to `undefined`, which means that no timeout will be enforced by
    * default.
    */
-  readonly forceKillAfter?: Duration.DurationInput | undefined
+  readonly forceKillAfter?: Duration.Input | undefined
 }
 
 /**

package/src/unstable/reactivity/Atom.ts

@@ -169,25 +169,25 @@ export const setIdleTTL: {
    * @since 4.0.0
    * @category combinators
    */
-  (duration: Duration.DurationInput): <A extends Atom<any>>(self: A) => A
+  (duration: Duration.Input): <A extends Atom<any>>(self: A) => A
   /**
    * @since 4.0.0
    * @category combinators
    */
-  <A extends Atom<any>>(self: A, duration: Duration.DurationInput): A
+  <A extends Atom<any>>(self: A, duration: Duration.Input): A
 } = dual<
   /**
    * @since 4.0.0
    * @category combinators
    */
-  (duration: Duration.DurationInput) => <A extends Atom<any>>(self: A) => A,
+  (duration: Duration.Input) => <A extends Atom<any>>(self: A) => A,
   /**
    * @since 4.0.0
    * @category combinators
    */
-  <A extends Atom<any>>(self: A, duration: Duration.DurationInput) => A
+  <A extends Atom<any>>(self: A, duration: Duration.Input) => A
 >(2, (self, durationInput) => {
-  const duration = Duration.fromDurationInputUnsafe(durationInput)
+  const duration = Duration.fromInputUnsafe(durationInput)
   const isFinite = Duration.isFinite(duration)
   return Object.assign(Object.create(Object.getPrototypeOf(self)), {
     ...self,
@@ -1684,16 +1684,16 @@ export const debounce: {
    * @since 4.0.0
    * @category combinators
    */
-  (duration: Duration.DurationInput): <A extends Atom<any>>(self: A) => WithoutSerializable<A>
+  (duration: Duration.Input): <A extends Atom<any>>(self: A) => WithoutSerializable<A>
   /**
    * @since 4.0.0
    * @category combinators
    */
-  <A extends Atom<any>>(self: A, duration: Duration.DurationInput): WithoutSerializable<A>
+  <A extends Atom<any>>(self: A, duration: Duration.Input): WithoutSerializable<A>
 } = dual(
   2,
-  <A>(self: Atom<A>, duration: Duration.DurationInput): Atom<A> => {
-    const millis = Duration.toMillis(Duration.fromDurationInputUnsafe(duration))
+  <A>(self: Atom<A>, duration: Duration.Input): Atom<A> => {
+    const millis = Duration.toMillis(Duration.fromInputUnsafe(duration))
     return transform(self, function(get) {
       let timeout: number | undefined
       let value = get.once(self)
@@ -1729,7 +1729,7 @@ export const withRefresh: {
    * @since 4.0.0
    * @category combinators
    */
-  (duration: Duration.DurationInput): <A extends Atom<any>>(self: A) => WithoutSerializable<A>
+  (duration: Duration.Input): <A extends Atom<any>>(self: A) => WithoutSerializable<A>
   /**
    * Ensures that the value of the atom is refreshed at most once per specified
    * duration.
@@ -1737,11 +1737,11 @@ export const withRefresh: {
    * @since 4.0.0
    * @category combinators
    */
-  <A extends Atom<any>>(self: A, duration: Duration.DurationInput): WithoutSerializable<A>
+  <A extends Atom<any>>(self: A, duration: Duration.Input): WithoutSerializable<A>
 } = dual(
   2,
-  <A>(self: Atom<A>, duration: Duration.DurationInput): Atom<A> => {
-    const millis = Duration.toMillis(Duration.fromDurationInputUnsafe(duration))
+  <A>(self: Atom<A>, duration: Duration.Input): Atom<A> => {
+    const millis = Duration.toMillis(Duration.fromInputUnsafe(duration))
     return transform(self, function(get) {
       const handle = setTimeout(() => get.refresh(self), millis) as any
       get.addFinalizer(() => clearTimeout(handle))

package/src/unstable/reactivity/AtomHttpApi.ts

@@ -103,7 +103,7 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
             | ReadonlyArray<unknown>
             | ReadonlyRecord<string, ReadonlyArray<unknown>>
             | undefined
-          readonly timeToLive?: Duration.DurationInput | undefined
+          readonly timeToLive?: Duration.Input | undefined
         }
       >
       : never
@@ -223,7 +223,7 @@ export const Service = <Self>() =>
       readonly headers?: any
       readonly withResponse?: boolean
       readonly reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
-      readonly timeToLive?: Duration.DurationInput | undefined
+      readonly timeToLive?: Duration.Input | undefined
     }
   ) =>
     queryFamily({
@@ -236,7 +236,7 @@ export const Service = <Self>() =>
       withResponse: request.withResponse ?? false,
       reactivityKeys: request.reactivityKeys,
       timeToLive: request.timeToLive
-        ? Duration.fromDurationInputUnsafe(request.timeToLive)
+        ? Duration.fromInputUnsafe(request.timeToLive)
         : undefined
     })) as any
 

package/src/unstable/reactivity/AtomRpc.ts

@@ -71,7 +71,7 @@ export interface AtomRpcClient<Self, Id extends string, Rpcs extends Rpc.Any, E>
         | ReadonlyArray<unknown>
         | ReadonlyRecord<string, ReadonlyArray<unknown>>
         | undefined
-      readonly timeToLive?: Duration.DurationInput | undefined
+      readonly timeToLive?: Duration.Input | undefined
     }
   ) => Rpc.ExtractTag<Rpcs, Tag> extends Rpc.Rpc<
     infer _Tag,
@@ -208,7 +208,7 @@ export const Service = <Self>() =>
         | ReadonlyArray<unknown>
         | ReadonlyRecord<string, ReadonlyArray<unknown>>
         | undefined
-      readonly timeToLive?: Duration.DurationInput | undefined
+      readonly timeToLive?: Duration.Input | undefined
     }
   ) =>
     queryFamily({
@@ -219,7 +219,7 @@ export const Service = <Self>() =>
         : undefined,
       reactivityKeys: options?.reactivityKeys,
       timeToLive: options?.timeToLive
-        ? Duration.fromDurationInputUnsafe(options.timeToLive)
+        ? Duration.fromInputUnsafe(options.timeToLive)
         : undefined
     }) as any
 

package/src/unstable/rpc/Rpc.ts

@@ -61,7 +61,7 @@ export interface Rpc<
   readonly payloadSchema: Payload
   readonly successSchema: Success
   readonly errorSchema: Error
-  readonly defectSchema: DefectSchema
+  readonly defectSchema: Schema.Top
   readonly annotations: ServiceMap.ServiceMap<never>
   readonly middlewares: ReadonlySet<Middleware>
   readonly "~requires": Requires
@@ -183,7 +183,7 @@ export interface AnyWithProps extends Pipeable {
   readonly payloadSchema: Schema.Top
   readonly successSchema: Schema.Top
   readonly errorSchema: Schema.Top
-  readonly defectSchema: DefectSchema
+  readonly defectSchema: Schema.Top
   readonly annotations: ServiceMap.ServiceMap<never>
   readonly middlewares: ReadonlySet<RpcMiddleware.AnyServiceWithProps>
   readonly "~requires": any
@@ -696,7 +696,7 @@ const makeProto = <
   readonly payloadSchema: Payload
   readonly successSchema: Success
   readonly errorSchema: Error
-  readonly defectSchema: DefectSchema
+  readonly defectSchema: Schema.Top
   readonly annotations: ServiceMap.ServiceMap<never>
   readonly middlewares: ReadonlySet<Middleware>
 }): Rpc<Tag, Payload, Success, Error, Middleware, Requires> => {

package/src/unstable/rpc/RpcClient.ts

@@ -21,7 +21,6 @@ import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
 import type * as Struct from "../../Struct.ts"
 import type { Span } from "../../Tracer.ts"
-import type { Mutable } from "../../Types.ts"
 import * as Headers from "../http/Headers.ts"
 import * as HttpBody from "../http/HttpBody.ts"
 import * as HttpClient from "../http/HttpClient.ts"
@@ -46,16 +45,7 @@ import { withRun } from "./Utils.ts"
  * @since 4.0.0
  * @category client
  */
-export type RpcClient<Rpcs extends Rpc.Any, E = never> = Struct.Simplify<
-  & RpcClient.From<RpcClient.NonPrefixed<Rpcs>, E, "">
-  & {
-    readonly [CurrentPrefix in RpcClient.Prefixes<Rpcs>]: RpcClient.From<
-      RpcClient.Prefixed<Rpcs, CurrentPrefix>,
-      E,
-      CurrentPrefix
-    >
-  }
->
+export type RpcClient<Rpcs extends Rpc.Any, E = never> = Struct.Simplify<RpcClient.From<Rpcs, E>>
 
 /**
  * @since 4.0.0
@@ -66,34 +56,8 @@ export declare namespace RpcClient {
    * @since 4.0.0
    * @category client
    */
-  export type Prefixes<Rpcs extends Rpc.Any> = Rpcs["_tag"] extends infer Tag
-    ? Tag extends `${infer Prefix}.${string}` ? Prefix : never
-    : never
-
-  /**
-   * @since 4.0.0
-   * @category client
-   */
-  export type NonPrefixed<Rpcs extends Rpc.Any> = Exclude<Rpcs, { readonly _tag: `${string}.${string}` }>
-
-  /**
-   * @since 4.0.0
-   * @category client
-   */
-  export type Prefixed<Rpcs extends Rpc.Any, Prefix extends string> = Extract<
-    Rpcs,
-    { readonly _tag: `${Prefix}.${string}` }
-  >
-
-  /**
-   * @since 4.0.0
-   * @category client
-   */
-  export type From<Rpcs extends Rpc.Any, E = never, Prefix extends string = ""> = {
-    readonly [
-      Current in Rpcs as Current["_tag"] extends `${Prefix}.${infer Method}` ? Method
-        : Current["_tag"]
-    ]: <
+  export type From<Rpcs extends Rpc.Any, E = never> = {
+    readonly [Current in Rpcs as Current["_tag"]]: <
       const AsQueue extends boolean = false,
       const Discard = false
     >(
@@ -615,16 +579,9 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
     }
   } else {
     client = {}
-    for (const rpc of group.requests.values()) {
-      const dot = rpc._tag.indexOf(".")
-      const prefix = dot === -1 ? undefined : rpc._tag.slice(0, dot)
-      if (prefix !== undefined && !(prefix in client)) {
-        ;(client as any)[prefix] = {} as Mutable<RpcClient.Prefixed<Rpcs, typeof prefix>>
-      }
-      const target = prefix !== undefined ? (client as any)[prefix] : client
-      const tag = prefix !== undefined ? rpc._tag.slice(dot + 1) : rpc._tag
-      target[tag] = onRequest(rpc as any)
-    }
+    group.requests.forEach((rpc) => {
+      client[rpc._tag] = onRequest(rpc as any)
+    })
   }
 
   return { client, write } as const
@@ -1119,7 +1076,7 @@ export const makeProtocolWorker = (
     readonly maxSize: number
     readonly concurrency?: number | undefined
     readonly targetUtilization?: number | undefined
-    readonly timeToLive: Duration.DurationInput
+    readonly timeToLive: Duration.Input
   }
 ): Effect.Effect<
   Protocol["Service"],
@@ -1267,7 +1224,7 @@ export const layerProtocolWorker: (
     readonly maxSize: number
     readonly concurrency?: number | undefined
     readonly targetUtilization?: number | undefined
-    readonly timeToLive: Duration.DurationInput
+    readonly timeToLive: Duration.Input
   }
 ) => Layer.Layer<
   Protocol,

package/src/unstable/socket/Socket.ts

@@ -5,7 +5,7 @@ import type { NonEmptyReadonlyArray } from "../../Array.ts"
 import type * as Cause from "../../Cause.ts"
 import * as Channel from "../../Channel.ts"
 import * as Deferred from "../../Deferred.ts"
-import type { DurationInput } from "../../Duration.ts"
+import type * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
 import * as FiberSet from "../../FiberSet.ts"
@@ -423,7 +423,7 @@ export const layerWebSocketConstructorGlobal: Layer.Layer<WebSocketConstructor>
  */
 export const makeWebSocket = (url: string | Effect.Effect<string>, options?: {
   readonly closeCodeIsError?: ((code: number) => boolean) | undefined
-  readonly openTimeout?: DurationInput | undefined
+  readonly openTimeout?: Duration.Input | undefined
   readonly protocols?: string | Array<string> | undefined
 }): Effect.Effect<Socket, never, WebSocketConstructor> =>
   fromWebSocket(
@@ -444,7 +444,7 @@ export const fromWebSocket = <RO>(
   acquire: Effect.Effect<globalThis.WebSocket, SocketError, RO>,
   options?: {
     readonly closeCodeIsError?: ((code: number) => boolean) | undefined
-    readonly openTimeout?: DurationInput | undefined
+    readonly openTimeout?: Duration.Input | undefined
   } | undefined
 ): Effect.Effect<Socket, never, Exclude<RO, Scope.Scope>> =>
   Effect.withFiber((fiber) => {
@@ -619,7 +619,7 @@ export const layerWebSocket: (
   url: string | Effect.Effect<string>,
   options?: {
     readonly closeCodeIsError?: ((code: number) => boolean) | undefined
-    readonly openTimeout?: DurationInput | undefined
+    readonly openTimeout?: Duration.Input | undefined
     readonly protocols?: string | Array<string> | undefined
   } | undefined
 ) => Layer.Layer<Socket, never, WebSocketConstructor> = flow(makeWebSocket, Layer.effect(Socket))

package/src/unstable/sql/SqlModel.ts

@@ -3,7 +3,7 @@
  * @category models
  */
 import type * as Cause from "../../Cause.ts"
-import type { DurationInput } from "../../Duration.ts"
+import type { Input } from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import { identity } from "../../Function.ts"
 import * as RequestResolver from "../../RequestResolver.ts"
@@ -69,7 +69,7 @@ export const makeRepository = <
     const idSchema = Model.fields[options.idColumn] as Schema.Top
     const idColumn = options.idColumn as string
 
-    const insertSchema = SqlSchema.single({
+    const insertSchema = SqlSchema.findOne({
       Request: Model.insert,
       Result: Model,
       execute: (request) =>
@@ -107,7 +107,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID(
         })
       ) as any
 
-    const updateSchema = SqlSchema.single({
+    const updateSchema = SqlSchema.findOne({
       Request: Model.update,
       Result: Model,
       execute: (request: any) =>
@@ -159,7 +159,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = ${request[idCol
         })
       ) as any
 
-    const findByIdSchema = SqlSchema.single({
+    const findByIdSchema = SqlSchema.findOne({
       Request: idSchema,
       Result: Model,
       execute: (id: any) => sql`select * from ${sql(options.tableName)} where ${sql(idColumn)} = ${id}`
@@ -210,7 +210,7 @@ export const makeDataLoaders = <
     readonly tableName: string
     readonly spanPrefix: string
     readonly idColumn: Id
-    readonly window: DurationInput
+    readonly window: Input
     readonly maxBatchSize?: number | undefined
   }
 ): Effect.Effect<

package/src/unstable/sql/SqlSchema.ts

@@ -13,7 +13,7 @@ import * as Schema from "../../Schema.ts"
  * @since 4.0.0
  * @category constructor
  */
-export const findMany = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
+export const findAll = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
   options: {
     readonly Request: Req
     readonly Result: Res
@@ -21,7 +21,30 @@ export const findMany = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
   }
 ) => {
   const encodeRequest = Schema.encodeEffect(options.Request)
-  const decode = Schema.decodeUnknownEffect(Schema.Array(options.Result))
+  const decode = Schema.decodeUnknownEffect(Schema.mutable(Schema.Array(options.Result)))
+  return (
+    request: Req["Encoded"]
+  ): Effect.Effect<
+    Array<Res["Type"]>,
+    E | Schema.SchemaError | Cause.NoSuchElementError,
+    Req["EncodingServices"] | Res["DecodingServices"] | R
+  > => Effect.flatMap(Effect.flatMap(encodeRequest(request), options.execute), decode)
+}
+
+/**
+ * Run a sql query with a request schema and a result schema.
+ *
+ * @since 4.0.0
+ * @category constructor
+ */
+export const findNonEmpty = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
+  options: {
+    readonly Request: Req
+    readonly Result: Res
+    readonly execute: (request: Req["Encoded"]) => Effect.Effect<ReadonlyArray<unknown>, E, R>
+  }
+) => {
+  const find = findAll(options)
   return (
     request: Req["Encoded"]
   ): Effect.Effect<
@@ -29,17 +52,10 @@ export const findMany = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
     E | Schema.SchemaError | Cause.NoSuchElementError,
     Req["EncodingServices"] | Res["DecodingServices"] | R
   > =>
-    Effect.flatMap(
-      Effect.flatMap(encodeRequest(request), options.execute),
-      (results): Effect.Effect<
-        Arr.NonEmptyArray<Res["Type"]>,
-        Schema.SchemaError | Cause.NoSuchElementError,
-        Req["EncodingServices"] | Res["DecodingServices"]
-      > =>
-        Arr.isReadonlyArrayNonEmpty(results)
-          ? decode(results) as Effect.Effect<Arr.NonEmptyArray<Res["Type"]>, Schema.SchemaError>
-          : Effect.fail(new Cause.NoSuchElementError())
-    )
+    Effect.flatMap(find(request), (results) =>
+      Arr.isArrayNonEmpty(results)
+        ? Effect.succeed(results)
+        : Effect.fail(new Cause.NoSuchElementError()))
 }
 
 const void_ = <Req extends Schema.Top, E, R>(
@@ -65,7 +81,7 @@ export {
 }
 
 /**
- * Run a sql query with a request schema and a result schema and return the first result, if any.
+ * Run a sql query with a request schema and a result schema and return the first result.
  *
  * @since 4.0.0
  * @category constructor
@@ -82,17 +98,17 @@ export const findOne = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
   return (
     request: Req["Type"]
   ): Effect.Effect<
-    Option.Option<Res["Type"]>,
-    E | Schema.SchemaError,
+    Res["Type"],
+    E | Schema.SchemaError | Cause.NoSuchElementError,
     R | Req["EncodingServices"] | Res["DecodingServices"]
   > =>
     Effect.flatMap(
       Effect.flatMap(encodeRequest(request), options.execute),
       (arr): Effect.Effect<
-        Option.Option<Res["Type"]>,
-        Schema.SchemaError,
+        Res["Type"],
+        Schema.SchemaError | Cause.NoSuchElementError,
         Req["EncodingServices"] | Res["DecodingServices"]
-      > => Arr.isReadonlyArrayNonEmpty(arr) ? Effect.asSome(decode(arr[0])) : Effect.succeedNone
+      > => Arr.isReadonlyArrayNonEmpty(arr) ? decode(arr[0]) : Effect.fail(new Cause.NoSuchElementError())
     )
 }
 
@@ -102,7 +118,7 @@ export const findOne = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
  * @since 4.0.0
  * @category constructor
  */
-export const single = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
+export const findOneOption = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
   options: {
     readonly Request: Req
     readonly Result: Res
@@ -114,16 +130,16 @@ export const single = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
   return (
     request: Req["Type"]
   ): Effect.Effect<
-    Res["Type"],
-    E | Schema.SchemaError | Cause.NoSuchElementError,
+    Option.Option<Res["Type"]>,
+    E | Schema.SchemaError,
     R | Req["EncodingServices"] | Res["DecodingServices"]
   > =>
     Effect.flatMap(
       Effect.flatMap(encodeRequest(request), options.execute),
       (arr): Effect.Effect<
-        Res["Type"],
-        Schema.SchemaError | Cause.NoSuchElementError,
+        Option.Option<Res["Type"]>,
+        Schema.SchemaError,
         Req["EncodingServices"] | Res["DecodingServices"]
-      > => Arr.isReadonlyArrayNonEmpty(arr) ? decode(arr[0]) : Effect.fail(new Cause.NoSuchElementError())
+      > => Arr.isReadonlyArrayNonEmpty(arr) ? Effect.asSome(decode(arr[0])) : Effect.succeedNone
     )
 }

package/src/unstable/workflow/DurableClock.ts

@@ -28,11 +28,11 @@ export interface DurableClock {
  */
 export const make = (options: {
   readonly name: string
-  readonly duration: Duration.DurationInput
+  readonly duration: Duration.Input
 }): DurableClock => ({
   [TypeId]: TypeId,
   name: options.name,
-  duration: Duration.fromDurationInputUnsafe(options.duration),
+  duration: Duration.fromInputUnsafe(options.duration),
   deferred: DurableDeferred.make(`DurableClock/${options.name}`)
 })
 
@@ -54,14 +54,14 @@ const InstanceTag = ServiceMap.Service<
 export const sleep: (
   options: {
     readonly name: string
-    readonly duration: Duration.DurationInput
+    readonly duration: Duration.Input
     /**
      * If the duration is less than or equal to this threshold, the clock will
      * be executed in memory.
      *
      * Defaults to 60 seconds.
      */
-    readonly inMemoryThreshold?: Duration.DurationInput | undefined
+    readonly inMemoryThreshold?: Duration.Input | undefined
   }
 ) => Effect.Effect<
   void,
@@ -69,16 +69,16 @@ export const sleep: (
   WorkflowEngine | WorkflowInstance
 > = Effect.fnUntraced(function*(options: {
   readonly name: string
-  readonly duration: Duration.DurationInput
-  readonly inMemoryThreshold?: Duration.DurationInput | undefined
+  readonly duration: Duration.Input
+  readonly inMemoryThreshold?: Duration.Input | undefined
 }) {
-  const duration = Duration.fromDurationInputUnsafe(options.duration)
+  const duration = Duration.fromInputUnsafe(options.duration)
   if (Duration.isZero(duration)) {
     return
   }
 
   const inMemoryThreshold = options.inMemoryThreshold
-    ? Duration.fromDurationInputUnsafe(options.inMemoryThreshold)
+    ? Duration.fromInputUnsafe(options.inMemoryThreshold)
     : defaultInMemoryThreshold
 
   if (Duration.isLessThanOrEqualTo(duration, inMemoryThreshold)) {