effect-app 4.0.0-beta.16 → 4.0.0-beta.161

package/src/Schema/email.ts

@@ -12,11 +12,16 @@ export type Email = string & EmailBrand
 export const Email = S
   .String
   .pipe(
+    S.annotate({
+      title: "Email",
+      description: "an email according to RFC 5322",
+      format: "email"
+    }),
+    S.check(S.isMinLength(3), /* a@b */ S.isMaxLength(998)),
     S.refine(isValidEmail as Refinement<string, Email>, {
       identifier: "Email",
-      title: "Email",
       description: "an email according to RFC 5322",
-      jsonSchema: { format: "email", minLength: 3, /* a@b */ maxLength: 998 }
+      jsonSchema: { format: "email", minLength: 3, maxLength: 998 }
     }),
     S.annotate({
       toArbitrary: () => (fc) => fc.emailAddress().map((_) => _ as Email)

package/src/Schema/ext.ts

@@ -1,56 +1,107 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
-import { Effect, Option, pipe, Schema, type SchemaAST, SchemaGetter, SchemaIssue, SchemaParser, SchemaTransformation, type ServiceMap } from "effect"
+import { Effect, Function, Option, pipe, type SchemaAST, SchemaIssue, SchemaTransformation } from "effect"
 import * as S from "effect/Schema"
+import { isDateValid } from "effect/Schema"
 import { type NonEmptyReadonlyArray } from "../Array.js"
+import * as Context from "../Context.js"
 import { extendM, typedKeysOf } from "../utils.js"
 import { type AST } from "./schema.js"
 
-// TODO: v4 migration — withConstructorDefault signature changed, propertySignature removed
-// Constraint relaxed from `Self extends S.Top & S.WithoutConstructorDefault` to `Self extends S.Top`
-// because `.pipe()` widens the schema type to `Top` which doesn't satisfy `WithoutConstructorDefault`.
-// The narrowing assertions below are safe — we're asserting "this schema hasn't had a default applied yet".
-export const withDefaultConstructor = <A>(
-  makeDefault: () => NoInfer<A>
-) =>
-<Self extends S.Top>(self: Self): S.withConstructorDefault<Self & S.WithoutConstructorDefault> => {
-  type Narrowed = Self & S.WithoutConstructorDefault
-  return S.withConstructorDefault<Narrowed>(
-    () => Option.some(makeDefault() as Narrowed["~type.make.in"])
-  )(self as Narrowed)
-}
+type ProvidedCodec<Self extends S.Top, R> = S.Codec<
+  Self["Type"],
+  Self["Encoded"],
+  Exclude<Self["DecodingServices"], R>,
+  Exclude<Self["EncodingServices"], R>
+>
+
+export const DefaultParseOptions: SchemaAST.ParseOptions = { concurrency: "unbounded" }
+
+type DecodeLike = (schema: any) => (input: any, options?: SchemaAST.ParseOptions) => any
+
+export const withDefaultParseOptions = <Decode extends DecodeLike>(
+  decode: Decode,
+  defaultParseOptions: SchemaAST.ParseOptions = DefaultParseOptions
+): Decode =>
+  ((schema: any) => {
+    const run = decode(schema)
+    return (input: any, options?: SchemaAST.ParseOptions) => run(input, { ...defaultParseOptions, ...options })
+  }) as Decode
 
 // TODO: v4 migration - Date is no longer by default encoded to string.
-const DateFromString = Schema.Date.pipe(
-  Schema.encodeTo(Schema.String, {
-    decode: SchemaGetter.Date(),
-    encode: SchemaGetter.transform((_) => _.toISOString())
-  })
-)
+
+const DateString = S.String.annotate({
+  identifier: "Date",
+  description: "a string in ISO 8601 format that will be decoded as a Date",
+  format: "date-time"
+})
+
+/**
+ * Schema type for {@link DateFromString}.
+ *
+ * @category Schemas
+ * @since 4.0.0
+ */
+export interface DateFromString extends S.decodeTo<S.Date, S.String> {}
+
+/**
+ * A transformation schema that parses an ISO 8601 string into a `Date`.
+ *
+ * Decoding:
+ * - A `string` is decoded as a `Date`.
+ *
+ * Encoding:
+ * - A `Date` is encoded as a `string`.
+ *
+ * @since 4.0.0
+ */
+export const DateFromString: DateFromString = DateString.pipe(S.decodeTo(S.Date, SchemaTransformation.dateFromString))
 
 /**
  * Like the default Schema `Date` but from String with `withDefault` => now
  */
 export const Date = Object.assign(DateFromString, {
-  withDefault: DateFromString.pipe(withDefaultConstructor(() => new global.Date()))
+  withDefault: DateFromString.pipe(S.withConstructorDefault(Effect.sync(() => new global.Date()))),
+  withDecodingDefaultType: DateFromString.pipe(S.withDecodingDefaultType(Effect.sync(() => new global.Date())))
+})
+
+/**
+ * Like the default Schema `DateValid` but from String with `withDefault` => now
+ */
+export const DateValid = Object.assign(Date.check(isDateValid()), {
+  withDefault: DateFromString.pipe(S.withConstructorDefault(Effect.sync(() => new global.Date()))),
+  withDecodingDefaultType: DateFromString.pipe(S.withDecodingDefaultType(Effect.sync(() => new global.Date())))
 })
 
 /**
  * Like the default Schema `Boolean` but with `withDefault` => false
  */
 export const Boolean = Object.assign(S.Boolean, {
-  withDefault: S.Boolean.pipe(withDefaultConstructor(() => false))
+  withDefault: S.Boolean.pipe(S.withConstructorDefault(Effect.succeed(false))),
+  withDecodingDefaultType: S.Boolean.pipe(S.withDecodingDefaultType(Effect.succeed(false)))
 })
 
 /**
+ * You probably want to use `Finite` instead of this.
  * Like the default Schema `Number` but with `withDefault` => 0
  */
-export const Number = Object.assign(S.Number, { withDefault: S.Number.pipe(withDefaultConstructor(() => 0)) })
+export const Number = Object.assign(S.Number, {
+  withDefault: S.Number.pipe(S.withConstructorDefault(Effect.succeed(0))),
+  withDecodingDefaultType: S.Number.pipe(S.withDecodingDefaultType(Effect.succeed(0)))
+})
 
 /**
- * Like the default Schema `Literal` but with `withDefault` => literals[0]
+ * Like the default Schema `Finite` but with `withDefault` => 0
  */
-export const Literal = <Literals extends NonEmptyReadonlyArray<AST.LiteralValue>>(...literals: Literals) =>
+export const Finite = Object.assign(S.Finite, {
+  withDefault: S.Finite.pipe(S.withConstructorDefault(Effect.succeed(0))),
+  withDecodingDefaultType: S.Finite.pipe(S.withDecodingDefaultType(Effect.succeed(0)))
+})
+
+/**
+ * Like the default Schema `Literals` but with `withDefault` => literals[0]
+ */
+export const Literals = <const Literals extends NonEmptyReadonlyArray<AST.LiteralValue>>(literals: Literals) =>
   pipe(
     S.Literals(literals),
     (s) =>
@@ -58,79 +109,141 @@ export const Literal = <Literals extends NonEmptyReadonlyArray<AST.LiteralValue>
         changeDefault: <A extends Literals[number]>(a: A) => {
           return Object.assign(S.Literals(literals), {
             Default: a,
-            withDefault: s.pipe(withDefaultConstructor(() => a))
+            withDefault: s.pipe(S.withConstructorDefault(Effect.succeed(a))),
+            withDecodingDefaultType: s.pipe(S.withDecodingDefaultType(Effect.succeed(a)))
           }) // todo: copy annotations from original?
         },
-        Default: literals[0] as typeof literals[0],
-        withDefault: s.pipe(withDefaultConstructor(() => literals[0]))
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion -- load-bearing: Object.assign widens the field type without it, breaking `expectTypeOf(l.Default).toEqualTypeOf<"a">()` in tests
+        Default: literals[0] as Literals[0],
+        withDefault: s.pipe(S.withConstructorDefault(Effect.succeed(literals[0]))),
+        withDecodingDefaultType: s.pipe(S.withDecodingDefaultType(Effect.succeed(literals[0])))
       })
   )
 
 /**
  * Like the default Schema `Array` but with `withDefault` => []
  */
-export function Array<Value extends S.Top>(value: Value) {
+export function Array<ValueSchema extends S.Top>(value: ValueSchema) {
   return pipe(
     S.Array(value),
-    (s) => Object.assign(s, { withDefault: s.pipe(withDefaultConstructor(() => [])) })
+    (s) =>
+      Object.assign(s, {
+        withDefault: s.pipe(S.withConstructorDefault(Effect.sync(() => []))),
+        withDecodingDefaultType: s.pipe(S.withDecodingDefaultType(Effect.sync(() => [])))
+      })
   )
 }
 
 /**
- * Like the default Schema `Map` but with `withDefault` => []
+ * An annotated `S.Array` of unique items that decodes to a `ReadonlySet`.
  */
-function Map_<Key extends S.Top, Value extends S.Top>(input: { key: Key; value: Value }) {
-  return pipe(
-    S.ReadonlyMap(input.key, input.value),
-    (s) => Object.assign(s, { withDefault: s.pipe(withDefaultConstructor(() => new global.Map())) })
+export const ReadonlySetFromArray = <ValueSchema extends S.Top>(value: ValueSchema) => {
+  const from = S
+    .Array(value)
+    .annotate({ expected: "an array of unique items that will be decoded as a ReadonlySet" })
+  const to = S.instanceOf(Set) as S.instanceOf<ReadonlySet<S.Schema.Type<ValueSchema>>>
+  const schema = from.pipe(
+    S.decodeTo(
+      to,
+      SchemaTransformation.transform({
+        decode: (arr) => new Set(arr) as ReadonlySet<S.Schema.Type<ValueSchema>>,
+        encode: (set) => [...set]
+      })
+    )
   )
+  return schema
 }
 
-export { Map_ as Map }
+/**
+ * An annotated `S.Array` of key-value tuples that decodes to a `ReadonlyMap`.
+ */
+export const ReadonlyMapFromArray = <KeySchema extends S.Top, ValueSchema extends S.Top>(pair: {
+  readonly key: KeySchema
+  readonly value: ValueSchema
+}) => {
+  const from = S
+    .Array(S.Tuple([pair.key, pair.value]))
+    .annotate({ expected: "an array of key-value tuples that will be decoded as a ReadonlyMap" })
+  const to = S.instanceOf(Map) as S.instanceOf<
+    ReadonlyMap<S.Schema.Type<KeySchema>, S.Schema.Type<ValueSchema>>
+  >
+  const schema = from.pipe(
+    S.decodeTo(
+      to,
+      SchemaTransformation.transform({
+        decode: (
+          arr
+        ) => new Map(arr) as ReadonlyMap<S.Schema.Type<KeySchema>, S.Schema.Type<ValueSchema>>,
+        encode: (
+          map
+        ) => [...map.entries()] as any // fu
+      })
+    )
+  )
+  return schema
+}
 
 /**
- * Like the default Schema `ReadonlySet` but with `withDefault` => new Set()
+ * Like the default Schema `ReadonlySet` but from Array with `withDefault` => new Set()
  */
-export const ReadonlySet = <Value extends S.Top>(value: Value) =>
+export const ReadonlySet = <ValueSchema extends S.Top>(value: ValueSchema) =>
   pipe(
-    S.ReadonlySet(value),
-    (s) => Object.assign(s, { withDefault: s.pipe(withDefaultConstructor(() => new Set<S.Schema.Type<Value>>())) })
+    ReadonlySetFromArray(value),
+    (s) =>
+      Object.assign(s, {
+        withDefault: s.pipe(S.withConstructorDefault(Effect.sync(() => new Set<S.Schema.Type<ValueSchema>>()))),
+        withDecodingDefaultType: s.pipe(
+          S.withDecodingDefaultType(Effect.sync(() => new Set<S.Schema.Type<ValueSchema>>()))
+        )
+      })
   )
 
 /**
- * Like the default Schema `ReadonlyMap` but with `withDefault` => new Map()
+ * Like the default Schema `ReadonlyMap` but from Array with `withDefault` => new Map()
  */
-export const ReadonlyMap = <K extends S.Top, V extends S.Top>(pair: {
-  readonly key: K
-  readonly value: V
+export const ReadonlyMap = <KeySchema extends S.Top, ValueSchema extends S.Top>(pair: {
+  readonly key: KeySchema
+  readonly value: ValueSchema
 }) =>
   pipe(
-    S.ReadonlyMap(pair.key, pair.value),
-    (s) => Object.assign(s, { withDefault: s.pipe(withDefaultConstructor(() => new Map())) })
+    ReadonlyMapFromArray(pair),
+    (s) =>
+      Object.assign(s, {
+        withDefault: s.pipe(S.withConstructorDefault(Effect.sync(() => new Map()))),
+        withDecodingDefaultType: s.pipe(S.withDecodingDefaultType(Effect.sync(() => new Map())))
+      })
   )
 
 /**
  * Like the default Schema `NullOr` but with `withDefault` => null
  */
-export const NullOr = <S extends S.Top>(self: S) =>
+export const NullOr = <Schema extends S.Top>(self: Schema) =>
   pipe(
     S.NullOr(self),
-    (s) => Object.assign(s, { withDefault: s.pipe(withDefaultConstructor(() => null)) })
+    (s) =>
+      Object.assign(s, {
+        withDefault: s.pipe(S.withConstructorDefault(Effect.succeed(null))),
+        withDecodingDefaultType: s.pipe(S.withDecodingDefaultType(Effect.succeed(null)))
+      })
   )
 
-export const defaultDate = (s: S.Top) => s.pipe(withDefaultConstructor(() => new global.Date()))
+export const defaultDate = <Schema extends S.Top & S.WithoutConstructorDefault>(schema: Schema) =>
+  schema.pipe(S.withConstructorDefault(Effect.sync(() => new global.Date())))
 
-export const defaultBool = (s: S.Top) => s.pipe(withDefaultConstructor(() => false))
+export const defaultBool = <Schema extends S.Top & S.WithoutConstructorDefault>(schema: Schema) =>
+  schema.pipe(S.withConstructorDefault(Effect.succeed(false)))
 
-export const defaultNullable = (
-  s: S.Top
-) => s.pipe(withDefaultConstructor(() => null))
+export const defaultNullable = <Schema extends S.Top & S.WithoutConstructorDefault>(schema: Schema) =>
+  schema.pipe(S.withConstructorDefault(Effect.succeed(null)))
 
-export const defaultArray = (s: S.Top) => s.pipe(withDefaultConstructor(() => []))
+export const defaultArray = <Schema extends S.Top & S.WithoutConstructorDefault>(schema: Schema) =>
+  schema.pipe(S.withConstructorDefault(Effect.sync(() => [])))
 
-export const defaultMap = (s: S.Top) => s.pipe(withDefaultConstructor(() => new Map()))
+export const defaultMap = <Schema extends S.Top & S.WithoutConstructorDefault>(schema: Schema) =>
+  schema.pipe(S.withConstructorDefault(Effect.sync(() => new Map())))
 
-export const defaultSet = (s: S.Top) => s.pipe(withDefaultConstructor(() => new Set()))
+export const defaultSet = <Schema extends S.Top & S.WithoutConstructorDefault>(schema: Schema) =>
+  schema.pipe(S.withConstructorDefault(Effect.sync(() => new Set())))
 
 export const withDefaultMake = <Self extends S.Top>(s: Self) => {
   const a = Object.assign(S.decodeSync(s as any) as WithDefaults<Self>, s)
@@ -160,8 +273,11 @@ export type WithDefaults<Self extends S.Top> = (
 //   : never
 
 export const inputDate = extendM(
-  S.Union([S.DateValid, S.Date]),
-  (s) => ({ withDefault: s.pipe(withDefaultConstructor(() => new globalThis.Date())) })
+  S.Union([S.DateValid, Date]),
+  (s) => ({
+    withDefault: s.pipe(S.withConstructorDefault(Effect.sync(() => new globalThis.Date()))),
+    withDecodingDefaultType: s.pipe(S.withDecodingDefaultType(Effect.sync(() => new globalThis.Date())))
+  })
 )
 
 export interface UnionBrand {}
@@ -211,7 +327,7 @@ export const transformTo = <To extends S.Top, From extends S.Top>(
               { message: "One way schema transformation, encoding is not allowed" }
             )
           )
-      }) as any
+      })
     )
   )
 
@@ -228,7 +344,7 @@ export const transformToOrFail = <To extends S.Top, From extends S.Top, RD>(
     S.decodeTo(
       to,
       SchemaTransformation.transformOrFail({
-        decode: decode as any,
+        decode,
         encode: (i: any) =>
           Effect.fail(
             new SchemaIssue.Forbidden(
@@ -236,33 +352,36 @@ export const transformToOrFail = <To extends S.Top, From extends S.Top, RD>(
               { message: "One way schema transformation, encoding is not allowed" }
             )
           )
-      }) as any
+      })
     )
   )
 
-// TODO: v4 migration — S.declare API changed (no [self] + decode/encode pattern)
-// Need to find v4 equivalent for contextual schema wrapping
-export const provide = <Self extends S.Top, R>(
-  self: Self,
-  context: ServiceMap.ServiceMap<R>
-): any => {
+export const provide: {
+  <R>(context: Context.Context<R>): <Self extends S.Top>(self: Self) => ProvidedCodec<Self, R>
+  <Self extends S.Top, R>(self: Self, context: Context.Context<R>): ProvidedCodec<Self, R>
+} = Function.dual(2, <Self extends S.Top, R>(self: Self, context: Context.Context<R>): ProvidedCodec<Self, R> => {
   const prov = Effect.provide(context)
-  return S
-    .declare((_u: unknown): _u is unknown => true) // placeholder — needs proper v4 declare
-    .pipe(
-      S.decodeTo(
-        self,
-        SchemaTransformation.transformOrFail({
-          decode: (n: any) => prov(SchemaParser.decodeUnknownEffect(self)(n)),
-          encode: (n: any) => prov(SchemaParser.encodeUnknownEffect(self)(n))
-        }) as any
-      ) as any
-    )
-}
-// TODO: v4 migration — ServiceMap.pick and S.declare pattern removed
-export const contextFromServices = <Self extends S.Top, Tags extends readonly any[]>(
-  _self: Self,
-  ..._services: Tags
-): any => {
-  throw new Error("contextFromServices: not yet migrated to v4")
-}
+  return self.pipe(
+    S.middlewareDecoding((effect) => prov(effect)),
+    S.middlewareEncoding((effect) => prov(effect))
+  )
+})
+export const contextFromServices = Effect.fnUntraced(function*<
+  Self extends S.Top,
+  Tags extends ReadonlyArray<Context.Key<any, any>>
+>(self: Self, ...services: Tags) {
+  const context: Context.Context<Context.Service.Identifier<Tags[number]>> = Context.pick(...services)(
+    yield* Effect.context<Context.Service.Identifier<Tags[number]>>()
+  )
+  return provide(self, context)
+}) as <
+  Self extends S.Top,
+  Tags extends ReadonlyArray<Context.Key<any, any>>
+>(
+  self: Self,
+  ...services: Tags
+) => Effect.Effect<
+  ProvidedCodec<Self, Context.Service.Identifier<Tags[number]>>,
+  never,
+  Context.Service.Identifier<Tags[number]>
+>

package/src/Schema/moreStrings.ts

@@ -1,4 +1,4 @@
-import { pipe } from "effect"
+import { Effect, pipe } from "effect"
 import type { Refinement } from "effect-app/Function"
 import { extendM } from "effect-app/utils"
 import * as S from "effect/Schema"
@@ -6,7 +6,7 @@ import type { Simplify } from "effect/Types"
 import { customRandom, nanoid, urlAlphabet } from "nanoid"
 import validator from "validator"
 import { fromBrand, nominal } from "./brand.js"
-import { withDefaultConstructor, withDefaultMake, type WithDefaults } from "./ext.js"
+import { withDefaultMake, type WithDefaults } from "./ext.js"
 import { type B } from "./schema.js"
 import type { NonEmptyString255Brand, NonEmptyStringBrand } from "./strings.js"
 
@@ -27,9 +27,8 @@ export type NonEmptyString50 = string & NonEmptyString50Brand
  */
 export const NonEmptyString50 = nonEmptyString.pipe(
   S.check(S.isMaxLength(50)),
-  fromBrand(nominal<NonEmptyString50>(), {
+  fromBrand<NonEmptyString50>(nominal<NonEmptyString50>(), {
     identifier: "NonEmptyString50",
-    title: "NonEmptyString50",
     jsonSchema: {}
   }),
   withDefaultMake
@@ -50,9 +49,8 @@ export type NonEmptyString64 = string & NonEmptyString64Brand
  */
 export const NonEmptyString64 = nonEmptyString.pipe(
   S.check(S.isMaxLength(64)),
-  fromBrand(nominal<NonEmptyString64>(), {
+  fromBrand<NonEmptyString64>(nominal<NonEmptyString64>(), {
     identifier: "NonEmptyString64",
-    title: "NonEmptyString64",
     jsonSchema: {}
   }),
   withDefaultMake
@@ -74,9 +72,8 @@ export type NonEmptyString80 = string & NonEmptyString80Brand
 
 export const NonEmptyString80 = nonEmptyString.pipe(
   S.check(S.isMaxLength(80)),
-  fromBrand(nominal<NonEmptyString80>(), {
+  fromBrand<NonEmptyString80>(nominal<NonEmptyString80>(), {
     identifier: "NonEmptyString80",
-    title: "NonEmptyString80",
     jsonSchema: {}
   }),
   withDefaultMake
@@ -97,9 +94,8 @@ export type NonEmptyString100 = string & NonEmptyString100Brand
  */
 export const NonEmptyString100 = nonEmptyString.pipe(
   S.check(S.isMaxLength(100)),
-  fromBrand(nominal<NonEmptyString100>(), {
+  fromBrand<NonEmptyString100>(nominal<NonEmptyString100>(), {
     identifier: "NonEmptyString100",
-    title: "NonEmptyString100",
     jsonSchema: {}
   }),
   withDefaultMake
@@ -121,7 +117,10 @@ export type Min3String255 = string & Min3String255Brand
 export const Min3String255 = pipe(
   S.String,
   S.check(S.isMinLength(3), S.isMaxLength(255)),
-  fromBrand(nominal<Min3String255>(), { identifier: "Min3String255", title: "Min3String255", jsonSchema: {} }),
+  fromBrand<Min3String255>(nominal<Min3String255>(), {
+    identifier: "Min3String255",
+    jsonSchema: {}
+  }),
   withDefaultMake
 )
 
@@ -151,16 +150,15 @@ export const StringId = extendM(
   pipe(
     S.String,
     S.check(S.isMinLength(minLength), S.isMaxLength(maxLength)),
-    fromBrand(nominal<StringId>(), {
+    fromBrand<StringId>(nominal<StringId>(), {
       identifier: "StringId",
-      title: "StringId",
       toArbitrary: () => (fc) => StringIdArb()(fc),
       jsonSchema: {}
     })
   ),
   (s) => ({
     make: makeStringId,
-    withDefault: s.pipe(withDefaultConstructor(makeStringId))
+    withDefault: s.pipe(S.withConstructorDefault(Effect.sync(makeStringId)))
   })
 )
   .pipe(withDefaultMake)
@@ -182,16 +180,15 @@ export function prefixedStringId<Brand extends StringId>() {
         (x) => (pref + x.substring(0, 50 - pref.length)) as Brand
       )
     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    const s: S.Codec<string & Brand, string> = StringId
+    const s = StringId
       .pipe(
         S.refine((x: string): x is string & Brand => x.startsWith(pref), {
-          identifier: name,
-          title: name
+          identifier: name
         }),
         S.annotate({
           toArbitrary: () => (fc) => arb()(fc)
         })
-      ) as S.Codec<string & Brand, string>
+      )
     const schema = s.pipe(withDefaultMake)
     const make = () => (pref + StringId.make().substring(0, 50 - pref.length)) as Brand
 
@@ -208,7 +205,9 @@ export function prefixedStringId<Brand extends StringId>() {
          */
         prefixSafe: <REST extends string>(str: `${Prefix}${Separator}${REST}`) => ex(str),
         prefix,
-        withDefault: schema.pipe(withDefaultConstructor(make))
+        withDefault: schema.pipe(S.withConstructorDefault<S.Codec<Brand, string> & S.WithoutConstructorDefault>(
+          Effect.sync(make)
+        ))
       })
     )
   }
@@ -247,9 +246,12 @@ const isUrl: Refinement<string, Url> = (s: string): s is Url => {
 export const Url = S
   .String
   .pipe(
+    S.annotate({
+      title: "Url",
+      format: "uri"
+    }),
     S.refine(isUrl, {
       identifier: "Url",
-      title: "Url",
       jsonSchema: { format: "uri" }
     }),
     S.annotate({

package/src/Schema/numbers.ts

@@ -1,8 +1,9 @@
+import { Effect } from "effect"
 import { extendM } from "effect-app/utils"
 import * as S from "effect/Schema"
 import type { Simplify } from "effect/Types"
 import { fromBrand, nominal } from "./brand.js"
-import { withDefaultConstructor, withDefaultMake } from "./ext.js"
+import { withDefaultMake } from "./ext.js"
 import { type B } from "./schema.js"
 
 export interface PositiveIntBrand
@@ -11,10 +12,10 @@ export interface PositiveIntBrand
 export const PositiveInt = extendM(
   S.Int.pipe(
     S.check(S.isGreaterThan(0)),
-    fromBrand(nominal<PositiveInt>(), { identifier: "PositiveInt", title: "PositiveInt", jsonSchema: {} }),
+    fromBrand<PositiveInt>(nominal<PositiveInt>(), { identifier: "PositiveInt", jsonSchema: {} }),
     withDefaultMake
   ),
-  (s) => ({ withDefault: s.pipe(withDefaultConstructor(() => s(1))) })
+  (s) => ({ withDefault: s.pipe(S.withConstructorDefault(Effect.sync(() => s(1)))) })
 )
 export type PositiveInt = number & PositiveIntBrand
 
@@ -22,53 +23,50 @@ export interface NonNegativeIntBrand extends Simplify<B.Brand<"NonNegativeInt">
 export const NonNegativeInt = extendM(
   S.Int.pipe(
     S.check(S.isGreaterThanOrEqualTo(0)),
-    fromBrand(nominal<NonNegativeInt>(), {
+    fromBrand<NonNegativeInt>(nominal<NonNegativeInt>(), {
       identifier: "NonNegativeInt",
-      title: "NonNegativeInt",
       jsonSchema: {}
     }),
     withDefaultMake
   ),
-  (s) => ({ withDefault: s.pipe(withDefaultConstructor(() => s(0))) })
+  (s) => ({ withDefault: s.pipe(S.withConstructorDefault(Effect.sync(() => s(0)))) })
 )
 export type NonNegativeInt = number & NonNegativeIntBrand
 
 export interface IntBrand extends Simplify<B.Brand<"Int">> {}
 export const Int = extendM(
-  S.Int.pipe(fromBrand(nominal<Int>(), { identifier: "Int", title: "Int", jsonSchema: {} }), withDefaultMake),
-  (s) => ({ withDefault: s.pipe(withDefaultConstructor(() => s(0))) })
+  S.Int.pipe(fromBrand<Int>(nominal<Int>(), { identifier: "Int", jsonSchema: {} }), withDefaultMake),
+  (s) => ({ withDefault: s.pipe(S.withConstructorDefault(Effect.sync(() => s(0)))) })
 )
 export type Int = number & IntBrand
 
 export interface PositiveNumberBrand extends Simplify<B.Brand<"PositiveNumber"> & NonNegativeNumberBrand> {}
 export const PositiveNumber = extendM(
-  S.Number.pipe(
+  S.Finite.pipe(
     S.check(S.isGreaterThan(0)),
-    fromBrand(nominal<PositiveNumber>(), {
+    fromBrand<PositiveNumber>(nominal<PositiveNumber>(), {
       identifier: "PositiveNumber",
-      title: "PositiveNumber",
       jsonSchema: {}
     }),
     withDefaultMake
   ),
-  (s) => ({ withDefault: s.pipe(withDefaultConstructor(() => s(1))) })
+  (s) => ({ withDefault: s.pipe(S.withConstructorDefault(Effect.sync(() => s(1)))) })
 )
 export type PositiveNumber = number & PositiveNumberBrand
 
 export interface NonNegativeNumberBrand extends Simplify<B.Brand<"NonNegativeNumber">> {}
 export const NonNegativeNumber = extendM(
   S
-    .Number
+    .Finite
     .pipe(
       S.check(S.isGreaterThanOrEqualTo(0)),
-      fromBrand(nominal<NonNegativeNumber>(), {
+      fromBrand<NonNegativeNumber>(nominal<NonNegativeNumber>(), {
         identifier: "NonNegativeNumber",
-        title: "NonNegativeNumber",
         jsonSchema: {}
       }),
       withDefaultMake
     ),
-  (s) => ({ withDefault: s.pipe(withDefaultConstructor(() => s(0))) })
+  (s) => ({ withDefault: s.pipe(S.withConstructorDefault(Effect.sync(() => s(0)))) })
 )
 export type NonNegativeNumber = number & NonNegativeNumberBrand
 

package/src/Schema/phoneNumber.ts

@@ -13,9 +13,13 @@ export type PhoneNumber = string & PhoneNumberBrand
 export const PhoneNumber = S
   .String
   .pipe(
+    S.annotate({
+      title: "PhoneNumber",
+      description: "a phone number with at least 7 digits",
+      format: "phone"
+    }),
     S.refine(isValidPhone as Refinement<string, PhoneNumber>, {
       identifier: "PhoneNumber",
-      title: "PhoneNumber",
       description: "a phone number with at least 7 digits",
       jsonSchema: { format: "phone" }
     }),