effect 4.0.0-rc.112 → 4.0.0-rc.113

package/src/internal/schema/standardSchema.ts

@@ -0,0 +1,125 @@
+import * as Cause from "../../Cause.ts"
+import * as Effect from "../../Effect.ts"
+import * as Exit from "../../Exit.ts"
+import * as JsonSchema from "../../JsonSchema.ts"
+import * as Scheduler from "../../Scheduler.ts"
+import type * as Schema from "../../Schema.ts"
+import * as SchemaAST from "../../SchemaAST.ts"
+import * as SchemaIssue from "../../SchemaIssue.ts"
+import * as SchemaParser from "../../SchemaParser.ts"
+import type { StandardJSONSchemaV1, StandardSchemaV1 } from "../../StandardSchema.ts"
+import * as InternalToCodec from "./toCodec.ts"
+import * as InternalToJsonSchemaDocument from "./toJsonSchemaDocument.ts"
+import * as InternalToRepresentation from "./toRepresentation.ts"
+
+function makeStandardResult<A>(exit: Exit.Exit<StandardSchemaV1.Result<A>>): StandardSchemaV1.Result<A> {
+  return Exit.isSuccess(exit) ? exit.value : {
+    issues: [{ message: Cause.pretty(exit.cause) }]
+  }
+}
+
+/** @internal */
+export function toStandardSchemaV1<S extends Schema.ConstraintDecoder<unknown>>(
+  self: S,
+  options?: {
+    readonly leafHook?: SchemaIssue.LeafHook | undefined
+    readonly checkHook?: SchemaIssue.CheckHook | undefined
+    readonly parseOptions?: SchemaAST.ParseOptions | undefined
+  }
+): StandardSchemaV1<S["Encoded"], S["Type"]> & S {
+  const decodeUnknownEffect = SchemaParser.decodeUnknownEffect(self) as (
+    input: unknown,
+    options?: SchemaAST.ParseOptions
+  ) => Effect.Effect<S["Type"], SchemaIssue.Issue>
+  const parseOptions: SchemaAST.ParseOptions = { errors: "all", ...options?.parseOptions }
+  const formatter = SchemaIssue.makeFormatterStandardSchemaV1(options)
+  const validate: StandardSchemaV1<S["Encoded"], S["Type"]>["~standard"]["validate"] = (value: unknown) => {
+    const scheduler = new Scheduler.MixedScheduler("sync")
+    const fiber = Effect.runFork(
+      Effect.match(decodeUnknownEffect(value, parseOptions), {
+        onFailure: formatter,
+        onSuccess: (value): StandardSchemaV1.Result<S["Type"]> => ({ value })
+      }),
+      { scheduler }
+    )
+    fiber.currentDispatcher?.flush()
+    const exit = fiber.pollUnsafe()
+    if (exit) {
+      return makeStandardResult(exit)
+    }
+    return new Promise((resolve) => {
+      fiber.addObserver((exit) => {
+        resolve(makeStandardResult(exit))
+      })
+    })
+  }
+  if ("~standard" in self) {
+    const out = self as any
+    if ("validate" in out["~standard"]) return out
+    Object.assign(out["~standard"], { validate })
+    return out
+  }
+  return Object.assign(self, {
+    "~standard": {
+      version: 1,
+      vendor: "effect",
+      validate
+    } as const
+  })
+}
+
+function toJsonSchemaDocument(ast: SchemaAST.AST): JsonSchema.Document<"draft-2020-12"> {
+  const document = InternalToRepresentation.toRepresentation(
+    InternalToCodec.toCodecJsonAST(ast)
+  )
+  return InternalToJsonSchemaDocument.toJsonSchemaDocument(document)
+}
+
+function toBaseStandardJSONSchemaV1(
+  ast: SchemaAST.AST,
+  target: StandardJSONSchemaV1.Target
+): JsonSchema.JsonSchema {
+  const doc2020_12 = toJsonSchemaDocument(ast)
+  if (target === "draft-2020-12") {
+    const schema = doc2020_12.schema
+    if (Object.keys(doc2020_12.definitions).length > 0) {
+      schema.$defs = doc2020_12.definitions
+    }
+    return schema
+  } else if (target === "draft-07") {
+    const doc07 = JsonSchema.toDocumentDraft07(doc2020_12)
+    const schema = doc07.schema
+    if (Object.keys(doc07.definitions).length > 0) {
+      schema.definitions = doc07.definitions
+    }
+    return schema
+  }
+  throw new globalThis.Error(`Unsupported target: ${target}`)
+}
+
+/** @internal */
+export function toStandardJSONSchemaV1<S extends Schema.Constraint>(
+  self: S
+): StandardJSONSchemaV1<S["Encoded"], S["Type"]> & S {
+  const jsonSchema: StandardJSONSchemaV1.Props<S["Encoded"], S["Type"]>["jsonSchema"] = {
+    input(options) {
+      return toBaseStandardJSONSchemaV1(self.ast, options.target)
+    },
+    output(options) {
+      return toBaseStandardJSONSchemaV1(SchemaAST.toType(self.ast), options.target)
+    }
+  }
+  if ("~standard" in self) {
+    const out = self as any
+    if ("jsonSchema" in out["~standard"]) return out
+    Object.assign(out["~standard"], { jsonSchema })
+    return out
+  }
+  return Object.assign(self, {
+    "~standard": {
+      version: 1,
+      vendor: "effect",
+      jsonSchema
+    } as const
+  })
+}

package/src/internal/schema/toCodeDocument.ts

@@ -45,7 +45,7 @@ function renderEmittableAnnotation(input: unknown): string | undefined {
     if (rendered === undefined) return undefined
     entries.push(`${formatPropertyKey(key)}: ${rendered}`)
   }
-  return `{ ${entries.join(", ")} }`
+  return entries.length === 0 ? "{}" : `{ ${entries.join(", ")} }`
 }
 
 function renderAnnotations(
@@ -330,6 +330,11 @@ export function toCodeDocument(
     return rendered === undefined ? "" : `.${method}(${rendered})`
   }
 
+  function unionOptionsRuntime(options: NonNullable<SchemaRepresentation.Union["options"]>): string {
+    if (!Object.hasOwn(options, "mode")) return "{}"
+    return `{ mode: ${options.mode === undefined ? "undefined" : format(options.mode)} }`
+  }
+
   function compileCheck(
     check: SchemaRepresentation.Check,
     path: Path
@@ -483,25 +488,29 @@ export function toCodeDocument(
           )
         })
         const rest = representation.rest.map((item, index) => recur(item, [...path, "rest", index]))
+        let code: SchemaRepresentation.Code
         if (Arr.isArrayNonEmpty(rest)) {
           const item = rest[0]
           if (elements.length === 0 && rest.length === 1) {
-            return makeCode(`Schema.Array(${item.runtime})`, `ReadonlyArray<${item.Type}>`)
+            code = makeCode(`Schema.Array(${item.runtime})`, `ReadonlyArray<${item.Type}>`)
+          } else {
+            const post = rest.slice(1)
+            code = makeCode(
+              `Schema.TupleWithRest(Schema.Tuple([${elements.map((element) => element.runtime).join(", ")}]), [${
+                rest.map((item) => item.runtime).join(", ")
+              }])`,
+              `readonly [${elements.map((element) => element.Type).join(", ")}, ...Array<${item.Type}>${
+                post.length > 0 ? `, ${post.map((item) => item.Type).join(", ")}` : ""
+              }]`
+            )
           }
-          const post = rest.slice(1)
-          return makeCode(
-            `Schema.TupleWithRest(Schema.Tuple([${elements.map((element) => element.runtime).join(", ")}]), [${
-              rest.map((item) => item.runtime).join(", ")
-            }])`,
-            `readonly [${elements.map((element) => element.Type).join(", ")}, ...Array<${item.Type}>${
-              post.length > 0 ? `, ${post.map((item) => item.Type).join(", ")}` : ""
-            }]`
+        } else {
+          code = makeCode(
+            `Schema.Tuple([${elements.map((element) => element.runtime).join(", ")}])`,
+            `readonly [${elements.map((element) => element.Type).join(", ")}]`
           )
         }
-        return makeCode(
-          `Schema.Tuple([${elements.map((element) => element.runtime).join(", ")}])`,
-          `readonly [${elements.map((element) => element.Type).join(", ")}]`
-        )
+        return code
       }
       case "Objects": {
         const properties = representation.propertySignatures.map((property, index) => {
@@ -513,52 +522,55 @@ export function toCodeDocument(
           let runtime = type.runtime
           if (property.isMutable) runtime = `Schema.mutableKey(${runtime})`
           if (property.isOptional) runtime = `Schema.optionalKey(${runtime})`
+          runtime += runtimeAnnotate(property.annotations, "annotateKey")
           const runtimeName = isSymbol ? `[${name}]` : name
           const typeName = `${property.isMutable ? "" : "readonly "}${runtimeName}${property.isOptional ? "?" : ""}`
-          return makeCode(
-            `${runtimeName}: ${runtime}${runtimeAnnotate(property.annotations, "annotateKey")}`,
-            `${typeName}: ${type.Type}`
-          )
+          return {
+            code: makeCode(`${runtimeName}: ${runtime}`, `${typeName}: ${type.Type}`)
+          }
         })
         const indexSignatures = representation.indexSignatures.map((signature, index) => ({
           parameter: recur(signature.parameter, [...path, "indexSignatures", index, "parameter"]),
           type: recur(signature.type, [...path, "indexSignatures", index, "type"])
         }))
-        const propertyRuntimes = properties.map((property) => property.runtime).join(", ")
-        const propertyTypes = properties.map((property) => property.Type).join(", ")
+        const propertyRuntimes = properties.map((property) => property.code.runtime).join(", ")
+        const propertyTypes = properties.map((property) => property.code.Type).join(", ")
+        let code: SchemaRepresentation.Code
         if (indexSignatures.length === 0) {
-          return makeCode(
+          code = makeCode(
             `Schema.Struct({ ${propertyRuntimes} })`,
             `{ ${propertyTypes} }`
           )
-        }
-        if (properties.length === 0 && indexSignatures.length === 1) {
+        } else if (properties.length === 0 && indexSignatures.length === 1) {
           const signature = indexSignatures[0]
-          return makeCode(
+          code = makeCode(
             `Schema.Record(${signature.parameter.runtime}, ${signature.type.runtime})`,
             `{ readonly [x: ${signature.parameter.Type}]: ${signature.type.Type} }`
           )
-        }
-        const indexRuntimes = indexSignatures.map((signature) =>
-          `Schema.Record(${signature.parameter.runtime}, ${signature.type.runtime})`
-        ).join(", ")
-        const indexTypes = indexSignatures.map((signature) =>
-          `readonly [x: ${signature.parameter.Type}]: ${signature.type.Type}`
-        )
-        if (properties.length === 0) {
-          return makeCode(
-            `Schema.StructWithRest(Schema.Struct({ ${propertyRuntimes} }), [${indexRuntimes}])`,
-            `{ ${indexTypes.join(", ")} }`
+        } else {
+          const indexRuntimes = indexSignatures.map((signature) =>
+            `Schema.Record(${signature.parameter.runtime}, ${signature.type.runtime})`
+          ).join(", ")
+          const indexTypes = indexSignatures.map((signature) =>
+            `readonly [x: ${signature.parameter.Type}]: ${signature.type.Type}`
           )
+          code = properties.length === 0
+            ? makeCode(
+              `Schema.StructWithRest(Schema.Struct({ ${propertyRuntimes} }), [${indexRuntimes}])`,
+              `{ ${indexTypes.join(", ")} }`
+            )
+            : makeCode(
+              `Schema.StructWithRest(Schema.Struct({ ${propertyRuntimes} }), [${indexRuntimes}])`,
+              [`{ ${propertyTypes} }`, ...indexTypes.map((indexType) => `{ ${indexType} }`)].join(" & ")
+            )
         }
-        return makeCode(
-          `Schema.StructWithRest(Schema.Struct({ ${propertyRuntimes} }), [${indexRuntimes}])`,
-          [`{ ${propertyTypes} }`, ...indexTypes.map((indexType) => `{ ${indexType} }`)].join(" & ")
-        )
+        return code
       }
       case "Union": {
-        if (representation.types.length === 0) return makeCode("Schema.Never", "never")
-        if (representation.types.every(isSimpleLiveLiteral)) {
+        if (representation.options === undefined && representation.types.length === 0) {
+          return makeCode("Schema.Never", "never")
+        }
+        if (representation.options === undefined && representation.types.every(isSimpleLiveLiteral)) {
           const literals = representation.types.map((literal) => format(literal.literal))
           return literals.length === 1
             ? makeCode(`Schema.Literal(${literals[0]})`, literals[0])
@@ -567,10 +579,12 @@ export function toCodeDocument(
         const types = representation.types.map((type, index) =>
           recur(type, [...path, "types", index], includeTypeBrands)
         )
-        const mode = representation.mode === "anyOf" ? "" : `, { mode: "oneOf" }`
+        const options = representation.options === undefined
+          ? ""
+          : `, ${unionOptionsRuntime(representation.options)}`
         return makeCode(
-          `Schema.Union([${types.map((type) => type.runtime).join(", ")}]${mode})`,
-          types.map((type) => type.Type).join(" | ")
+          `Schema.Union([${types.map((type) => type.runtime).join(", ")}]${options})`,
+          types.length === 0 ? "never" : types.map((type) => type.Type).join(" | ")
         )
       }
     }

package/src/internal/schema/toCodec.ts

@@ -0,0 +1,312 @@
+import { memoize } from "../../Function.ts"
+import * as Predicate from "../../Predicate.ts"
+import type * as PublicSchema from "../../Schema.ts"
+import * as SchemaAST from "../../SchemaAST.ts"
+import * as SchemaGetter from "../../SchemaGetter.ts"
+import * as InternalTransformation from "../../SchemaTransformation.ts"
+import * as InternalMake from "./make.ts"
+
+/** @internal */
+export function toCodecJson<S extends PublicSchema.Constraint>(schema: S): PublicSchema.toCodecJson<S> {
+  return InternalMake.make(toCodecJsonAST(schema.ast), { schema })
+}
+
+/** @internal */
+export const toCodecJsonAST = SchemaAST.applyToSelfOrLastLinkEncodingIdempotent((ast) => {
+  const out = toCodecJsonASTStep(ast, toCodecJsonAST)
+  const context = ast.context
+  if (out === ast || context === undefined) return out
+  return SchemaAST.replaceContextLastLink(out, withoutConstructorDefault(context))
+})
+
+function withoutConstructorDefault(context: SchemaAST.Context): SchemaAST.Context {
+  return context.constructorDefault === undefined ?
+    context :
+    new SchemaAST.Context(context.isOptional, context.isMutable, undefined, context.annotations)
+}
+
+function validateCanonicalObjectPropertyNames(ast: SchemaAST.Objects): void {
+  if (ast.propertySignatures.some((ps) => typeof ps.name !== "string")) {
+    throw new globalThis.Error("Objects property names must be strings", { cause: ast })
+  }
+}
+
+function makeReorder(getPriority: (ast: SchemaAST.AST) => number) {
+  return (types: ReadonlyArray<SchemaAST.AST>): ReadonlyArray<SchemaAST.AST> => {
+    // Create a map of original indices for O(1) lookup
+    const indexMap = new Map<SchemaAST.AST, number>()
+    for (let i = 0; i < types.length; i++) {
+      indexMap.set(SchemaAST.toEncoded(types[i]), i)
+    }
+
+    // Create a sorted copy of the types array
+    const sortedTypes = [...types].sort((a, b) => {
+      a = SchemaAST.toEncoded(a)
+      b = SchemaAST.toEncoded(b)
+      const pa = getPriority(a)
+      const pb = getPriority(b)
+      if (pa !== pb) return pa - pb
+      // If priorities are equal, maintain original order (stable sort)
+      return indexMap.get(a)! - indexMap.get(b)!
+    })
+
+    // Check if order changed by comparing arrays
+    const orderChanged = sortedTypes.some((ast, index) => ast !== types[index])
+
+    if (!orderChanged) return types
+    return sortedTypes
+  }
+}
+
+const toCodecJsonReorder = makeReorder((ast: SchemaAST.AST) => {
+  switch (ast._tag) {
+    case "BigInt":
+    case "Symbol":
+    case "UniqueSymbol":
+      return 0
+    default:
+      return 1
+  }
+})
+
+function toCodecJsonASTStep(ast: SchemaAST.AST, recur: (ast: SchemaAST.AST) => SchemaAST.AST): SchemaAST.AST {
+  switch (ast._tag) {
+    case "Declaration": {
+      const getLink = ast.annotations?.toCodecJson ?? ast.annotations?.toCodec
+      if (!Predicate.isFunction(getLink)) {
+        return SchemaAST.replaceEncoding(ast, [SchemaAST.unknownToJson])
+      }
+      const typeParameters = ast.typeParameters.map((tp) => InternalMake.make(SchemaAST.toEncoded(tp)))
+      const link = getLink(typeParameters)
+      return link === undefined ? ast : SchemaAST.replaceEncoding(ast, [SchemaAST.mapLink(link, recur)])
+    }
+    case "Unknown":
+      return SchemaAST.replaceEncoding(ast, [SchemaAST.unknownToJson])
+    case "ObjectKeyword":
+      return SchemaAST.replaceEncoding(ast, [SchemaAST.objectKeywordToJson])
+    case "Undefined":
+    case "Void":
+    case "Literal":
+    case "Number":
+      return ast.toCodecJson()
+    case "UniqueSymbol":
+    case "Symbol":
+    case "BigInt":
+      return ast.toCodecStringTree()
+    case "Objects": {
+      validateCanonicalObjectPropertyNames(ast)
+      return ast.recur(recur, SchemaAST.parameterFromString)
+    }
+    case "Union": {
+      const sortedTypes = toCodecJsonReorder(ast.types)
+      if (sortedTypes !== ast.types) {
+        return new SchemaAST.Union(
+          sortedTypes,
+          ast.options,
+          ast.annotations,
+          ast.checks,
+          ast.encoding,
+          ast.context,
+          ast.encodingChecks
+        ).recur(recur)
+      }
+      return ast.recur(recur)
+    }
+    case "Arrays":
+    case "Suspend":
+      return ast.recur(recur)
+  }
+  // `Schema.Any` is used as an escape hatch
+  return ast
+}
+
+/** @internal */
+export function toCodecIso<S extends PublicSchema.Constraint>(
+  schema: S
+): PublicSchema.Codec<S["Type"], S["Iso"]> {
+  return InternalMake.make(toCodecIsoAST(SchemaAST.toType(schema.ast)))
+}
+
+const toCodecIsoAST = memoize((ast: SchemaAST.AST): SchemaAST.AST => {
+  const out = toCodecIsoASTStep(ast, toCodecIsoAST)
+  return out !== ast && ast.context !== undefined ?
+    SchemaAST.replaceContextLastLink(out, withoutConstructorDefault(ast.context)) :
+    out
+})
+
+function toCodecIsoASTStep(ast: SchemaAST.AST, recur: (ast: SchemaAST.AST) => SchemaAST.AST): SchemaAST.AST {
+  switch (ast._tag) {
+    case "Declaration": {
+      const getLink = ast.annotations?.toCodecIso ?? ast.annotations?.toCodec
+      if (Predicate.isFunction(getLink)) {
+        const link = getLink(ast.typeParameters.map((tp) => InternalMake.make(tp)))
+        return SchemaAST.replaceEncoding(ast, [SchemaAST.mapLink(link, recur)])
+      }
+      return ast
+    }
+    case "Arrays":
+    case "Objects":
+    case "Union":
+    case "Suspend":
+      return ast.recur(recur)
+  }
+  return ast
+}
+
+/** @internal */
+export function toCodecStringTree<S extends PublicSchema.Constraint>(
+  schema: S
+): PublicSchema.toCodecStringTree<S> {
+  return InternalMake.make(toCodecStringTreeAST(schema.ast), { schema })
+}
+
+/** @internal */
+export function toCodecArrayFromSingle<S extends PublicSchema.Constraint>(
+  schema: S
+): PublicSchema.toCodecArrayFromSingle<S> {
+  return InternalMake.make(toCodecArrayFromSingleAST(schema.ast))
+}
+
+const toStringTreeReorder = makeReorder((ast: SchemaAST.AST) => {
+  switch (ast._tag) {
+    case "Null":
+    case "Boolean":
+    case "Number":
+    case "BigInt":
+    case "Symbol":
+    case "UniqueSymbol":
+      return 0
+    default:
+      return 1
+  }
+})
+
+function toCodecStringTreeASTStep(
+  ast: SchemaAST.AST,
+  recur: (ast: SchemaAST.AST) => SchemaAST.AST,
+  onMissingAnnotation: (ast: SchemaAST.AST) => SchemaAST.AST
+): SchemaAST.AST {
+  switch (ast._tag) {
+    case "Declaration": {
+      const typeParameters = ast.typeParameters.map((tp) => InternalMake.make(recur(SchemaAST.toEncoded(tp))))
+      const getStringTreeLink = ast.annotations?.toCodecStringTree
+      if (Predicate.isFunction(getStringTreeLink)) {
+        const link = getStringTreeLink(typeParameters)
+        if (link === undefined) return ast
+        return SchemaAST.replaceEncoding(ast, [SchemaAST.mapLink(link, recur)])
+      }
+      const getJsonLink = ast.annotations?.toCodecJson
+      const jsonLink = Predicate.isFunction(getJsonLink) ? getJsonLink(typeParameters) : undefined
+      const getLink = jsonLink === undefined ? ast.annotations?.toCodec : undefined
+      const link = jsonLink ?? (Predicate.isFunction(getLink) ? getLink(typeParameters) : undefined)
+      return link === undefined
+        ? onMissingAnnotation(ast)
+        : SchemaAST.replaceEncoding(ast, [SchemaAST.mapLink(link, recur)])
+    }
+    case "Null":
+      return SchemaAST.replaceEncoding(ast, [nullToString])
+    case "Boolean":
+      return SchemaAST.replaceEncoding(ast, [booleanToString])
+    case "Unknown":
+    case "ObjectKeyword":
+      return SchemaAST.replaceEncoding(ast, [SchemaAST.unknownToStringTree])
+    case "Enum":
+    case "Number":
+    case "Literal":
+    case "UniqueSymbol":
+    case "Symbol":
+    case "BigInt":
+      return ast.toCodecStringTree()
+    case "Objects": {
+      validateCanonicalObjectPropertyNames(ast)
+      return ast.recur(recur, SchemaAST.parameterFromString)
+    }
+    case "Union": {
+      const sortedTypes = toStringTreeReorder(ast.types)
+      if (sortedTypes !== ast.types) {
+        return new SchemaAST.Union(
+          sortedTypes,
+          ast.options,
+          ast.annotations,
+          ast.checks,
+          ast.encoding,
+          ast.context,
+          ast.encodingChecks
+        ).recur(recur)
+      }
+      return ast.recur(recur)
+    }
+    case "Arrays":
+    case "Suspend":
+      return ast.recur(recur)
+  }
+  // `Schema.Any` is used as an escape hatch
+  return ast
+}
+
+const nullToString = new SchemaAST.Link(
+  new SchemaAST.Literal("null"),
+  new InternalTransformation.Transformation(
+    SchemaGetter.transform(() => null),
+    SchemaGetter.transform(() => "null")
+  )
+)
+
+const booleanToString = new SchemaAST.Link(
+  new SchemaAST.Union([new SchemaAST.Literal("true"), new SchemaAST.Literal("false")]),
+  new InternalTransformation.Transformation(
+    SchemaGetter.transform((s) => s === "true"),
+    SchemaGetter.String()
+  )
+)
+
+const arrayFromSingleTransformation = new InternalTransformation.Transformation(
+  SchemaGetter.transform((input: ReadonlyArray<unknown> | string) => typeof input === "string" ? [input] : input),
+  SchemaGetter.passthrough()
+)
+
+const isCodecArrayFromSingleLink = (link: SchemaAST.Link): boolean =>
+  link.transformation === arrayFromSingleTransformation
+
+const toCodecStringTreeAST = SchemaAST.applyToSelfOrLastLinkEncodingIdempotent((ast) => {
+  const out = toCodecStringTreeASTStep(ast, toCodecStringTreeAST, (ast) => {
+    throw new globalThis.Error("Missing structural codec for StringTree", { cause: ast })
+  })
+  if (out !== ast && ast.context !== undefined) {
+    return SchemaAST.replaceContextLastLink(out, withoutConstructorDefault(ast.context))
+  }
+  return out
+}, { stopAt: isCodecArrayFromSingleLink })
+
+const toArrayFromSingleInputElement = (ast: SchemaAST.AST): SchemaAST.AST =>
+  SchemaAST.isOptional(ast) ? SchemaAST.optionalKey(SchemaAST.unknown) : SchemaAST.unknown
+
+const toCodecArrayFromSingleAST = SchemaAST.applyToSelfOrLastLinkEncodingIdempotent((ast) => {
+  const out = toCodecArrayFromSingleASTStep(ast)
+  if (SchemaAST.isArrays(out)) {
+    const ensure = SchemaAST.decodeTo(
+      new SchemaAST.Union(
+        [
+          new SchemaAST.Arrays(
+            out.isMutable,
+            out.elements.map(toArrayFromSingleInputElement),
+            out.rest.map(toArrayFromSingleInputElement)
+          ),
+          SchemaAST.string
+        ],
+        { mode: "anyOf" }
+      ),
+      out,
+      arrayFromSingleTransformation
+    )
+    return SchemaAST.isOptional(ast) ? SchemaAST.optionalKey(ensure) : ensure
+  }
+  return out
+}, { stopAt: isCodecArrayFromSingleLink })
+
+function toCodecArrayFromSingleASTStep(ast: SchemaAST.AST): SchemaAST.AST {
+  return ast._tag === "Declaration" || ast._tag === "Arrays" || ast._tag === "Objects" || ast._tag === "Union" ||
+      ast._tag === "Suspend"
+    ? ast.recur(toCodecArrayFromSingleAST)
+    : ast
+}

package/src/internal/schema/toDifferJsonPatch.ts

@@ -0,0 +1,24 @@
+import type { Differ } from "../../Differ.ts"
+import * as JsonPatch from "../../JsonPatch.ts"
+import type * as Schema from "../../Schema.ts"
+import * as SchemaParser from "../../SchemaParser.ts"
+import * as InternalToCodec from "./toCodec.ts"
+
+/** @internal */
+export function toDifferJsonPatch<T>(
+  schema: Schema.ConstraintCodec<T, unknown>
+): Differ<T, JsonPatch.JsonPatch> {
+  const serializer = InternalToCodec.toCodecJson(schema)
+  const get = SchemaParser.encodeSync(serializer)
+  const set = SchemaParser.decodeSync(serializer)
+  return {
+    empty: [],
+    diff: (oldValue, newValue) => JsonPatch.get(get(oldValue), get(newValue)),
+    combine: (first, second) => [...first, ...second],
+    patch: (oldValue, patch) => {
+      const value = get(oldValue)
+      const patched = JsonPatch.apply(patch, value)
+      return Object.is(patched, value) ? oldValue : set(patched)
+    }
+  }
+}