effect 4.0.0-beta.4 → 4.0.0-beta.40

package/src/SchemaParser.ts

@@ -49,7 +49,23 @@ export function makeEffect<S extends Schema.Top>(schema: S) {
   const ast = recurDefaults(AST.toType(schema.ast))
   const parser = run<S["Type"], never>(ast)
   return (input: S["~type.make.in"], options?: Schema.MakeOptions): Effect.Effect<S["Type"], Issue.Issue> => {
-    return parser(input, options?.parseOptions)
+    return parser(
+      input,
+      options?.disableChecks
+        ? options?.parseOptions ? { ...options.parseOptions, disableChecks: true } : { disableChecks: true }
+        : options?.parseOptions
+    )
+  }
+}
+
+/**
+ * @category Constructing
+ * @since 4.0.0
+ */
+export function makeOption<S extends Schema.Top>(schema: S) {
+  const parser = makeEffect(schema)
+  return (input: S["~type.make.in"], options?: Schema.MakeOptions): Option.Option<S["Type"]> => {
+    return Exit.getSuccess(Effect.runSyncExit(parser(input, options) as any))
   }
 }
 
@@ -73,10 +89,8 @@ export function makeUnsafe<S extends Schema.Top>(schema: S) {
  * @category Asserting
  * @since 4.0.0
  */
-export function is<S extends Schema.Top & { readonly DecodingServices: never }>(
-  schema: S
-): <I>(input: I) => input is I & S["Type"] {
-  return _is<S["Type"]>(schema.ast)
+export function is<T>(schema: Schema.Schema<T>): <I>(input: I) => input is I & T {
+  return _is<T>(schema.ast)
 }
 
 /** @internal */
@@ -102,11 +116,9 @@ export function _issue<T>(ast: AST.AST) {
  * @category Asserting
  * @since 4.0.0
  */
-export function asserts<S extends Schema.Top & { readonly DecodingServices: never }>(
-  schema: S
-) {
-  const parser = asExit(run<S["Type"], never>(AST.toType(schema.ast)))
-  return <I>(input: I): asserts input is I & S["Type"] => {
+export function asserts<T>(schema: Schema.Schema<T>) {
+  const parser = asExit(run<T, never>(AST.toType(schema.ast)))
+  return <I>(input: I): asserts input is I & T => {
     const exit = parser(input, AST.defaultParseOptions)
     if (Exit.isFailure(exit)) {
       const issue = Cause.findError(exit.cause)
@@ -141,7 +153,7 @@ export const decodeEffect: <S extends Schema.Top>(
  * @category Decoding
  * @since 4.0.0
  */
-export function decodeUnknownPromise<S extends Schema.Top & { readonly DecodingServices: never }>(
+export function decodeUnknownPromise<S extends Schema.Decoder<unknown>>(
   schema: S
 ): (input: unknown, options?: AST.ParseOptions) => Promise<S["Type"]> {
   return asPromise(decodeUnknownEffect(schema))
@@ -151,7 +163,7 @@ export function decodeUnknownPromise<S extends Schema.Top & { readonly DecodingS
  * @category Decoding
  * @since 4.0.0
  */
-export function decodePromise<S extends Schema.Top & { readonly DecodingServices: never }>(
+export function decodePromise<S extends Schema.Decoder<unknown>>(
   schema: S
 ): (input: S["Encoded"], options?: AST.ParseOptions) => Promise<S["Type"]> {
   return asPromise(decodeEffect(schema))
@@ -161,7 +173,7 @@ export function decodePromise<S extends Schema.Top & { readonly DecodingServices
  * @category Decoding
  * @since 4.0.0
  */
-export function decodeUnknownExit<S extends Schema.Top & { readonly DecodingServices: never }>(
+export function decodeUnknownExit<S extends Schema.Decoder<unknown>>(
   schema: S
 ): (input: unknown, options?: AST.ParseOptions) => Exit.Exit<S["Type"], Issue.Issue> {
   return asExit(decodeUnknownEffect(schema))
@@ -171,7 +183,7 @@ export function decodeUnknownExit<S extends Schema.Top & { readonly DecodingServ
  * @category Decoding
  * @since 4.0.0
  */
-export const decodeExit: <S extends Schema.Top & { readonly DecodingServices: never }>(
+export const decodeExit: <S extends Schema.Decoder<unknown>>(
   schema: S
 ) => (input: S["Encoded"], options?: AST.ParseOptions) => Exit.Exit<S["Type"], Issue.Issue> = decodeUnknownExit
 
@@ -179,7 +191,7 @@ export const decodeExit: <S extends Schema.Top & { readonly DecodingServices: ne
  * @category Decoding
  * @since 4.0.0
  */
-export function decodeUnknownOption<S extends Schema.Top & { readonly DecodingServices: never }>(
+export function decodeUnknownOption<S extends Schema.Decoder<unknown>>(
   schema: S
 ): (input: unknown, options?: AST.ParseOptions) => Option.Option<S["Type"]> {
   return asOption(decodeUnknownEffect(schema))
@@ -189,7 +201,7 @@ export function decodeUnknownOption<S extends Schema.Top & { readonly DecodingSe
  * @category Decoding
  * @since 4.0.0
  */
-export const decodeOption: <S extends Schema.Top & { readonly DecodingServices: never }>(
+export const decodeOption: <S extends Schema.Decoder<unknown>>(
   schema: S
 ) => (input: S["Encoded"], options?: AST.ParseOptions) => Option.Option<S["Type"]> = decodeUnknownOption
 
@@ -197,7 +209,25 @@ export const decodeOption: <S extends Schema.Top & { readonly DecodingServices:
  * @category Decoding
  * @since 4.0.0
  */
-export function decodeUnknownSync<S extends Schema.Top & { readonly DecodingServices: never }>(
+export function decodeUnknownResult<S extends Schema.Decoder<unknown>>(
+  schema: S
+): (input: unknown, options?: AST.ParseOptions) => Result.Result<S["Type"], Issue.Issue> {
+  return asResult(decodeUnknownEffect(schema))
+}
+
+/**
+ * @category Decoding
+ * @since 4.0.0
+ */
+export const decodeResult: <S extends Schema.Decoder<unknown>>(
+  schema: S
+) => (input: S["Encoded"], options?: AST.ParseOptions) => Result.Result<S["Type"], Issue.Issue> = decodeUnknownResult
+
+/**
+ * @category Decoding
+ * @since 4.0.0
+ */
+export function decodeUnknownSync<S extends Schema.Decoder<unknown>>(
   schema: S
 ): (input: unknown, options?: AST.ParseOptions) => S["Type"] {
   return asSync(decodeUnknownEffect(schema))
@@ -207,7 +237,7 @@ export function decodeUnknownSync<S extends Schema.Top & { readonly DecodingServ
  * @category Decoding
  * @since 4.0.0
  */
-export const decodeSync: <S extends Schema.Top & { readonly DecodingServices: never }>(
+export const decodeSync: <S extends Schema.Decoder<unknown>>(
   schema: S
 ) => (input: S["Encoded"], options?: AST.ParseOptions) => S["Type"] = decodeUnknownSync
 
@@ -234,7 +264,7 @@ export const encodeEffect: <S extends Schema.Top>(
  * @category Encoding
  * @since 4.0.0
  */
-export const encodeUnknownPromise = <S extends Schema.Top & { readonly EncodingServices: never }>(
+export const encodeUnknownPromise = <S extends Schema.Encoder<unknown>>(
   schema: S
 ): (input: unknown, options?: AST.ParseOptions) => Promise<S["Encoded"]> => asPromise(encodeUnknownEffect(schema))
 
@@ -242,7 +272,7 @@ export const encodeUnknownPromise = <S extends Schema.Top & { readonly EncodingS
  * @category Encoding
  * @since 4.0.0
  */
-export const encodePromise: <S extends Schema.Top & { readonly EncodingServices: never }>(
+export const encodePromise: <S extends Schema.Encoder<unknown>>(
   schema: S
 ) => (input: S["Type"], options?: AST.ParseOptions) => Promise<S["Encoded"]> = encodeUnknownPromise
 
@@ -250,7 +280,7 @@ export const encodePromise: <S extends Schema.Top & { readonly EncodingServices:
  * @category Encoding
  * @since 4.0.0
  */
-export function encodeUnknownExit<S extends Schema.Top & { readonly EncodingServices: never }>(
+export function encodeUnknownExit<S extends Schema.Encoder<unknown>>(
   schema: S
 ): (input: unknown, options?: AST.ParseOptions) => Exit.Exit<S["Encoded"], Issue.Issue> {
   return asExit(encodeUnknownEffect(schema))
@@ -260,7 +290,7 @@ export function encodeUnknownExit<S extends Schema.Top & { readonly EncodingServ
  * @category Encoding
  * @since 4.0.0
  */
-export const encodeExit: <S extends Schema.Top & { readonly EncodingServices: never }>(
+export const encodeExit: <S extends Schema.Encoder<unknown>>(
   schema: S
 ) => (input: S["Type"], options?: AST.ParseOptions) => Exit.Exit<S["Encoded"], Issue.Issue> = encodeUnknownExit
 
@@ -268,7 +298,7 @@ export const encodeExit: <S extends Schema.Top & { readonly EncodingServices: ne
  * @category Encoding
  * @since 4.0.0
  */
-export function encodeUnknownOption<S extends Schema.Top & { readonly EncodingServices: never }>(
+export function encodeUnknownOption<S extends Schema.Encoder<unknown>>(
   schema: S
 ): (input: unknown, options?: AST.ParseOptions) => Option.Option<S["Encoded"]> {
   return asOption(encodeUnknownEffect(schema))
@@ -278,7 +308,7 @@ export function encodeUnknownOption<S extends Schema.Top & { readonly EncodingSe
  * @category Encoding
  * @since 4.0.0
  */
-export const encodeOption: <S extends Schema.Top & { readonly EncodingServices: never }>(
+export const encodeOption: <S extends Schema.Encoder<unknown>>(
   schema: S
 ) => (input: S["Type"], options?: AST.ParseOptions) => Option.Option<S["Encoded"]> = encodeUnknownOption
 
@@ -286,7 +316,25 @@ export const encodeOption: <S extends Schema.Top & { readonly EncodingServices:
  * @category Encoding
  * @since 4.0.0
  */
-export function encodeUnknownSync<S extends Schema.Top & { readonly EncodingServices: never }>(
+export function encodeUnknownResult<S extends Schema.Encoder<unknown>>(
+  schema: S
+): (input: unknown, options?: AST.ParseOptions) => Result.Result<S["Encoded"], Issue.Issue> {
+  return asResult(encodeUnknownEffect(schema))
+}
+
+/**
+ * @category Encoding
+ * @since 4.0.0
+ */
+export const encodeResult: <S extends Schema.Encoder<unknown>>(
+  schema: S
+) => (input: S["Type"], options?: AST.ParseOptions) => Result.Result<S["Encoded"], Issue.Issue> = encodeUnknownResult
+
+/**
+ * @category Encoding
+ * @since 4.0.0
+ */
+export function encodeUnknownSync<S extends Schema.Encoder<unknown>>(
   schema: S
 ): (input: unknown, options?: AST.ParseOptions) => S["Encoded"] {
   return asSync(encodeUnknownEffect(schema))
@@ -296,7 +344,7 @@ export function encodeUnknownSync<S extends Schema.Top & { readonly EncodingServ
  * @category Encoding
  * @since 4.0.0
  */
-export const encodeSync: <S extends Schema.Top & { readonly EncodingServices: never }>(
+export const encodeSync: <S extends Schema.Encoder<unknown>>(
   schema: S
 ) => (input: S["Type"], options?: AST.ParseOptions) => S["Encoded"] = encodeUnknownSync
 
@@ -332,6 +380,23 @@ export function asOption<T, E, R>(
   return (input: E, options?: AST.ParseOptions) => Exit.getSuccess(parserExit(input, options))
 }
 
+function asResult<T, E, R>(
+  parser: (input: E, options?: AST.ParseOptions) => Effect.Effect<T, Issue.Issue, R>
+): (input: E, options?: AST.ParseOptions) => Result.Result<T, Issue.Issue> {
+  const parserExit = asExit(parser)
+  return (input: E, options?: AST.ParseOptions) => {
+    const exit = parserExit(input, options)
+    if (Exit.isSuccess(exit)) {
+      return Result.succeed(exit.value)
+    }
+    const error = Cause.findError(exit.cause)
+    if (Result.isFailure(error)) {
+      throw Cause.squash(error.failure)
+    }
+    return Result.fail(error.success)
+  }
+}
+
 function asSync<T, E, R>(
   parser: (input: E, options?: AST.ParseOptions) => Effect.Effect<T, Issue.Issue, R>
 ): (input: E, options?: AST.ParseOptions) => T {
@@ -385,7 +450,7 @@ const recur = memoize(
       parser ??= ast.getParser(recur)
       let sroa = srou ? Effect.flatMapEager(srou, (ou) => parser(ou, options)) : parser(ou, options)
 
-      if (ast.checks) {
+      if (ast.checks && !options?.disableChecks) {
         const checks = ast.checks
         if (options?.errors === "all" && isStructural && Option.isSome(ou)) {
           sroa = Effect.catchEager(sroa, (issue) => {

package/src/SchemaRepresentation.ts

@@ -1646,7 +1646,7 @@ export const fromASTs: (asts: readonly [AST.AST, ...Array<AST.AST>]) => MultiDoc
  *
  * @since 4.0.0
  */
-export const DocumentFromJson: Schema.Codec<Document, unknown> = Schema.toCodecJson($Document)
+export const DocumentFromJson: Schema.Codec<Document, Schema.Json> = Schema.toCodecJson($Document)
 
 /**
  * Schema codec that decodes a {@link MultiDocument} from JSON and encodes it
@@ -1657,7 +1657,7 @@ export const DocumentFromJson: Schema.Codec<Document, unknown> = Schema.toCodecJ
  *
  * @since 4.0.0
  */
-export const MultiDocumentFromJson: Schema.Codec<MultiDocument, unknown> = Schema.toCodecJson($MultiDocument)
+export const MultiDocumentFromJson: Schema.Codec<MultiDocument, Schema.Json> = Schema.toCodecJson($MultiDocument)
 
 /**
  * Wraps a single {@link Document} as a {@link MultiDocument} with one
@@ -1698,7 +1698,8 @@ export type Reviver<T> = (declaration: Declaration, recur: (representation: Repr
 
 /**
  * Default {@link Reviver} for {@link toSchema} that handles built-in Effect
- * types (Option, Result, Redacted, Cause, Exit, ReadonlyMap, ReadonlySet,
+ * types (Option, Result, Redacted, Cause, Exit, ReadonlyMap, HashMap,
+ * ReadonlySet,
  * Date, Duration, URL, RegExp, etc.).
  *
  * - Pass as `options.reviver` to {@link toSchema} to reconstruct schemas that
@@ -1716,42 +1717,66 @@ export const toSchemaDefaultReviver: Reviver<Schema.Top> = (s, recur) => {
   if (Predicate.isObject(typeConstructor) && typeof typeConstructor._tag === "string") {
     const typeParameters = s.typeParameters.map(recur)
     switch (typeConstructor._tag) {
-      case "effect/Option":
-        return Schema.Option(typeParameters[0])
-      case "effect/Result":
-        return Schema.Result(typeParameters[0], typeParameters[1])
-      case "effect/Redacted":
-        return Schema.Redacted(typeParameters[0])
-      case "effect/Cause/Failure":
-        return Schema.CauseFailure(typeParameters[0], typeParameters[1])
-      case "effect/Cause":
-        return Schema.Cause(typeParameters[0], typeParameters[1])
+      // built-in types
+      case "Date":
+        return Schema.Date
       case "Error":
         return Schema.Error
-      case "effect/Exit":
-        return Schema.Exit(typeParameters[0], typeParameters[1], typeParameters[2])
+      case "ErrorWithStack":
+        return Schema.ErrorWithStack
+      case "File":
+        return Schema.File
+      case "FormData":
+        return Schema.FormData
       case "ReadonlyMap":
         return Schema.ReadonlyMap(typeParameters[0], typeParameters[1])
       case "ReadonlySet":
         return Schema.ReadonlySet(typeParameters[0])
       case "RegExp":
         return Schema.RegExp
+      case "Uint8Array":
+        return Schema.Uint8Array
       case "URL":
         return Schema.URL
-      case "File":
-        return Schema.File
-      case "Date":
-        return Schema.Date
-      case "effect/Duration":
-        return Schema.Duration
-      case "FormData":
-        return Schema.FormData
       case "URLSearchParams":
         return Schema.URLSearchParams
-      case "Uint8Array":
-        return Schema.Uint8Array
-      case "DateTime.Utc":
+      // effect types
+      case "effect/Option":
+        return Schema.Option(typeParameters[0])
+      case "effect/Result":
+        return Schema.Result(typeParameters[0], typeParameters[1])
+      case "effect/Redacted":
+        return Schema.Redacted(typeParameters[0])
+      case "effect/DateTime.TimeZone":
+        return Schema.TimeZone
+      case "effect/DateTime.TimeZone.Named":
+        return Schema.TimeZoneNamed
+      case "effect/DateTime.TimeZone.Offset":
+        return Schema.TimeZoneOffset
+      case "effect/DateTime.Utc":
         return Schema.DateTimeUtc
+      case "effect/DateTime.Zoned":
+        return Schema.DateTimeZoned
+      case "effect/BigDecimal":
+        return Schema.BigDecimal
+      case "effect/Chunk":
+        return Schema.Chunk(typeParameters[0])
+      case "effect/Cause":
+        return Schema.Cause(typeParameters[0], typeParameters[1])
+      case "effect/Cause/Failure":
+        return Schema.CauseReason(typeParameters[0], typeParameters[1])
+      case "effect/Duration":
+        return Schema.Duration
+      case "effect/Exit":
+        return Schema.Exit(typeParameters[0], typeParameters[1], typeParameters[2])
+      case "effect/Json":
+        return Schema.Json
+      case "effect/MutableJson":
+        return Schema.MutableJson
+      case "effect/HashMap":
+        return Schema.HashMap(typeParameters[0], typeParameters[1])
+      case "effect/HashSet":
+        return Schema.HashSet(typeParameters[0])
     }
   }
 }

package/src/SchemaTransformation.ts

@@ -82,6 +82,8 @@
  * @since 4.0.0
  */
 
+import * as BigDecimal from "./BigDecimal.ts"
+import * as DateTime from "./DateTime.ts"
 import * as Duration from "./Duration.ts"
 import * as Effect from "./Effect.ts"
 import * as Option from "./Option.ts"
@@ -905,15 +907,14 @@ export const bigintFromString = new Transformation(
  */
 export const durationFromNanos: Transformation<Duration.Duration, bigint> = transformOrFail({
   decode: (i) => Effect.succeed(Duration.nanos(i)),
-  encode: (a) => {
-    const nanos = Duration.toNanos(a)
-    if (Predicate.isUndefined(nanos)) {
-      return Effect.fail(
-        new Issue.InvalidValue(Option.some(a), { message: `Unable to encode ${a} into a bigint` })
-      )
-    }
-    return Effect.succeed(nanos)
-  }
+  encode: (a) =>
+    Option.match(Duration.toNanos(a), {
+      onNone: () =>
+        Effect.fail(
+          new Issue.InvalidValue(Option.some(a), { message: `Unable to encode ${a} into a bigint` })
+        ),
+      onSome: (nanos) => Effect.succeed(nanos)
+    })
 })
 
 /**
@@ -1004,8 +1005,7 @@ export const errorFromErrorJsonEncoded = (options?: {
  * ```
  *
  * See also:
- * - {@link optionFromOptionalKey}
- * - {@link optionFromOptional}
+ * - {@link optionFromNullishOr}
  *
  * @since 4.0.0
  */
@@ -1016,6 +1016,88 @@ export function optionFromNullOr<T>(): Transformation<Option.Option<T>, T | null
   })
 }
 
+/**
+ * Decodes `T | undefined` into `Option<T>` and encodes `Option<T>` back
+ * to `T | undefined`.
+ *
+ * When to use this:
+ * - Converting undefined-or API fields to `Option`.
+ *
+ * Behavior:
+ * - Decode: `undefined` → `Option.none()`, non-undefined → `Option.some(value)`.
+ * - Encode: `Option.none()` → `undefined`, `Option.some(value)` → `value`.
+ * - Pure and synchronous.
+ *
+ * **Example** (Option from undefined-or)
+ *
+ * ```ts
+ * import { Schema, SchemaTransformation } from "effect"
+ *
+ * const schema = Schema.UndefinedOr(Schema.String).pipe(
+ *   Schema.decodeTo(
+ *     Schema.Option(Schema.String),
+ *     SchemaTransformation.optionFromUndefinedOr()
+ *   )
+ * )
+ * ```
+ *
+ * See also:
+ * - {@link optionFromOptionalKey}
+ * - {@link optionFromOptional}
+ *
+ * @since 4.0.0
+ */
+export function optionFromUndefinedOr<T>(): Transformation<Option.Option<T>, T | undefined> {
+  return transform({
+    decode: Option.fromUndefinedOr,
+    encode: Option.getOrUndefined
+  })
+}
+
+/**
+ * Decodes `T | null | undefined` into `Option<T>` and encodes `Option<T>`
+ * back to `T | null` or `T | undefined` depending on the provided `options.onNoneEncoding` (defaults to `undefined`).
+ *
+ * When to use this:
+ * - Converting nullish API fields to `Option` when both `null` and
+ *   `undefined` represent absence.
+ *
+ * Behavior:
+ * - Decode: `null` or `undefined` → `Option.none()`, otherwise → `Option.some(value)`.
+ * - Encode: `Option.none()` → `null` or `undefined` (per `options.onNoneEncoding`),
+ *   `Option.some(value)` → `value`.
+ * - Pure and synchronous.
+ *
+ * **Example** (Option from nullish, encoding None as null)
+ *
+ * ```ts
+ * import { Schema, SchemaTransformation } from "effect"
+ *
+ * const schema = Schema.NullishOr(Schema.String).pipe(
+ *   Schema.decodeTo(
+ *     Schema.Option(Schema.String),
+ *     SchemaTransformation.optionFromNullishOr({ onNoneEncoding: null })
+ *   )
+ * )
+ * ```
+ *
+ * See also:
+ * - {@link optionFromNullOr}
+ * - {@link optionFromUndefinedOr}
+ *
+ * @since 4.0.0
+ */
+export function optionFromNullishOr<T>(
+  options?: {
+    onNoneEncoding: null | undefined
+  }
+): Transformation<Option.Option<T>, T | null | undefined> {
+  return transform({
+    decode: Option.fromNullishOr,
+    encode: options?.onNoneEncoding === null ? Option.getOrNull : Option.getOrUndefined
+  })
+}
+
 /**
  * Decodes an optional struct key into `Option<T>` and encodes `Option<T>`
  * back to an optional key.
@@ -1045,8 +1127,8 @@ export function optionFromNullOr<T>(): Transformation<Option.Option<T>, T | null
  * ```
  *
  * See also:
- * - {@link optionFromNullOr}
  * - {@link optionFromOptional}
+ * - {@link optionFromUndefinedOr}
  * - {@link transformOptional}
  *
  * @since 4.0.0
@@ -1086,8 +1168,8 @@ export function optionFromOptionalKey<T>(): Transformation<Option.Option<T>, T>
  * ```
  *
  * See also:
- * - {@link optionFromNullOr}
  * - {@link optionFromOptionalKey}
+ * - {@link optionFromUndefinedOr}
  * - {@link transformOptional}
  *
  * @since 4.0.0
@@ -1136,6 +1218,33 @@ export const urlFromString: Transformation<URL, string> = transformOrFail<URL, s
   encode: (url) => Effect.succeed(url.href)
 })
 
+/**
+ * Decodes a `string` into a `BigDecimal` and encodes a `BigDecimal` back to
+ * its string representation.
+ *
+ * When to use this:
+ * - Parsing decimal number strings from APIs or user input.
+ *
+ * Behavior:
+ * - Decode: calls `BigDecimal.fromString(s)`. Fails with `InvalidValue` if the
+ *   string is not a valid BigDecimal representation.
+ * - Encode: returns `BigDecimal.format(bd)`.
+ *
+ * @since 4.0.0
+ */
+export const bigDecimalFromString: Transformation<BigDecimal.BigDecimal, string> = transformOrFail<
+  BigDecimal.BigDecimal,
+  string
+>({
+  decode: (s) => {
+    const result = BigDecimal.fromString(s)
+    return Option.isNone(result)
+      ? Effect.fail(new Issue.InvalidValue(Option.some(s), { message: `Invalid BigDecimal string: ${s}` }))
+      : Effect.succeed(result.value)
+  },
+  encode: (bd) => Effect.succeed(BigDecimal.format(bd))
+})
+
 /**
  * Decodes a Base64-encoded `string` into a `Uint8Array` and encodes a
  * `Uint8Array` back to a Base64 string.
@@ -1264,3 +1373,79 @@ export const fromURLSearchParams = new Transformation<unknown, URLSearchParams>(
   Getter.decodeURLSearchParams(),
   Getter.encodeURLSearchParams()
 )
+
+/**
+ * @since 4.0.0
+ */
+export const timeZoneOffsetFromNumber: Transformation<DateTime.TimeZone.Offset, number> = transform<
+  DateTime.TimeZone.Offset,
+  number
+>({
+  decode: (n) => DateTime.zoneMakeOffset(n),
+  encode: (tz) => tz.offset
+})
+
+/**
+ * @since 4.0.0
+ */
+export const timeZoneNamedFromString: Transformation<DateTime.TimeZone.Named, string> = transformOrFail<
+  DateTime.TimeZone.Named,
+  string
+>({
+  decode: (s) => {
+    return Option.match(DateTime.zoneMakeNamed(s), {
+      onNone: () => Effect.fail(new Issue.InvalidValue(Option.some(s), { message: `Invalid IANA time zone: ${s}` })),
+      onSome: Effect.succeed
+    })
+  },
+  encode: (tz) => Effect.succeed(tz.id)
+})
+
+/**
+ * @since 4.0.0
+ */
+export const timeZoneFromString: Transformation<DateTime.TimeZone, string> = transformOrFail<
+  DateTime.TimeZone,
+  string
+>({
+  decode: (s) => {
+    return Option.match(DateTime.zoneFromString(s), {
+      onNone: () => Effect.fail(new Issue.InvalidValue(Option.some(s), { message: `Invalid time zone: ${s}` })),
+      onSome: Effect.succeed
+    })
+  },
+  encode: (tz) => Effect.succeed(DateTime.zoneToString(tz))
+})
+
+/**
+ * @since 4.0.0
+ */
+export const dateTimeUtcFromString: Transformation<DateTime.Utc, string> = transformOrFail<
+  DateTime.Utc,
+  string
+>({
+  decode: (s) => {
+    return Option.match(DateTime.make(s), {
+      onNone: () => Effect.fail(new Issue.InvalidValue(Option.some(s), { message: "Invalid DateTime input" })),
+      onSome: (result) => Effect.succeed(DateTime.toUtc(result))
+    })
+  },
+  encode: (utc) => Effect.succeed(DateTime.formatIso(utc))
+})
+
+/**
+ * @since 4.0.0
+ */
+export const dateTimeZonedFromString: Transformation<DateTime.Zoned, string> = transformOrFail<
+  DateTime.Zoned,
+  string
+>({
+  decode: (s) => {
+    return Option.match(DateTime.makeZonedFromString(s), {
+      onNone: () =>
+        Effect.fail(new Issue.InvalidValue(Option.some(s), { message: `Invalid zoned DateTime string: ${s}` })),
+      onSome: Effect.succeed
+    })
+  },
+  encode: (zoned) => Effect.succeed(DateTime.formatIsoZoned(zoned))
+})

package/src/ScopedCache.ts

@@ -69,7 +69,7 @@ export const makeWith = <
 >(options: {
   readonly lookup: (key: Key) => Effect.Effect<A, E, R | Scope.Scope>
   readonly capacity: number
-  readonly timeToLive?: ((exit: Exit.Exit<A, E>, key: Key) => Duration.DurationInput) | undefined
+  readonly timeToLive?: ((exit: Exit.Exit<A, E>, key: Key) => Duration.Input) | undefined
   readonly requireServicesAt?: ServiceMode | undefined
 }): Effect.Effect<
   ScopedCache<Key, A, E, "lookup" extends ServiceMode ? Exclude<R, Scope.Scope> : never>,
@@ -88,7 +88,7 @@ export const makeWith = <
     self.state = { _tag: "Open", map }
     self.capacity = options.capacity
     self.timeToLive = options.timeToLive
-      ? (exit: Exit.Exit<A, E>, key: Key) => Duration.fromDurationInputUnsafe(options.timeToLive!(exit, key))
+      ? (exit: Exit.Exit<A, E>, key: Key) => Duration.fromInputUnsafe(options.timeToLive!(exit, key))
       : defaultTimeToLive
     return effect.as(
       Scope.addFinalizer(
@@ -116,7 +116,7 @@ export const make = <
   options: {
     readonly lookup: (key: Key) => Effect.Effect<A, E, R | Scope.Scope>
     readonly capacity: number
-    readonly timeToLive?: Duration.DurationInput | undefined
+    readonly timeToLive?: Duration.Input | undefined
     readonly requireServicesAt?: ServiceMode | undefined
   }
 ): Effect.Effect<