effect-app 4.0.0-beta.310 → 4.0.0-beta.312

package/src/Schema/Class.ts

@@ -1,7 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import type * as Cause from "effect/Cause"
 import * as Effect from "effect/Effect"
-import * as Option from "effect/Option"
 import * as S from "effect/Schema"
 import * as SchemaGetter from "effect/SchemaGetter"
 import * as SchemaIssue from "effect/SchemaIssue"
@@ -14,9 +13,11 @@ import * as SchemaParser from "./SchemaParser.ts"
 
 type ClassAnnotations<Self> = S.Annotations.Declaration<Self, readonly [any]>
 
-export interface EnhancedClass<Self, SchemaS extends S.Top & { readonly fields: S.Struct.Fields }, Inherited>
-  extends S.Class<Self, SchemaS, Inherited>
-{
+export interface EnhancedClass<
+  Self,
+  SchemaS extends S.Constraint & { readonly fields: S.Struct.Fields },
+  Inherited
+> extends S.Class<Self, SchemaS, Inherited> {
   /**
    * See `copyOrigin` docs in `utils.ts` for return-type design details.
    */
@@ -39,12 +40,22 @@ export declare const ExtendedSchemaNoEncoded: unique symbol
 
 export type ExtendedSchemaNoEncoded = typeof ExtendedSchemaNoEncoded
 
-type WithEncoded<SchemaS extends S.Top, Encoded> = Omit<SchemaS, "Encoded"> & { readonly Encoded: Encoded }
+/**
+ * Override schema `Encoded` while keeping `Constraint` (intersection, not `Omit`).
+ * Free type-params for `Encoded` keep the conditional unresolved — callers that
+ * need Encoded overrides use the intersection form of the class factory return type.
+ */
+type WithEncoded<SchemaS extends S.Constraint, Encoded> = SchemaS & { readonly Encoded: Encoded }
 
-type ExtendedSchema<SchemaS extends S.Top, Encoded> = [Encoded] extends [ExtendedSchemaNoEncoded] ? SchemaS
+type ExtendedSchema<SchemaS extends S.Constraint & { readonly fields: S.Struct.Fields }, Encoded> = [
+  Encoded
+] extends [ExtendedSchemaNoEncoded] ? SchemaS
   : WithEncoded<SchemaS, Encoded>
 
-export type Class<Self, S extends S.Top & { readonly fields: S.Struct.Fields }, Inherited> = EnhancedClass<
+/** Struct fields schema, optionally with a caller-supplied Encoded override. */
+type ClassFieldsSchema<Fields extends S.Struct.Fields, Encoded> = ExtendedSchema<S.Struct<Fields>, Encoded>
+
+export type Class<Self, S extends S.Constraint & { readonly fields: S.Struct.Fields }, Inherited> = EnhancedClass<
   Self,
   S,
   Inherited
@@ -73,7 +84,7 @@ function makeRelaxedDeclaration(
       if (input !== null && typeof input === "object") {
         return decodeStruct(input, options)
       }
-      return Effect.fail(new SchemaIssue.InvalidType(self, Option.some(input)))
+      return Effect.fail(new SchemaIssue.InvalidType(self, input))
     },
     ast.annotations,
     ast.checks,
@@ -114,7 +125,7 @@ export const Class: <Self = never, Encoded = ExtendedSchemaNoEncoded, Brand = {}
 ) => [Self] extends [never] ? MissingSelfGeneric<"Class">
   : EnhancedClass<
     Self,
-    ExtendedSchema<S.Struct<Fields>, Encoded>,
+    ClassFieldsSchema<Fields, Encoded>,
     Brand
   > = (identifier) => (fields, annotations, options) => {
     const relaxed = options?.strict === false
@@ -182,7 +193,7 @@ export const TaggedClass: <Self = never, Encoded = ExtendedSchemaNoEncoded, Bran
 ) => [Self] extends [never] ? MissingSelfGeneric<"TaggedClass">
   : EnhancedClass<
     Self,
-    ExtendedSchema<S.Struct<{ readonly _tag: S.tag<Tag> } & Fields>, Encoded>,
+    ClassFieldsSchema<{ readonly _tag: S.tag<Tag> } & Fields, Encoded>,
     Brand
   > = (identifier) => (tag, fields, annotations, options) => {
     const relaxed = options?.strict === false
@@ -227,11 +238,11 @@ export const ErrorClass: <Self = never, Encoded = ExtendedSchemaNoEncoded, Brand
 ) => [Self] extends [never] ? MissingSelfGeneric<"ErrorClass">
   : EnhancedClass<
     Self,
-    ExtendedSchema<S.Struct<Fields>, Encoded>,
+    ClassFieldsSchema<Fields, Encoded>,
     Cause.YieldableError & Brand
   > = (identifier) => (fields, annotations, options) => {
     const relaxed = options?.strict === false
-    const Base = (S.ErrorClass as any)(identifier)(fields, { ...concurrencyUnbounded, ...annotations })
+    const Base = (S.Error as any)(identifier)(fields, { ...concurrencyUnbounded, ...annotations })
     const originalAstDescriptor = Object.getOwnPropertyDescriptor(Base, "ast")!
     const astCache = new WeakMap<any, SchemaAST.Declaration>()
     const copyCache = new WeakMap<any, ReturnType<typeof copyOrigin>>()
@@ -273,11 +284,11 @@ export const TaggedErrorClass: <Self = never, Encoded = ExtendedSchemaNoEncoded,
 ) => [Self] extends [never] ? MissingSelfGeneric<"TaggedErrorClass">
   : EnhancedClass<
     Self,
-    ExtendedSchema<S.Struct<{ readonly _tag: S.tag<Tag> } & Fields>, Encoded>,
+    ClassFieldsSchema<{ readonly _tag: S.tag<Tag> } & Fields, Encoded>,
     Cause.YieldableError & Brand
   > = (identifier) => (tag, fields, annotations, options) => {
     const relaxed = options?.strict === false
-    const Base = (S.TaggedErrorClass as any)(identifier)(tag, fields, { ...concurrencyUnbounded, ...annotations })
+    const Base = (S.TaggedError as any)(identifier)(tag, fields, { ...concurrencyUnbounded, ...annotations })
     const originalAstDescriptor = Object.getOwnPropertyDescriptor(Base, "ast")!
     const astCache = new WeakMap<any, SchemaAST.Declaration>()
     const copyCache = new WeakMap<any, ReturnType<typeof copyOrigin>>()
@@ -305,9 +316,9 @@ export const TaggedErrorClass: <Self = never, Encoded = ExtendedSchemaNoEncoded,
     } as any
   }
 
-export interface Opaque<Self, Encoded, SchemaS extends S.Top, Brand>
-  extends S.Opaque<Self, ExtendedSchema<SchemaS, Encoded>, Brand>
-{}
+export interface Opaque<Self, Encoded, SchemaS extends S.Top, Brand> extends S.Opaque<Self, SchemaS, Brand> {
+  readonly "Encoded": Encoded extends ExtendedSchemaNoEncoded ? SchemaS["Encoded"] : Encoded
+}
 
 export const Opaque: <Self, Encoded = ExtendedSchemaNoEncoded, Brand = {}>() => <S extends S.Top>(
   schema: S
@@ -338,9 +349,8 @@ export const Opaque: <Self, Encoded = ExtendedSchemaNoEncoded, Brand = {}>() =>
  * (`~type.make.in`) and other derived members are still computed from the struct. See
  * a future `OpaqueShape`-style helper if those also need to be supplied.
  */
-export interface OpaqueType<Self, Encoded, SchemaS extends S.Top, Brand>
-  extends S.Opaque<Self, ExtendedSchema<SchemaS, Encoded>, Brand>
-{
+export interface OpaqueType<Self, Encoded, SchemaS extends S.Top, Brand> extends S.Opaque<Self, SchemaS, Brand> {
+  readonly "Encoded": Encoded extends ExtendedSchemaNoEncoded ? SchemaS["Encoded"] : Encoded
   new(_: never): Self
 }
 
@@ -348,12 +358,6 @@ export const OpaqueType: <Self, Encoded = ExtendedSchemaNoEncoded, Brand = {}>()
   schema: S
 ) => OpaqueType<Self, Encoded, S, Brand> & Omit<S, keyof S.Top> = S.Opaque as any
 
-// Override both the `Encoded` and make-input (`~type.make.in`) members in one go,
-// like `ExtendedSchema` does for `Encoded` alone.
-type ExtendedShape<SchemaS extends S.Top, Encoded, MakeIn> =
-  & Omit<SchemaS, "Encoded" | "~type.make.in">
-  & { readonly Encoded: Encoded; readonly "~type.make.in": MakeIn }
-
 type OpaqueFacadeConstructorArgs<MakeIn> = {} extends MakeIn ? [props?: MakeIn, options?: S.MakeOptions]
   : [props: MakeIn, options?: S.MakeOptions]
 
@@ -376,7 +380,9 @@ type OpaqueClassFacadeInput<DecodingServices, EncodingServices> =
 
 type PrototypeFunction = Function & { prototype: object }
 
-const ClassAnnotationId = "~effect/Schema/Class"
+// Class schemas expose a constructor descriptor under this key (was previously
+// identified via a `~effect/Schema/Class` annotation id).
+const ConstructorAnnotationKey = "~constructor"
 
 const getOwnOrInheritedPropertyDescriptor = (value: object, property: PropertyKey): PropertyDescriptor | undefined => {
   let current: object | null = value
@@ -389,13 +395,19 @@ const getOwnOrInheritedPropertyDescriptor = (value: object, property: PropertyKe
 
 const isClassSchemaConstructor = (value: unknown): value is PrototypeFunction => {
   if (typeof value !== "function") return false
+  // Transformed schemas (e.g. `Class.pipe(S.encodeKeys(...))`) are also functions with a
+  // Declaration AST that still carries `~constructor`, but they are not constructable classes.
+  // Real Schema.Class constructors expose a static `identifier`.
+  if (typeof (value as { readonly identifier?: unknown }).identifier !== "string") return false
   const ast = (value as { readonly ast?: unknown }).ast
-  return SchemaAST.isAST(ast) && SchemaAST.isDeclaration(ast) && ast.annotations?.[ClassAnnotationId] !== undefined
+  return SchemaAST.isAST(ast)
+    && SchemaAST.isDeclaration(ast)
+    && ast.annotations?.[ConstructorAnnotationKey] !== undefined
 }
 
 const getFacadeClassSchema = (schema: OpaqueFacadeInput<any, any>): PrototypeFunction | undefined => {
   if (isClassSchemaConstructor(schema)) return schema
-  const target = "to" in schema ? schema.to : undefined
+  const target = "to" in schema ? (schema as { readonly to?: unknown }).to : undefined
   return isClassSchemaConstructor(target) ? target : undefined
 }
 
@@ -451,8 +463,10 @@ type OpaqueFacadeStatics<SchemaS extends S.Top> = Omit<SchemaS, Exclude<keyof S.
  * {@link OpaqueType}.
  */
 export interface OpaqueShape<Self, Encoded, MakeIn, SchemaS extends S.Top, Brand>
-  extends S.Opaque<Self, ExtendedShape<SchemaS, Encoded, MakeIn>, Brand>
+  extends S.Opaque<Self, SchemaS, Brand>
 {
+  readonly "Encoded": Encoded
+  readonly "~type.make.in": MakeIn
   new(_: never): Self
 }
 
@@ -625,7 +639,7 @@ export function OpaqueErrorFacadeClass<
       & OpaqueErrorFacadeClass<Self, Encoded, MakeIn, DecodingServices, EncodingServices, Brand>
       & OpaqueFacadeStatics<SchemaS>
 
-    if (typeof schema === "function") {
+    if (isClassSchemaConstructor(schema)) {
       return schema as SchemaS & FacadeSchema
     }
 

package/src/Schema/SpecialJsonSchema.ts

@@ -3,8 +3,7 @@
  * post-processes the output (e.g. flattens simple allOf).
  */
 import type * as JsonSchema from "effect/JsonSchema"
-import type * as Schema from "effect/Schema"
-import * as SchemaRepresentation from "effect/SchemaRepresentation"
+import * as Schema from "effect/Schema"
 
 /**
  * Converts a schema to a JSON Schema Document (draft-2020-12), with
@@ -14,8 +13,7 @@ export function specialJsonSchemaDocument(
   schema: Schema.Top,
   options?: Schema.ToJsonSchemaOptions
 ): JsonSchema.Document<"draft-2020-12"> {
-  const doc = SchemaRepresentation.fromAST(schema.ast)
-  const jd = SchemaRepresentation.toJsonSchemaDocument(doc, options)
+  const jd = Schema.toJsonSchemaDocument(schema, options)
   const processedDefs: JsonSchema.Definitions = {}
   for (const [key, def] of Object.entries(jd.definitions)) {
     processedDefs[key] = postProcessJsonSchema(def)

package/src/Schema/ext.ts

@@ -36,7 +36,6 @@ import { pipe } from "effect/Function"
 import * as Function from "effect/Function"
 import * as Option from "effect/Option"
 import * as S from "effect/Schema"
-import { isDateValid } from "effect/Schema"
 import * as SchemaIssue from "effect/SchemaIssue"
 import * as SchemaTransformation from "effect/SchemaTransformation"
 import * as Struct from "effect/Struct"
@@ -136,13 +135,13 @@ const DateValidString = S.String.annotate({
   format: "date-time"
 })
 
+// Schema.Date rejects invalid Dates since beta.91+; no separate isDateValid check needed.
 const DateValidFromString = DateValidString
   .pipe(
     S.decodeTo(S.Date, SchemaTransformation.dateFromString)
   )
-  .check(isDateValid())
 
-/** Like the default Schema `DateValid` but from String, with default helpers. */
+/** Like the default Schema `Date` (valid only) but from String, with default helpers. */
 export const DateValid = extendM(DateValidFromString, (s) => ({
   /**
    * Construction-only default `new Date()`. Applied only when the field is
@@ -504,9 +503,9 @@ export type WithDefaults<Self extends S.Top> = (
 // export type UnionToIntersection3<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I
 //   : never
 
-/** Union of `DateValid` and `Date`, with default helpers. */
+/** Union of core `Schema.Date` (Date objects) and string-encoded `Date`, with default helpers. */
 export const inputDate = extendM(
-  S.Union([S.DateValid, Date]),
+  S.Union([S.Date, Date]),
   (s) => ({
     /**
      * Construction-only default `new Date()`. Applied only when the field is
@@ -597,7 +596,7 @@ export interface DropConstructorDefaultLambda extends Struct.Lambda {
 export const dropConstructorDefault: DropConstructorDefaultLambda = Struct.lambda<DropConstructorDefaultLambda>(
   (schema) => {
     const context = schema.ast.context
-    if (!context?.defaultValue) return schema
+    if (!context?.constructorDefault) return schema
     return schema.rebuild(
       SchemaASTInternal.replaceContext(
         schema.ast,
@@ -636,8 +635,8 @@ export const transformTo = <To extends S.Top, From extends S.Top>(
         encode: (i: any) =>
           Effect.fail(
             new SchemaIssue.Forbidden(
-              Option.some(i),
-              { message: "One way schema transformation, encoding is not allowed" }
+              { message: "One way schema transformation, encoding is not allowed" },
+              i
             )
           )
       })
@@ -661,8 +660,8 @@ export const transformToOrFail = <To extends S.Top, From extends S.Top, RD>(
         encode: (i: any) =>
           Effect.fail(
             new SchemaIssue.Forbidden(
-              Option.some(i),
-              { message: "One way schema transformation, encoding is not allowed" }
+              { message: "One way schema transformation, encoding is not allowed" },
+              i
             )
           )
       })

package/src/Schema/moreStrings.ts

@@ -177,7 +177,7 @@ const StringIdSchemaBase = pipe(
 )
 const makeStringId = (s?: string): StringId =>
   s !== undefined ? S.decodeSync(StringIdSchemaBase)(s) : nanoid() as unknown as StringId
-const StringIdArb = (): S.LazyArbitrary<StringId> => (fc) =>
+const StringIdArb = (): S.Arbitrary<StringId> => (fc) =>
   fc
     .uint8Array({ minLength: length, maxLength: length })
     .map((_) => customRandom(urlAlphabet, size, (size) => _.subarray(0, size))() as StringId)
@@ -226,7 +226,7 @@ export function prefixedStringId<Type extends StringId>() {
   ) => {
     type FullPrefix = `${Prefix}${Separator}`
     const pref = `${prefix}${separator ?? "-"}` as FullPrefix
-    const arb = (): S.LazyArbitrary<Type> => (fc) =>
+    const arb = (): S.Arbitrary<Type> => (fc) =>
       StringIdArb()(fc).map(
         (x) => (pref + x.substring(0, 50 - pref.length)) as Type
       )

package/test/dist/rpc.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rpc.test.d.ts","sourceRoot":"","sources":["../rpc.test.ts"],"names":[],"mappings":"AAGA,OAAO,EAAiB,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AACrF,OAAO,EAAE,CAAC,EAAE,MAAM,iBAAiB,CAAA;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;;;;;;;;;;;;;;;;;;;;;;;;AAE7C,qBAAa,iBAAkB,SAAQ,sBAIrC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAI0B,KAAK;;;;AAKpC,qBAAa,KAAM,SAAQ,UAQzB;CAAG"}
+{"version":3,"file":"rpc.test.d.ts","sourceRoot":"","sources":["../rpc.test.ts"],"names":[],"mappings":"AAGA,OAAO,EAAiB,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AACrF,OAAO,EAAE,CAAC,EAAE,MAAM,iBAAiB,CAAA;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;;;;;;;;;;;;;;;;;;;;;;;;AAE7C,qBAAa,iBAAkB,SAAQ,sBAIrC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAI0B,KAAK;;;;AAKpC,qBAAa,KAAM,SAAQ,UAQzB;CAAG"}

package/test/moreStrings.test.ts

@@ -9,7 +9,7 @@ const isNanoId = (value: string) => value.length === 21 && Array.from(value).eve
 
 test("StringId arbitrary generates nanoid-shaped values", () => {
   fc.assert(
-    fc.property(S.toArbitrary(S.StringId), (value) => {
+    fc.property(S.toArbitrary(S.StringId)(fc), (value) => {
       expect(isNanoId(value)).toBe(true)
       expect(S.is(S.StringId)(value)).toBe(true)
     })

package/test/rpc.test.ts

@@ -58,5 +58,5 @@ test("Void decodes and encodes as void", () => {
   expectTypeOf<typeof _statsRequestType>().toEqualTypeOf<"query">()
   expectTypeOf(statsFromMake).toEqualTypeOf<Stats>()
   expectTypeOf(statsFromMakeOption).toEqualTypeOf<Option.Option<Stats>>()
-  expectTypeOf(statsFromMakeEffect).toEqualTypeOf<Effect.Effect<Stats, S.SchemaError>>()
+  expectTypeOf(statsFromMakeEffect).toEqualTypeOf<Effect.Effect<Stats, S.SchemaIssue.Issue>>()
 })

package/test/special.test.ts

@@ -7,7 +7,6 @@ import { deduplicateOpenApiSchemas } from "effect-app/Schema/SpecialOpenApi"
 import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
 import * as Predicate from "effect/Predicate"
-import * as Schema from "effect/Schema"
 import * as S from "effect/Schema"
 import * as SchemaGetter from "effect/SchemaGetter"
 import { describe, expect, it } from "vitest"
@@ -492,8 +491,8 @@ describe("OpaqueFacade", () => {
         never,
         never
       >()(
-        // @ts-expect-error OpaqueErrorFacadeClass requires a class schema.
-        AppSchema.Struct({ value: S.String })
+        // Runtime guard: only class schemas are accepted (struct schemas throw).
+        AppSchema.Struct({ value: S.String }) as never
       )
 
     expect(makeStructErrorFacade).toThrow("OpaqueErrorFacadeClass requires a class schema")
@@ -642,36 +641,36 @@ describe("TaggedError", () => {
 
 describe("SpecialJsonSchema", () => {
   it("nullable to optional — from NullOr", () => {
-    const nullableDecodedUndefinedEncoded = (schema: Schema.Top) => {
+    const nullableDecodedUndefinedEncoded = (schema: S.Top) => {
       const isNullableSchema = "members" in schema
         && globalThis.Array.isArray((schema as any).members)
         && (schema as any).members.length === 2
         && (schema as any).members.some((member: any) => member.ast._tag === "Null")
 
-      const nullableMembers = isNullableSchema ? (schema as any).members as ReadonlyArray<Schema.Top> : undefined
+      const nullableMembers = isNullableSchema ? (schema as any).members as ReadonlyArray<S.Top> : undefined
       const innerSchema = nullableMembers
         ? nullableMembers.find((member: any) => member.ast._tag !== "Null")!
         : schema
 
-      const nullableSchema = isNullableSchema ? schema : Schema.NullOr(schema)
+      const nullableSchema = isNullableSchema ? schema : S.NullOr(schema)
 
       return nullableSchema.pipe(
-        Schema.encodeTo(Schema.optionalKey(innerSchema), {
+        S.encodeTo(S.optionalKey(innerSchema), {
           decode: SchemaGetter.transformOptional(Option.orElseSome(() => null)),
           encode: SchemaGetter.transformOptional(Option.filter(Predicate.isNotNull))
         })
       )
     }
 
-    const fromNullOr = nullableDecodedUndefinedEncoded(Schema.NullOr(Schema.String))
-    const structFromNullOr = Schema.Struct({ status: fromNullOr })
+    const fromNullOr = nullableDecodedUndefinedEncoded(S.NullOr(S.String))
+    const structFromNullOr = S.Struct({ status: fromNullOr })
 
-    const encode = Schema.encodeUnknownSync(structFromNullOr as any)
+    const encode = S.encodeUnknownSync(structFromNullOr as any)
     const encodedNull = encode({ status: null })
     expect("status" in encodedNull).toBe(false)
     expect(encode({ status: "test" })).toStrictEqual({ status: "test" })
 
-    const decode = Schema.decodeUnknownSync(structFromNullOr as any)
+    const decode = S.decodeUnknownSync(structFromNullOr as any)
     expect(decode({})).toStrictEqual({ status: null })
     expect(decode({ status: "test" })).toStrictEqual({ status: "test" })
 
@@ -689,24 +688,24 @@ describe("SpecialJsonSchema", () => {
   })
 
   it("identifies X universally — deduplicates same-fingerprint references", () => {
-    const X = Schema.String.annotate({ title: "X", identifier: "X" })
+    const X = S.String.annotate({ title: "X", identifier: "X" })
 
-    const s = Schema.Struct({
-      a: Schema.NullOr(X).pipe(
-        Schema.encodeTo(Schema.optionalKey(X), {
+    const s = S.Struct({
+      a: S.NullOr(X).pipe(
+        S.encodeTo(S.optionalKey(X), {
           decode: SchemaGetter.transformOptional(Option.orElseSome(() => null)),
           encode: SchemaGetter.transformOptional(Option.filter(Predicate.isNotNull))
         })
       ),
-      b: Schema.NullOr(X).pipe(
-        Schema.encodeTo(Schema.optionalKey(X), {
+      b: S.NullOr(X).pipe(
+        S.encodeTo(S.optionalKey(X), {
           decode: SchemaGetter.transformOptional(Option.orElseSome(() => null)),
           encode: SchemaGetter.transformOptional(Option.filter(Predicate.isNotNull))
         })
       ),
-      c: Schema.NullOr(X),
+      c: S.NullOr(X),
       d: X,
-      e: X.pipe(Schema.optionalKey)
+      e: X.pipe(S.optionalKey)
     })
 
     const doc = specialJsonSchemaDocument(s)
@@ -738,16 +737,16 @@ describe("SpecialJsonSchema", () => {
   })
 
   it("shared annotated schema via helper — deduplicates", () => {
-    const X = Schema.String.annotate({ title: "X", identifier: "X" })
+    const X = S.String.annotate({ title: "X", identifier: "X" })
 
     const cache = new WeakMap()
-    const nullableDecodedUndefinedEncoded = (schema: Schema.Top) => {
+    const nullableDecodedUndefinedEncoded = (schema: S.Top) => {
       const isNullableSchema = "members" in schema
         && globalThis.Array.isArray((schema as any).members)
         && (schema as any).members.length === 2
         && (schema as any).members.some((member: any) => member.ast._tag === "Null")
 
-      const nullableMembers = isNullableSchema ? (schema as any).members as ReadonlyArray<Schema.Top> : undefined
+      const nullableMembers = isNullableSchema ? (schema as any).members as ReadonlyArray<S.Top> : undefined
       const innerSchema = nullableMembers
         ? nullableMembers.find((member: any) => member.ast._tag !== "Null")!
         : schema
@@ -755,9 +754,9 @@ describe("SpecialJsonSchema", () => {
       const cached = cache.get(innerSchema.ast)
       if (cached !== undefined) return cached
 
-      const nullableSchema = isNullableSchema ? schema : Schema.NullOr(schema)
+      const nullableSchema = isNullableSchema ? schema : S.NullOr(schema)
       const out = nullableSchema.pipe(
-        Schema.encodeTo(Schema.optionalKey(innerSchema), {
+        S.encodeTo(S.optionalKey(innerSchema), {
           decode: SchemaGetter.transformOptional(Option.orElseSome(() => null)),
           encode: SchemaGetter.transformOptional(Option.filter(Predicate.isNotNull))
         })
@@ -767,12 +766,12 @@ describe("SpecialJsonSchema", () => {
       return out
     }
 
-    const structWithShared = Schema.Struct({
+    const structWithShared = S.Struct({
       a: nullableDecodedUndefinedEncoded(X),
-      b: nullableDecodedUndefinedEncoded(Schema.NullOr(X)),
-      c: Schema.NullOr(X),
+      b: nullableDecodedUndefinedEncoded(S.NullOr(X)),
+      c: S.NullOr(X),
       d: X,
-      e: X.pipe(Schema.optionalKey)
+      e: X.pipe(S.optionalKey)
     })
 
     const doc = specialJsonSchemaDocument(structWithShared)