effect-app 4.0.0-beta.30 → 4.0.0-beta.300

package/test/special.test.ts

@@ -0,0 +1,1258 @@
+import { InvalidStateError, LoginError, NotFoundError, NotLoggedInError, OptimisticConcurrencyException, ServiceUnavailableError, UnauthorizedError, ValidationError } from "effect-app/client/errors"
+import { RequestContext } from "effect-app/RequestContext"
+import * as AppSchema from "effect-app/Schema"
+import { Class } from "effect-app/Schema/Class"
+import { flattenNestedAnyOf, flattenSimpleAllOf, specialJsonSchemaDocument } from "effect-app/Schema/SpecialJsonSchema"
+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"
+
+class _FacadeModel extends AppSchema.Class<_FacadeModel>("FacadeModel")({ value: S.String }) {
+  get upperValue() {
+    return this.value.toUpperCase()
+  }
+
+  static describe(self: { readonly value: string }) {
+    return `value:${self.value}`
+  }
+}
+
+interface FacadeModelEncoded {
+  readonly value: string
+}
+
+interface FacadeModelMake {
+  readonly value: string
+}
+
+class FacadeModel extends AppSchema.OpaqueFacade<
+  FacadeModel,
+  FacadeModelEncoded,
+  FacadeModelMake,
+  never,
+  never
+>()(_FacadeModel) {
+  declare readonly value: string
+  declare readonly upperValue: string
+
+  get decoratedValue() {
+    return `facade:${this.value}`
+  }
+
+  label() {
+    return this.decoratedValue
+  }
+}
+
+class _RenamedFacadeModel extends AppSchema.Class<_RenamedFacadeModel>("RenamedFacadeModel")({
+  internalName: S.String
+}) {
+  get upperName() {
+    return this.internalName.toUpperCase()
+  }
+}
+
+interface RenamedFacadeModelEncoded {
+  readonly external_name: string
+}
+
+interface RenamedFacadeModelMake {
+  readonly internalName: string
+}
+
+class RenamedFacadeModel extends AppSchema.OpaqueFacade<
+  RenamedFacadeModel,
+  RenamedFacadeModelEncoded,
+  RenamedFacadeModelMake,
+  never,
+  never
+>()(_RenamedFacadeModel.pipe(S.encodeKeys({ internalName: "external_name" }))) {
+  declare readonly internalName: string
+  declare readonly upperName: string
+
+  get decoratedName() {
+    return `facade:${this.internalName}`
+  }
+}
+
+const _StructFacadeModel = AppSchema.Struct({ value: S.String })
+
+interface StructFacadeModelEncoded {
+  readonly value: string
+}
+
+interface StructFacadeModelMake {
+  readonly value: string
+}
+
+class StructFacadeModel extends AppSchema.OpaqueFacade<
+  StructFacadeModel,
+  StructFacadeModelEncoded,
+  StructFacadeModelMake,
+  never,
+  never
+>()(_StructFacadeModel) {
+  declare readonly value: string
+}
+
+const _RenamedStructFacadeModel = AppSchema.Struct({ internalName: S.String }).pipe(
+  S.encodeKeys({ internalName: "external_name" })
+)
+
+interface RenamedStructFacadeModelEncoded {
+  readonly external_name: string
+}
+
+interface RenamedStructFacadeModelMake {
+  readonly internalName: string
+}
+
+class RenamedStructFacadeModel extends AppSchema.OpaqueFacade<
+  RenamedStructFacadeModel,
+  RenamedStructFacadeModelEncoded,
+  RenamedStructFacadeModelMake,
+  never,
+  never
+>()(_RenamedStructFacadeModel) {
+  declare readonly internalName: string
+}
+
+const _RenamedOpaqueStructFacadeModel = AppSchema
+  .Opaque<
+    { readonly internalName: string },
+    RenamedStructFacadeModelEncoded
+  >()(AppSchema.Struct({ internalName: S.String }))
+  .pipe(S.encodeKeys({ internalName: "external_name" }))
+
+class RenamedOpaqueStructFacadeModel extends AppSchema.OpaqueFacade<
+  RenamedOpaqueStructFacadeModel,
+  RenamedStructFacadeModelEncoded,
+  RenamedStructFacadeModelMake,
+  never,
+  never
+>()(_RenamedOpaqueStructFacadeModel) {
+  declare readonly internalName: string
+}
+
+describe("Class", () => {
+  describe("strict", () => {
+    it("encoding doesnt accepts plain objects matching the struct (Fields argument)", () => {
+      class A extends Class<A>("A")({ a: S.String }) {}
+
+      expect(S.encodeUnknownSync(A)(new A({ a: "hello" }))).toStrictEqual({ a: "hello" })
+      expect(() => S.encodeUnknownSync(A)({ a: "world" })).toThrow()
+      expect(() => S.encodeUnknownSync(A)(null)).toThrow()
+    })
+
+    it("encoding rejects plain objects matching the struct (Struct argument)", () => {
+      class A extends Class<A>("A")(S.Struct({ a: S.String })) {}
+
+      expect(S.encodeUnknownSync(A)(new A({ a: "hello" }))).toStrictEqual({ a: "hello" })
+      expect(() => S.encodeUnknownSync(A)({ a: "world" })).toThrow()
+      expect(() => S.encodeUnknownSync(A)(null)).toThrow()
+    })
+
+    it("decoding still works normally", () => {
+      class A extends Class<A>("A")({ a: S.String }) {}
+
+      const decoded = S.decodeUnknownSync(A)({ a: "hello" })
+      expect(decoded).toBeInstanceOf(A)
+      expect(decoded.a).toBe("hello")
+
+      expect(() => S.decodeUnknownSync(A)(null)).toThrow()
+      expect(() => S.decodeUnknownSync(A)({ a: 1 })).toThrow()
+    })
+
+    it("S.is accepts class instances and not matching plain objects", () => {
+      class A extends Class<A>("A")({ a: S.String }) {}
+
+      expect(S.is(A)(new A({ a: "hello" }))).toBe(true)
+      expect(S.is(A)({ a: "world" })).toBe(false)
+      expect(S.is(A)({ a: 1 })).toBe(false)
+      expect(S.is(A)(null)).toBe(false)
+    })
+
+    it("rejects values that don't match the struct", () => {
+      class A extends Class<A>("A")({ a: S.String }) {}
+
+      expect(() => S.encodeUnknownSync(A)({ a: 123 })).toThrow()
+      expect(() => S.encodeUnknownSync(A)("not an object")).toThrow()
+    })
+
+    it("returns a class constructor — new and instanceof work", () => {
+      class A extends Class<A>("A")({ a: S.String }) {}
+
+      const instance = new A({ a: "hello" })
+      expect(instance).toBeInstanceOf(A)
+      expect(instance.a).toBe("hello")
+    })
+
+    it("preserves fields and identifier", () => {
+      class A extends Class<A>("A")({ a: S.String, b: S.Number }) {}
+
+      expect(A.identifier).toBe("A")
+      expect(Object.keys(A.fields)).toStrictEqual(["a", "b"])
+    })
+  })
+
+  describe("non strict", () => {
+    it("encoding accepts plain objects matching the struct (Fields argument)", () => {
+      class A extends Class<A>("A")({ a: S.String }, undefined, { strict: false }) {}
+
+      expect(S.encodeUnknownSync(A)(new A({ a: "hello" }))).toStrictEqual({ a: "hello" })
+      expect(S.encodeUnknownSync(A)({ a: "world" })).toStrictEqual({ a: "world" })
+      expect(() => S.encodeUnknownSync(A)(null)).toThrow()
+    })
+
+    it("encoding accepts plain objects matching the struct (Struct argument)", () => {
+      class A extends Class<A>("A")(S.Struct({ a: S.String }), undefined, { strict: false }) {}
+
+      expect(S.encodeUnknownSync(A)(new A({ a: "hello" }))).toStrictEqual({ a: "hello" })
+      expect(S.encodeUnknownSync(A)({ a: "world" })).toStrictEqual({ a: "world" })
+      expect(() => S.encodeUnknownSync(A)(null)).toThrow()
+    })
+
+    it("S.is accepts class instances and matching plain objects", () => {
+      class A extends Class<A>("A")({ a: S.String }, undefined, { strict: false }) {}
+
+      expect(S.is(A)(new A({ a: "hello" }))).toBe(true)
+      expect(S.is(A)({ a: "world" })).toBe(true)
+      expect(S.is(A)({ a: 1 })).toBe(false)
+      expect(S.is(A)(null)).toBe(false)
+    })
+  })
+})
+
+describe("Class constructor", () => {
+  describe("strict", () => {
+    it("works as a base class — new, instanceof, encoding plain objects", () => {
+      class A extends Class<A>("A")({ a: S.String }) {}
+
+      const instance = new A({ a: "hello" })
+      expect(instance).toBeInstanceOf(A)
+      expect(instance.a).toBe("hello")
+
+      expect(S.encodeUnknownSync(A)(instance)).toStrictEqual({ a: "hello" })
+      expect(() => S.encodeUnknownSync(A)({ a: "world" })).toThrow()
+      expect(() => S.encodeUnknownSync(A)(null)).toThrow()
+      expect(() => S.encodeUnknownSync(A)({ a: 123 })).toThrow()
+    })
+
+    it("decoding works normally", () => {
+      class A extends Class<A>("A")({ a: S.String }) {}
+
+      const decoded = S.decodeUnknownSync(A)({ a: "hello" })
+      expect(decoded).toBeInstanceOf(A)
+      expect(decoded.a).toBe("hello")
+
+      expect(() => S.decodeUnknownSync(A)({ a: 1 })).toThrow()
+    })
+
+    it("exposes fields, identifier", () => {
+      class A extends Class<A>("A")({ a: S.String, b: S.Number }) {}
+
+      expect(A.identifier).toBe("A")
+      expect(Object.keys(A.fields)).toStrictEqual(["a", "b"])
+    })
+  })
+
+  describe("non strict", () => {
+    it("works as a base class — new, instanceof, encoding plain objects", () => {
+      class A extends Class<A>("A")({ a: S.String }, undefined, { strict: false }) {}
+
+      const instance = new A({ a: "hello" })
+      expect(instance).toBeInstanceOf(A)
+      expect(instance.a).toBe("hello")
+
+      expect(S.encodeUnknownSync(A)(instance)).toStrictEqual({ a: "hello" })
+      expect(S.encodeUnknownSync(A)({ a: "world" })).toStrictEqual({ a: "world" })
+      expect(() => S.encodeUnknownSync(A)(null)).toThrow()
+      expect(() => S.encodeUnknownSync(A)({ a: 123 })).toThrow()
+    })
+  })
+})
+
+describe("TaggedStruct constructor", () => {
+  it("works with _tag, make, and encoding plain objects", () => {
+    const Circle = AppSchema.TaggedStruct("Circle", { radius: S.Number })
+
+    const instance = Circle.make({ radius: 5 })
+    expect(instance).toEqual({ _tag: "Circle", radius: 5 })
+
+    expect(S.encodeUnknownSync(Circle)(instance)).toStrictEqual({ _tag: "Circle", radius: 5 })
+    expect(S.encodeUnknownSync(Circle)({ _tag: "Circle", radius: 10 })).toStrictEqual({ _tag: "Circle", radius: 10 })
+
+    expect(() => S.encodeUnknownSync(Circle)(null)).toThrow()
+    expect(() => S.encodeUnknownSync(Circle)({ _tag: "Circle", radius: "nope" })).toThrow()
+  })
+
+  it("decoding works normally", () => {
+    const Circle = AppSchema.TaggedStruct("Circle", { radius: S.Number })
+
+    const decoded = S.decodeUnknownSync(Circle)({ _tag: "Circle", radius: 5 })
+    expect(decoded).toEqual({ _tag: "Circle", radius: 5 })
+  })
+
+  it("S.decodeSync(S.toType(X)) should report n length schema error", () => {
+    class X extends S.Opaque<X>()(S.TaggedStruct("X", { n: S.String.pipe(S.check(S.isMinLength(3))) })) {}
+
+    try {
+      S.decodeSync(S.toType(X))({ _tag: "X", n: "a" /* not length 3 */ })
+      expect.fail("expected decode to fail with a SchemaError")
+    } catch (error) {
+      expect(S.isSchemaError(error)).toBe(true)
+      if (S.isSchemaError(error)) {
+        expect(error.message).toContain("n")
+        expect(error.message.toLowerCase()).toContain("length")
+      }
+    }
+  })
+
+  it("exposes fields", () => {
+    const Circle = AppSchema.TaggedStruct("Circle", { radius: S.Number })
+
+    expect(Object.keys(Circle.fields)).toContain("_tag")
+    expect(Object.keys(Circle.fields)).toContain("radius")
+  })
+})
+
+describe("strict declaration option", () => {
+  it("Class strict: true keeps class-level expected errors", () => {
+    class X extends Class<X>("X")({ n: S.String.pipe(S.check(S.isMinLength(3))) }, undefined, { strict: true }) {}
+
+    expect(() => S.decodeSync(S.toType(X))({ n: "a" })).toThrow("Expected X")
+  })
+
+  it("TaggedStruct preserves field-level expected errors", () => {
+    class X extends S.Opaque<X>()(AppSchema.TaggedStruct("X", { n: S.String.pipe(S.check(S.isMinLength(3))) })) {}
+
+    expect(() => S.decodeSync(S.toType(X))({ _tag: "X", n: "a" })).toThrow()
+  })
+
+  it("Class with encoded override strict: true keeps class-level expected errors", () => {
+    class X extends Class<X, never>("X")({ n: S.String.pipe(S.check(S.isMinLength(3))) }, undefined, {
+      strict: true
+    }) {}
+
+    expect(() => S.decodeSync(S.toType(X))({ n: "a" })).toThrow("Expected X")
+  })
+
+  it("TaggedStruct with opaque wrapper decodes tagged input", () => {
+    class X extends S.Opaque<X>()(AppSchema.TaggedStruct("X", { n: S.String.pipe(S.check(S.isMinLength(3))) })) {}
+
+    expect(() => S.decodeSync(S.toType(X))({ _tag: "X", n: "a" })).toThrow()
+  })
+})
+
+describe("Class.copy", () => {
+  it("creates a new instance with updated fields", () => {
+    class A extends Class<A>("A")({ a: S.String, b: S.Number }) {}
+
+    const instance = new A({ a: "hello", b: 1 })
+    const copied: A = A.copy(instance, { b: 2 })
+    expect(copied).toBeInstanceOf(A)
+    expect(copied.a).toBe("hello")
+    expect(copied.b).toBe(2)
+  })
+
+  it("accepts a function for updates", () => {
+    class A extends Class<A>("A")({ a: S.String, b: S.Number }) {}
+
+    const instance = new A({ a: "hello", b: 1 })
+    const copied: A = A.copy(instance, (a) => ({ b: a.b + 1 }))
+    expect(copied).toBeInstanceOf(A)
+    expect(copied.b).toBe(2)
+  })
+
+  it("is pipeable", () => {
+    class A extends Class<A>("A")({ a: S.String, b: S.Number }) {}
+
+    const instance = new A({ a: "hello", b: 1 })
+    const copied: A = A.copy({ b: 2 })(instance)
+    expect(copied).toBeInstanceOf(A)
+    expect(copied.b).toBe(2)
+  })
+})
+
+describe("TaggedStruct (opaque).copy", () => {
+  it("creates a new instance with updated fields", () => {
+    const Circle = AppSchema.TaggedStruct("Circle", { radius: S.Number })
+
+    const instance = Circle.make({ radius: 5 })
+    const copied = Circle.copy(instance, { radius: 10 })
+    expect(copied).toEqual({ _tag: "Circle", radius: 10 })
+  })
+
+  it("accepts a function for updates", () => {
+    const Circle = AppSchema.TaggedStruct("Circle", { radius: S.Number })
+
+    const instance = Circle.make({ radius: 5 })
+    const copied = Circle.copy(instance, (c) => ({ radius: c.radius * 2 }))
+    expect(copied).toEqual({ _tag: "Circle", radius: 10 })
+  })
+})
+
+describe("OpaqueFacade", () => {
+  it("keeps OpaqueFacade usable with struct schemas", () => {
+    const decoded = S.decodeSync(StructFacadeModel)({ value: "hello" })
+
+    expect(decoded).toStrictEqual({ value: "hello" })
+    expect(S.encodeSync(StructFacadeModel)(decoded)).toStrictEqual({ value: "hello" })
+    expect(S.is(StructFacadeModel)(decoded)).toBe(true)
+    expect(S.is(StructFacadeModel)({ value: 1 })).toBe(false)
+  })
+
+  it("keeps encoded-key struct facades on the struct path", () => {
+    const decoded = S.decodeSync(RenamedStructFacadeModel)({ external_name: "fran" })
+
+    expect(decoded).toStrictEqual({ internalName: "fran" })
+    expect(decoded).not.toBeInstanceOf(RenamedStructFacadeModel)
+    expect(S.encodeSync(RenamedStructFacadeModel)(decoded)).toStrictEqual({ external_name: "fran" })
+    expect(S.is(RenamedStructFacadeModel)(decoded)).toBe(true)
+    expect(S.is(RenamedStructFacadeModel)({ external_name: "fran" })).toBe(false)
+  })
+
+  it("keeps encoded-key opaque struct facades on the struct path", () => {
+    const decoded = S.decodeSync(RenamedOpaqueStructFacadeModel)({ external_name: "fran" })
+
+    expect(decoded).toStrictEqual({ internalName: "fran" })
+    expect(decoded).not.toBeInstanceOf(RenamedOpaqueStructFacadeModel)
+    expect(S.encodeSync(RenamedOpaqueStructFacadeModel)(decoded)).toStrictEqual({ external_name: "fran" })
+    expect(S.is(RenamedOpaqueStructFacadeModel)(decoded)).toBe(true)
+    expect(S.is(RenamedOpaqueStructFacadeModel)({ external_name: "fran" })).toBe(false)
+  })
+
+  it("decodes through the public facade class", () => {
+    const decoded = S.decodeSync(FacadeModel)({ value: "hello" })
+    const decodedEffect = Effect.runSync(S.decodeUnknownEffect(FacadeModel)({ value: "effect" }))
+
+    expect(decoded).toBeInstanceOf(FacadeModel)
+    expect(decodedEffect).toBeInstanceOf(FacadeModel)
+    expect(decoded).toBeInstanceOf(_FacadeModel)
+    expect(decoded.value).toBe("hello")
+    expect(decoded.upperValue).toBe("HELLO")
+    expect(decoded.decoratedValue).toBe("facade:hello")
+    expect(decoded.label()).toBe("facade:hello")
+    expect(FacadeModel.describe(decoded)).toBe("value:hello")
+  })
+
+  it("validates facade instances with S.is", () => {
+    const instance = new FacadeModel({ value: "hello" })
+
+    expect(instance).toBeInstanceOf(FacadeModel)
+    expect(instance.upperValue).toBe("HELLO")
+    expect(instance.label()).toBe("facade:hello")
+    expect(S.is(FacadeModel)(instance)).toBe(true)
+    expect(S.is(FacadeModel)(S.decodeSync(FacadeModel)({ value: "world" }))).toBe(true)
+    expect(S.is(FacadeModel)({ value: "plain" })).toBe(false)
+    expect(S.is(FacadeModel)({ value: 1 })).toBe(false)
+  })
+
+  it("decodes renamed keys through the public facade class", () => {
+    const decoded = S.decodeSync(RenamedFacadeModel)({ external_name: "fran" })
+
+    expect(decoded).toBeInstanceOf(RenamedFacadeModel)
+    expect(decoded).toBeInstanceOf(_RenamedFacadeModel)
+    expect(Object.getPrototypeOf(decoded)).toBe(RenamedFacadeModel.prototype)
+    expect(decoded.internalName).toBe("fran")
+    expect(decoded.upperName).toBe("FRAN")
+    expect(decoded.decoratedName).toBe("facade:fran")
+    expect(S.encodeSync(RenamedFacadeModel)(decoded)).toStrictEqual({ external_name: "fran" })
+    expect(S.is(RenamedFacadeModel)(decoded)).toBe(true)
+    expect(S.is(RenamedFacadeModel)({ internalName: "plain" })).toBe(false)
+    expect(S.is(RenamedFacadeModel)({ external_name: "plain" })).toBe(false)
+  })
+
+  it("keeps generated struct facades decodable with public statics", () => {
+    const input: typeof RequestContext.Encoded = {
+      span: { traceId: "trace", spanId: "span", sampled: true },
+      name: "operation",
+      locale: "en",
+      namespace: "tenant"
+    }
+
+    const decoded = S.decodeSync(RequestContext)(input)
+
+    expect(decoded).not.toBeInstanceOf(RequestContext)
+    expect(S.is(RequestContext)(decoded)).toBe(true)
+    expect(RequestContext.toMonitoring(decoded)).toStrictEqual({ operationName: "operation", locale: "en" })
+  })
+
+  it("keeps error facades class-only", () => {
+    const makeStructErrorFacade = () =>
+      AppSchema.OpaqueErrorFacadeClass<
+        { readonly value: string },
+        { readonly value: string },
+        { readonly value: string },
+        never,
+        never
+      >()(
+        // @ts-expect-error OpaqueErrorFacadeClass requires a class schema.
+        AppSchema.Struct({ value: S.String })
+      )
+
+    expect(makeStructErrorFacade).toThrow("OpaqueErrorFacadeClass requires a class schema")
+  })
+})
+
+describe("Struct.copy", () => {
+  it("creates a new value with updated fields", () => {
+    const A = AppSchema.Struct({ a: S.String, b: S.Number })
+
+    const instance = A.make({ a: "hello", b: 1 })
+    const copied = A.copy(instance, { b: 2 })
+
+    expect(copied).toEqual({ a: "hello", b: 2 })
+    expect(copied).not.toBe(instance)
+  })
+
+  it("accepts a function for updates", () => {
+    const A = AppSchema.Struct({ a: S.String, b: S.Number })
+
+    const instance = A.make({ a: "hello", b: 1 })
+    const copied = A.copy(instance, (a) => ({ b: a.b + 1 }))
+
+    expect(copied).toEqual({ a: "hello", b: 2 })
+  })
+
+  it("allows widening updates against the full struct type", () => {
+    const A = AppSchema.Struct({
+      name: S.String,
+      state: S.Union([
+        S.Struct({ _tag: S.tag("a"), a: S.String }),
+        S.Struct({ _tag: S.tag("b"), b: S.Number })
+      ])
+    })
+
+    const instance = A.make({ name: "x", state: { _tag: "a", a: "a" } })
+    const copied = A.copy(instance, { state: { _tag: "b", b: 1 } })
+
+    expect(copied).toEqual({ name: "x", state: { _tag: "b", b: 1 } })
+  })
+
+  it("copy function is preserved when using .annotate()", () => {
+    const A = AppSchema.Struct({ a: S.String, b: S.Number }).annotate({ title: "A" })
+
+    const instance = A.make({ a: "hello", b: 1 })
+    const copied = A.copy(instance, { b: 2 })
+
+    expect(copied).toEqual({ a: "hello", b: 2 })
+    expect(copied).not.toBe(instance)
+  })
+
+  it("copy function is preserved when using .annotateKey()", () => {
+    const A = AppSchema.Struct({ a: S.String, b: S.Number }).annotateKey({ title: "A" })
+
+    const instance = A.make({ a: "hello", b: 1 })
+    const copied = A.copy(instance, { b: 2 })
+
+    expect(copied).toEqual({ a: "hello", b: 2 })
+    expect(copied).not.toBe(instance)
+  })
+
+  it("copy function is preserved when using .mapFields()", () => {
+    const A = AppSchema.Struct({ a: S.String, b: S.Number }).mapFields((f) => ({ ...f }))
+
+    const instance = A.make({ a: "hello", b: 1 })
+    const copied = A.copy(instance, { b: 2 })
+
+    expect(copied).toEqual({ a: "hello", b: 2 })
+    expect(copied).not.toBe(instance)
+  })
+
+  it("copy function is preserved through chained calls", () => {
+    const A = AppSchema
+      .Struct({ a: S.String, b: S.Number })
+      .annotate({ title: "A" })
+      .annotateKey({ description: "test" })
+
+    const instance = A.make({ a: "hello", b: 1 })
+    const copied = A.copy(instance, { b: 2 })
+
+    expect(copied).toEqual({ a: "hello", b: 2 })
+    expect(copied).not.toBe(instance)
+  })
+})
+
+describe("TaggedStruct.copy", () => {
+  it("creates a new tagged value with updated fields", () => {
+    const Circle = AppSchema.TaggedStruct("Circle", { radius: S.Number })
+
+    const instance = Circle.make({ radius: 5 })
+    const copied = Circle.copy(instance, { radius: 10 })
+
+    expect(copied).toEqual({ _tag: "Circle", radius: 10 })
+    expect(copied).not.toBe(instance)
+  })
+})
+
+describe("TaggedError", () => {
+  it("InvalidStateError toString includes the message", () => {
+    const error = new InvalidStateError("something went wrong")
+    expect(error.toString()).toContain("something went wrong")
+  })
+
+  it("NotFoundError toString includes the message", () => {
+    const error = new NotFoundError({ type: "User", id: "123" })
+    expect(error.toString()).toContain("Didn't find User")
+    expect(error.toString()).toContain("123")
+  })
+
+  it("ServiceUnavailableError toString includes the message", () => {
+    const error = new ServiceUnavailableError("service down")
+    expect(error.toString()).toContain("service down")
+  })
+
+  it("ValidationError toString includes the message", () => {
+    const error = new ValidationError({ errors: ["field required"] })
+    expect(error.toString()).toContain("Validation failed")
+    expect(error.toString()).toContain("field required")
+  })
+
+  it("NotLoggedInError toString includes the message", () => {
+    const error = new NotLoggedInError("not logged in")
+    expect(error.toString()).toContain("not logged in")
+  })
+
+  it("LoginError toString includes the message", () => {
+    const error = new LoginError("login failed")
+    expect(error.toString()).toContain("login failed")
+  })
+
+  it("UnauthorizedError toString includes the message", () => {
+    const error = new UnauthorizedError("forbidden")
+    expect(error.toString()).toContain("forbidden")
+  })
+
+  it("OptimisticConcurrencyException toString includes the message", () => {
+    const error = new OptimisticConcurrencyException({ message: "conflict" })
+    expect(error.toString()).toContain("conflict")
+  })
+
+  it("OptimisticConcurrencyException from details toString includes the message", () => {
+    const error = new OptimisticConcurrencyException({ type: "User", id: "123", code: 409 })
+    expect(error.toString()).toContain("Existing User 123 record changed")
+  })
+})
+
+describe("SpecialJsonSchema", () => {
+  it("nullable to optional — from NullOr", () => {
+    const nullableDecodedUndefinedEncoded = (schema: Schema.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 innerSchema = nullableMembers
+        ? nullableMembers.find((member: any) => member.ast._tag !== "Null")!
+        : schema
+
+      const nullableSchema = isNullableSchema ? schema : Schema.NullOr(schema)
+
+      return nullableSchema.pipe(
+        Schema.encodeTo(Schema.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 encode = Schema.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)
+    expect(decode({})).toStrictEqual({ status: null })
+    expect(decode({ status: "test" })).toStrictEqual({ status: "test" })
+
+    const doc = specialJsonSchemaDocument(structFromNullOr)
+    expect(doc).toStrictEqual({
+      dialect: "draft-2020-12",
+      schema: {
+        "type": "object",
+        "properties": {
+          "status": { "type": "string" }
+        }
+      },
+      definitions: {}
+    })
+  })
+
+  it("identifies X universally — deduplicates same-fingerprint references", () => {
+    const X = Schema.String.annotate({ title: "X", identifier: "X" })
+
+    const s = Schema.Struct({
+      a: Schema.NullOr(X).pipe(
+        Schema.encodeTo(Schema.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), {
+          decode: SchemaGetter.transformOptional(Option.orElseSome(() => null)),
+          encode: SchemaGetter.transformOptional(Option.filter(Predicate.isNotNull))
+        })
+      ),
+      c: Schema.NullOr(X),
+      d: X,
+      e: X.pipe(Schema.optionalKey)
+    })
+
+    const doc = specialJsonSchemaDocument(s)
+    expect(doc).toStrictEqual({
+      dialect: "draft-2020-12",
+      schema: {
+        "type": "object",
+        "properties": {
+          "a": { "$ref": "#/$defs/X" },
+          "b": { "$ref": "#/$defs/X" },
+          "c": {
+            "anyOf": [
+              { "$ref": "#/$defs/X" },
+              { "type": "null" }
+            ]
+          },
+          "d": { "$ref": "#/$defs/X" },
+          "e": { "$ref": "#/$defs/X" }
+        },
+        "required": ["c", "d"]
+      },
+      definitions: {
+        X: {
+          "type": "string",
+          "title": "X"
+        }
+      }
+    })
+  })
+
+  it("shared annotated schema via helper — deduplicates", () => {
+    const X = Schema.String.annotate({ title: "X", identifier: "X" })
+
+    const cache = new WeakMap()
+    const nullableDecodedUndefinedEncoded = (schema: Schema.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 innerSchema = nullableMembers
+        ? nullableMembers.find((member: any) => member.ast._tag !== "Null")!
+        : schema
+
+      const cached = cache.get(innerSchema.ast)
+      if (cached !== undefined) return cached
+
+      const nullableSchema = isNullableSchema ? schema : Schema.NullOr(schema)
+      const out = nullableSchema.pipe(
+        Schema.encodeTo(Schema.optionalKey(innerSchema), {
+          decode: SchemaGetter.transformOptional(Option.orElseSome(() => null)),
+          encode: SchemaGetter.transformOptional(Option.filter(Predicate.isNotNull))
+        })
+      )
+
+      cache.set(innerSchema.ast, out)
+      return out
+    }
+
+    const structWithShared = Schema.Struct({
+      a: nullableDecodedUndefinedEncoded(X),
+      b: nullableDecodedUndefinedEncoded(Schema.NullOr(X)),
+      c: Schema.NullOr(X),
+      d: X,
+      e: X.pipe(Schema.optionalKey)
+    })
+
+    const doc = specialJsonSchemaDocument(structWithShared)
+    expect(doc).toStrictEqual({
+      dialect: "draft-2020-12",
+      schema: {
+        "type": "object",
+        "properties": {
+          "a": { "$ref": "#/$defs/X" },
+          "b": { "$ref": "#/$defs/X" },
+          "c": {
+            "anyOf": [
+              { "$ref": "#/$defs/X" },
+              { "type": "null" }
+            ]
+          },
+          "d": { "$ref": "#/$defs/X" },
+          "e": { "$ref": "#/$defs/X" }
+        },
+        "required": ["c", "d"]
+      },
+      definitions: {
+        X: {
+          "type": "string",
+          "title": "X"
+        }
+      }
+    })
+  })
+})
+
+describe("SpecialOpenApi", () => {
+  it("deduplicates identical components.schemas entries with same base identifier", () => {
+    const spec = {
+      openapi: "3.1.0",
+      info: { title: "Test", version: "1.0" },
+      paths: {
+        "/foo": {
+          get: {
+            responses: {
+              200: {
+                content: {
+                  "application/json": {
+                    schema: { $ref: "#/components/schemas/X" }
+                  }
+                }
+              }
+            }
+          }
+        },
+        "/bar": {
+          get: {
+            responses: {
+              200: {
+                content: {
+                  "application/json": {
+                    schema: { $ref: "#/components/schemas/X1" }
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      components: {
+        schemas: {
+          X: { type: "string", title: "X" },
+          X1: { type: "string", title: "X" }
+        }
+      }
+    }
+
+    const result = deduplicateOpenApiSchemas(spec) as any
+
+    // X1 should be removed, and $ref to X1 rewritten to X
+    expect(result.components.schemas).toStrictEqual({
+      X: { type: "string", title: "X" }
+    })
+    expect(
+      result.paths["/bar"].get.responses[200].content["application/json"].schema
+    )
+      .toStrictEqual({ $ref: "#/components/schemas/X" })
+  })
+
+  it("does not deduplicate entries with different representations", () => {
+    const spec = {
+      openapi: "3.1.0",
+      info: { title: "Test", version: "1.0" },
+      paths: {},
+      components: {
+        schemas: {
+          X: { type: "string", title: "X" },
+          X1: { type: "number", title: "X" }
+        }
+      }
+    }
+
+    const result = deduplicateOpenApiSchemas(spec) as any
+
+    // Both should remain since they have different representations
+    expect(result.components.schemas).toStrictEqual({
+      X: { type: "string", title: "X" },
+      X1: { type: "number", title: "X" }
+    })
+  })
+
+  it("returns spec unchanged when no duplicates exist", () => {
+    const spec = {
+      openapi: "3.1.0",
+      info: { title: "Test", version: "1.0" },
+      paths: {},
+      components: {
+        schemas: {
+          Foo: { type: "string" },
+          Bar: { type: "number" }
+        }
+      }
+    }
+
+    const result = deduplicateOpenApiSchemas(spec)
+    expect(result).toStrictEqual(spec)
+  })
+
+  it("rewrites nested $ref pointers in allOf/anyOf/oneOf", () => {
+    const spec = {
+      openapi: "3.1.0",
+      info: { title: "Test", version: "1.0" },
+      paths: {
+        "/baz": {
+          post: {
+            requestBody: {
+              content: {
+                "application/json": {
+                  schema: {
+                    anyOf: [
+                      { $ref: "#/components/schemas/Y1" },
+                      { type: "null" }
+                    ]
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      components: {
+        schemas: {
+          Y: { type: "object", properties: { name: { type: "string" } } },
+          Y1: { type: "object", properties: { name: { type: "string" } } }
+        }
+      }
+    }
+
+    const result = deduplicateOpenApiSchemas(spec) as any
+
+    expect(result.components.schemas).toStrictEqual({
+      Y: { type: "object", properties: { name: { type: "string" } } }
+    })
+    expect(
+      result.paths["/baz"].post.requestBody.content["application/json"].schema.anyOf[0]
+    )
+      .toStrictEqual({ $ref: "#/components/schemas/Y" })
+  })
+
+  it("rewrites $ref pointers inside definitions themselves", () => {
+    const spec = {
+      openapi: "3.1.0",
+      info: { title: "Test", version: "1.0" },
+      paths: {},
+      components: {
+        schemas: {
+          Inner: { type: "string" },
+          Inner1: { type: "string" },
+          Outer: {
+            type: "object",
+            properties: {
+              field: { $ref: "#/components/schemas/Inner1" }
+            }
+          }
+        }
+      }
+    }
+
+    const result = deduplicateOpenApiSchemas(spec) as any
+
+    expect(Object.keys(result.components.schemas)).toStrictEqual(["Inner", "Outer"])
+    expect(result.components.schemas.Outer.properties.field).toStrictEqual({
+      $ref: "#/components/schemas/Inner"
+    })
+  })
+
+  it("handles spec without components gracefully", () => {
+    const spec = { openapi: "3.1.0", info: { title: "Test", version: "1.0" }, paths: {} }
+    const result = deduplicateOpenApiSchemas(spec)
+    expect(result).toStrictEqual(spec)
+  })
+
+  it("flattens allOf in components.schemas", () => {
+    const spec = {
+      openapi: "3.1.0",
+      info: { title: "Test", version: "1.0" },
+      paths: {},
+      components: {
+        schemas: {
+          PositiveInt: {
+            type: "integer",
+            allOf: [{ exclusiveMinimum: 0, title: "PositiveInt" }]
+          }
+        }
+      }
+    }
+
+    const result = deduplicateOpenApiSchemas(spec) as any
+
+    expect(result.components.schemas.PositiveInt).toStrictEqual({
+      type: "integer",
+      exclusiveMinimum: 0,
+      title: "PositiveInt"
+    })
+  })
+
+  it("does not flatten allOf containing $ref entries", () => {
+    const spec = {
+      openapi: "3.1.0",
+      info: { title: "Test", version: "1.0" },
+      paths: {},
+      components: {
+        schemas: {
+          Composed: {
+            type: "object",
+            allOf: [{ $ref: "#/components/schemas/Base" }]
+          },
+          Base: { type: "object", properties: { id: { type: "string" } } }
+        }
+      }
+    }
+
+    const result = deduplicateOpenApiSchemas(spec) as any
+
+    expect(result.components.schemas.Composed).toStrictEqual({
+      type: "object",
+      allOf: [{ $ref: "#/components/schemas/Base" }]
+    })
+  })
+
+  it("does not flatten allOf entries that define their own type", () => {
+    const spec = {
+      openapi: "3.1.0",
+      info: { title: "Test", version: "1.0" },
+      paths: {},
+      components: {
+        schemas: {
+          Mixed: {
+            type: "object",
+            allOf: [{ type: "string", minLength: 1 }]
+          }
+        }
+      }
+    }
+
+    const result = deduplicateOpenApiSchemas(spec) as any
+
+    expect(result.components.schemas.Mixed).toStrictEqual({
+      type: "object",
+      allOf: [{ type: "string", minLength: 1 }]
+    })
+  })
+})
+
+describe("flattenSimpleAllOf", () => {
+  it("flattens constraint-only allOf into parent with type", () => {
+    const input = {
+      type: "integer",
+      allOf: [{ exclusiveMinimum: 0, title: "PositiveInt" }]
+    }
+    expect(flattenSimpleAllOf(input)).toStrictEqual({
+      type: "integer",
+      exclusiveMinimum: 0,
+      title: "PositiveInt"
+    })
+  })
+
+  it("flattens string type with multiple constraints", () => {
+    const input = {
+      type: "string",
+      allOf: [
+        { minLength: 1, maxLength: 255 },
+        { title: "NonEmptyString255" }
+      ]
+    }
+    expect(flattenSimpleAllOf(input)).toStrictEqual({
+      type: "string",
+      minLength: 1,
+      maxLength: 255,
+      title: "NonEmptyString255"
+    })
+  })
+
+  it("does not flatten allOf with $ref", () => {
+    const input = {
+      type: "object",
+      allOf: [{ $ref: "#/components/schemas/Base" }]
+    }
+    expect(flattenSimpleAllOf(input)).toStrictEqual(input)
+  })
+
+  it("does not flatten allOf entries with their own type", () => {
+    const input = {
+      type: "object",
+      allOf: [{ type: "string", minLength: 1 }]
+    }
+    expect(flattenSimpleAllOf(input)).toStrictEqual(input)
+  })
+
+  it("allOf entry wins on property conflict", () => {
+    const input = {
+      type: "integer",
+      title: "OldTitle",
+      allOf: [{ title: "NewTitle", minimum: 0 }]
+    }
+    expect(flattenSimpleAllOf(input)).toStrictEqual({
+      type: "integer",
+      title: "NewTitle",
+      minimum: 0
+    })
+  })
+})
+
+describe("Post-processing integration — real Effect Schema types", () => {
+  it("PositiveInt — allOf flattened, no wrapping", () => {
+    const doc = specialJsonSchemaDocument(AppSchema.PositiveInt)
+    expect(doc.definitions["PositiveInt"]).toStrictEqual({
+      type: "integer",
+      exclusiveMinimum: 0
+    })
+  })
+
+  it("NonEmptyString255 — multiple allOf constraints merged", () => {
+    const doc = specialJsonSchemaDocument(AppSchema.NonEmptyString255)
+    expect(doc.definitions["NonEmptyString255"]).toStrictEqual({
+      type: "string",
+      minLength: 1,
+      maxLength: 255
+    })
+  })
+
+  it("NullOr(NonEmptyString64k) — null preserved in anyOf, allOf flattened in definition", () => {
+    const schema = S.Struct({ note: S.NullOr(AppSchema.NonEmptyString64k) })
+    const doc = specialJsonSchemaDocument(schema)
+
+    // null variant preserved (correct JSON Schema for NullOr)
+    expect(doc.schema).toStrictEqual({
+      type: "object",
+      properties: {
+        note: {
+          anyOf: [
+            { $ref: "#/$defs/NonEmptyString64k" },
+            { type: "null" }
+          ]
+        }
+      },
+      required: ["note"]
+    })
+
+    // allOf flattened in the referenced definition
+    expect(doc.definitions["NonEmptyString64k"]).toStrictEqual({
+      type: "string",
+      minLength: 1,
+      maxLength: 65536
+    })
+  })
+
+  it("NonNegativeInt — allOf flattened", () => {
+    const doc = specialJsonSchemaDocument(AppSchema.NonNegativeInt)
+    expect(doc.definitions["NonNegativeInt"]).toStrictEqual({
+      type: "integer",
+      minimum: 0
+    })
+  })
+
+  it("NullOr union flattens nested anyOf members", () => {
+    const A = S.String.annotate({ identifier: "A" })
+    const B = S.Boolean.annotate({ identifier: "B" })
+    const schema = S.Struct({
+      value: S.NullOr(S.Union([A, B]))
+    })
+    const doc = specialJsonSchemaDocument(schema)
+    const valueProp = (doc.schema as Record<string, any>)["properties"]["value"]
+
+    expect(valueProp).toStrictEqual({
+      anyOf: [
+        { $ref: "#/$defs/A" },
+        { $ref: "#/$defs/B" },
+        { type: "null" }
+      ]
+    })
+  })
+})
+
+describe("flattenNestedAnyOf", () => {
+  it("flattens nested anyOf with no sibling keys", () => {
+    const input = {
+      anyOf: [
+        { anyOf: [{ type: "string" }, { type: "number" }] },
+        { type: "null" }
+      ]
+    }
+    expect(flattenNestedAnyOf(input)).toStrictEqual({
+      anyOf: [
+        { type: "string" },
+        { type: "number" },
+        { type: "null" }
+      ]
+    })
+  })
+
+  it("does not flatten anyOf entry with sibling keys", () => {
+    const input = {
+      anyOf: [
+        { anyOf: [{ type: "string" }], title: "X" },
+        { type: "null" }
+      ]
+    }
+    // The inner anyOf is not flattened into the outer (sibling "title" prevents it),
+    // but the single-element inner anyOf is unwrapped within the entry itself
+    expect(flattenNestedAnyOf(input)).toStrictEqual({
+      anyOf: [
+        { type: "string", title: "X" },
+        { type: "null" }
+      ]
+    })
+  })
+
+  it("unwraps anyOf with single item after flattening", () => {
+    const input = {
+      anyOf: [
+        { anyOf: [{ type: "string" }] }
+      ]
+    }
+    expect(flattenNestedAnyOf(input)).toStrictEqual({ type: "string" })
+  })
+
+  it("unwraps anyOf with single item, merging sibling properties", () => {
+    const input = {
+      title: "MyField",
+      anyOf: [{ type: "string" }]
+    }
+    expect(flattenNestedAnyOf(input)).toStrictEqual({
+      title: "MyField",
+      type: "string"
+    })
+  })
+
+  it("recurses into nested objects", () => {
+    const input = {
+      properties: {
+        field: {
+          anyOf: [
+            { anyOf: [{ $ref: "#/defs/A" }, { $ref: "#/defs/B" }] },
+            { type: "null" }
+          ]
+        }
+      }
+    }
+    expect(flattenNestedAnyOf(input)).toStrictEqual({
+      properties: {
+        field: {
+          anyOf: [
+            { $ref: "#/defs/A" },
+            { $ref: "#/defs/B" },
+            { type: "null" }
+          ]
+        }
+      }
+    })
+  })
+
+  it("passes through non-objects unchanged", () => {
+    expect(flattenNestedAnyOf(null)).toBe(null)
+    expect(flattenNestedAnyOf(42)).toBe(42)
+    expect(flattenNestedAnyOf("hello")).toBe("hello")
+  })
+})