effect 4.0.0-beta.97 → 4.0.0-beta.99

package/src/SchemaRepresentation.ts

@@ -18,6 +18,7 @@ import { collectBrands } from "./internal/schema/annotations.ts"
 import * as InternalRepresentation from "./internal/schema/representation.ts"
 import { unescapeToken } from "./JsonPointer.ts"
 import type * as JsonSchema from "./JsonSchema.ts"
+import { remainder } from "./Number.ts"
 import * as Option from "./Option.ts"
 import * as Predicate from "./Predicate.ts"
 import * as Rec from "./Record.ts"
@@ -3038,63 +3039,37 @@ export function fromJsonSchemaDocument(document: JsonSchema.Document<"draft-2020
 export function fromJsonSchemaMultiDocument(document: JsonSchema.MultiDocument<"draft-2020-12">, options?: {
   readonly onEnter?: ((js: JsonSchema.JsonSchema) => JsonSchema.JsonSchema) | undefined
 }): MultiDocument {
-  let visited: Set<string>
+  let definitionIdentifier: string | undefined
   const references: Record<string, Representation> = {}
 
-  type Slot = {
-    // 0 = not started, 1 = building, 2 = done
-    state: 0 | 1 | 2
-    value: Exclude<Representation, { _tag: "Reference" }> | undefined
-  }
+  type ResolvedReference = Exclude<Representation, { _tag: "Reference" }>
+  const resolvedReferences = new Map<string, ResolvedReference | null>()
 
-  const slots = new Map<string, Slot>()
-
-  function getSlot(identifier: string): Slot {
-    const existing = slots.get(identifier)
-    if (existing) return existing
-
-    // Create the slot *before* resolving, so self-references can see it.
-    const slot: Slot = {
-      state: 0,
-      value: undefined
-    }
-    slots.set(identifier, slot)
-    return slot
-  }
-
-  function resolveReference($ref: string): Exclude<Representation, { _tag: "Reference" }> {
+  function resolveReference($ref: string): ResolvedReference {
     const definition = document.definitions[$ref]
     if (definition === undefined) {
       throw new Error(`Reference ${$ref} not found`)
     }
 
-    const slot = getSlot($ref)
-
-    if (slot.state === 2) {
-      // Already built: return the built schema directly
-      return slot.value!
-    }
-
-    if (slot.state === 1) {
-      // Circular: we're currently building this identifier.
+    const resolved = resolvedReferences.get($ref)
+    if (resolved === null) {
       throw new Error(`Circular reference detected: ${$ref}`)
     }
+    if (resolved !== undefined) return resolved
 
-    // First time: build it.
-    slot.state = 1
+    resolvedReferences.set($ref, null)
     const value = recur(definition)
-
-    slot.value = value._tag === "Reference" ? resolveReference(value.$ref) : value
-    slot.state = 2
-    return slot.value
+    const out = value._tag === "Reference" ? resolveReference(value.$ref) : value
+    resolvedReferences.set($ref, out)
+    return out
   }
 
-  Object.entries(document.definitions).forEach(([identifier, definition]) => {
-    visited = new Set<string>([identifier])
+  for (const [identifier, definition] of Object.entries(document.definitions)) {
+    definitionIdentifier = identifier
     references[identifier] = unknownToJson(recur(definition))
-  })
+  }
 
-  visited = new Set<string>()
+  definitionIdentifier = undefined
   const representations = Arr.map(document.schemas, (schema) => unknownToJson(recur(schema)))
   return {
     representations,
@@ -3143,7 +3118,7 @@ export function fromJsonSchemaMultiDocument(document: JsonSchema.MultiDocument<"
       const $ref = js.$ref.slice(2).split("/").at(-1)
       if ($ref !== undefined) {
         const reference: Reference = { _tag: "Reference", $ref: unescapeToken($ref) }
-        if (visited.has($ref)) {
+        if (definitionIdentifier === $ref) {
           return { _tag: "Suspend", thunk: reference, checks: [] }
         } else {
           return reference
@@ -3250,168 +3225,159 @@ export function fromJsonSchemaMultiDocument(document: JsonSchema.MultiDocument<"
         return combine(resolveReference(a.$ref), b)
       case "Never":
         return a
-      case "Unknown":
-        switch (b._tag) {
-          case "Reference":
-            return combine(a, resolveReference(b.$ref))
-          default:
-            return { ...b, ...combineAnnotations(a.annotations, b.annotations) }
-        }
+      case "Unknown": {
+        const resolved = b._tag === "Reference" ? resolveReference(b.$ref) : b
+        return { ...resolved, ...combineAnnotations(a.annotations, resolved.annotations) }
+      }
       case "Null":
-        switch (b._tag) {
-          case "Unknown":
-          case "Null":
-            return { ...a, ...combineAnnotations(a.annotations, b.annotations) }
-          case "Union":
-            return combine(b, a)
-          case "Reference":
-            return combine(a, resolveReference(b.$ref))
-          default:
-            return never
-        }
       case "String":
-        switch (b._tag) {
-          case "Unknown":
-            return { ...a, ...combineAnnotations(a.annotations, b.annotations) }
-          case "String": {
-            const checks = combineChecks(a.checks, b.checks, b.annotations)
-            return {
-              _tag: "String",
-              checks: checks ?? a.checks,
-              ...combineAnnotations(a.annotations, checks ? undefined : b.annotations)
-            }
-          }
-          case "Literal":
-            return typeof b.literal === "string" ? { ...b, ...combineAnnotations(a.annotations, b.annotations) } : never
-          case "Union":
-            return combine(b, a)
-          case "Reference":
-            return combine(a, resolveReference(b.$ref))
-          default:
-            return never
-        }
       case "Number":
-        switch (b._tag) {
-          case "Unknown":
-            return { ...a, ...combineAnnotations(a.annotations, b.annotations) }
-          case "Number": {
-            const checks = combineNumberChecks(a.checks, b.checks, b.annotations)
-            return {
-              _tag: "Number",
-              checks: checks ?? a.checks,
-              ...combineAnnotations(a.annotations, checks ? undefined : b.annotations)
-            }
-          }
-          case "Literal":
-            return typeof b.literal === "number" ? { ...b, ...combineAnnotations(a.annotations, b.annotations) } : never
-          case "Union":
-            return combine(b, a)
-          case "Reference":
-            return combine(a, resolveReference(b.$ref))
-          default:
-            return never
+      case "Boolean":
+      case "Literal":
+      case "Arrays":
+      case "Objects":
+      case "Union":
+        break
+    }
+
+    if (b._tag === "Reference") {
+      return combine(a, resolveReference(b.$ref))
+    }
+    if (b._tag === "Unknown") {
+      return { ...a, ...combineAnnotations(a.annotations, b.annotations) }
+    }
+    if (a._tag === "Union") {
+      const types = a.types.map((s) => combine(s, b)).filter((s) => s !== never)
+      if (types.length === 0) return never
+      return {
+        _tag: "Union",
+        types,
+        mode: a.mode,
+        ...makeAnnotations(a.annotations)
+      }
+    }
+    if (b._tag === "Union") {
+      return combine(b, a)
+    }
+
+    switch (a._tag) {
+      case "Null":
+        return b._tag === "Null" ? { ...a, ...combineAnnotations(a.annotations, b.annotations) } : never
+      case "String": {
+        if (b._tag === "Literal") {
+          return satisfiesLiteral(a, b) ? { ...b, ...combineAnnotations(a.annotations, b.annotations) } : never
+        }
+        if (b._tag !== "String") return never
+        const checks = combineChecks(a.checks, b.checks, b.annotations)
+        return {
+          _tag: "String",
+          checks: checks ?? a.checks,
+          ...combineAnnotations(a.annotations, checks ? undefined : b.annotations)
+        }
+      }
+      case "Number": {
+        if (b._tag === "Literal") {
+          return satisfiesLiteral(a, b) ? { ...b, ...combineAnnotations(a.annotations, b.annotations) } : never
+        }
+        if (b._tag !== "Number") return never
+        const checks = combineNumberChecks(a.checks, b.checks, b.annotations)
+        return {
+          _tag: "Number",
+          checks: checks ?? a.checks,
+          ...combineAnnotations(a.annotations, checks ? undefined : b.annotations)
         }
+      }
       case "Boolean":
-        switch (b._tag) {
-          case "Unknown":
-            return { ...a, ...combineAnnotations(a.annotations, b.annotations) }
-          case "Boolean":
-            return { _tag: "Boolean", ...combineAnnotations(a.annotations, b.annotations) }
-          case "Literal":
-            return typeof b.literal === "boolean"
-              ? { ...b, ...combineAnnotations(a.annotations, b.annotations) }
-              : never
-          case "Union":
-            return combine(b, a)
-          case "Reference":
-            return combine(a, resolveReference(b.$ref))
-          default:
-            return never
+        if (b._tag === "Boolean") {
+          return { _tag: "Boolean", ...combineAnnotations(a.annotations, b.annotations) }
         }
+        return b._tag === "Literal" && typeof b.literal === "boolean"
+          ? { ...b, ...combineAnnotations(a.annotations, b.annotations) }
+          : never
       case "Literal":
         switch (b._tag) {
-          case "Unknown":
-            return { ...a, ...combineAnnotations(a.annotations, b.annotations) }
           case "Literal":
             return a.literal === b.literal
               ? { ...a, ...combineAnnotations(a.annotations, b.annotations) }
               : never
           case "String":
-            return typeof a.literal === "string" ? { ...a, ...combineAnnotations(a.annotations, b.annotations) } : never
           case "Number":
-            return typeof a.literal === "number" ? { ...a, ...combineAnnotations(a.annotations, b.annotations) } : never
+            return satisfiesLiteral(b, a) ? { ...a, ...combineAnnotations(a.annotations, b.annotations) } : never
           case "Boolean":
             return typeof a.literal === "boolean"
               ? { ...a, ...combineAnnotations(a.annotations, b.annotations) }
               : never
-          case "Union":
-            return combine(b, a)
-          case "Reference":
-            return combine(a, resolveReference(b.$ref))
           default:
             return never
         }
-      case "Arrays":
-        switch (b._tag) {
-          case "Unknown":
-            return { ...a, ...combineAnnotations(a.annotations, b.annotations) }
-          case "Arrays": {
-            const checks = combineArraysChecks(a.checks, b.checks, b.annotations)
-            return {
-              _tag: "Arrays",
-              elements: combineElements(a.elements, b.elements),
-              rest: combineRest(a.rest, b.rest),
-              checks: checks ?? a.checks,
-              ...combineAnnotations(a.annotations, checks ? undefined : b.annotations)
-            }
-          }
-          case "Union":
-            return combine(b, a)
-          case "Reference":
-            return combine(a, resolveReference(b.$ref))
-          default:
-            return never
-        }
-      case "Objects":
-        switch (b._tag) {
-          case "Unknown":
-            return { ...a, ...combineAnnotations(a.annotations, b.annotations) }
-          case "Objects": {
-            const checks = combineChecks(a.checks, b.checks, b.annotations)
-            return {
-              _tag: "Objects",
-              propertySignatures: combinePropertySignatures(a.propertySignatures, b.propertySignatures),
-              indexSignatures: combineIndexSignatures(a.indexSignatures, b.indexSignatures),
-              checks: checks ?? a.checks,
-              ...combineAnnotations(a.annotations, checks ? undefined : b.annotations)
-            }
-          }
-          case "Union":
-            return combine(b, a)
-          case "Reference":
-            return combine(a, resolveReference(b.$ref))
-          default:
-            return never
+      case "Arrays": {
+        if (b._tag !== "Arrays") return never
+        const arrays = combineArrays(a, b)
+        if (arrays === undefined) return never
+        const checks = combineArraysChecks(a.checks, b.checks, b.annotations)
+        return {
+          _tag: "Arrays",
+          elements: arrays.elements,
+          rest: arrays.rest,
+          checks: checks ?? a.checks,
+          ...combineAnnotations(a.annotations, checks ? undefined : b.annotations)
         }
-      case "Union": {
-        switch (b._tag) {
-          case "Unknown":
-            return { ...a, ...combineAnnotations(a.annotations, b.annotations) }
-          default: {
-            const types = a.types.map((s) => combine(s, b)).filter((s) => s !== never)
-            if (types.length === 0) return never
-            return {
-              _tag: "Union",
-              types,
-              mode: a.mode,
-              ...makeAnnotations(a.annotations)
-            }
-          }
+      }
+      case "Objects": {
+        if (b._tag !== "Objects") return never
+        const checks = combineChecks(a.checks, b.checks, b.annotations)
+        return {
+          _tag: "Objects",
+          propertySignatures: combinePropertySignatures(a.propertySignatures, b.propertySignatures),
+          indexSignatures: combineIndexSignatures(a.indexSignatures, b.indexSignatures),
+          checks: checks ?? a.checks,
+          ...combineAnnotations(a.annotations, checks ? undefined : b.annotations)
         }
       }
+      default:
+        return never
+    }
+  }
+
+  function satisfiesPrimitiveCheck(check: Check<Meta>, value: unknown): boolean {
+    if (check._tag === "FilterGroup") {
+      return check.checks.every((check) => satisfiesPrimitiveCheck(check, value))
+    }
+    const meta = check.meta
+    switch (meta._tag) {
+      case "isMinLength":
+        return typeof value === "string" && value.length >= meta.minLength
+      case "isMaxLength":
+        return typeof value === "string" && value.length <= meta.maxLength
+      case "isPattern":
+        return typeof value === "string" && meta.regExp.test(value)
+      case "isFinite":
+        return typeof value === "number" && globalThis.Number.isFinite(value)
+      case "isInt":
+        return typeof value === "number" && globalThis.Number.isSafeInteger(value)
+      case "isMultipleOf":
+        return typeof value === "number" && remainder(value, meta.divisor) === 0
+      case "isGreaterThan":
+        return typeof value === "number" && value > meta.exclusiveMinimum
+      case "isGreaterThanOrEqualTo":
+        return typeof value === "number" && value >= meta.minimum
+      case "isLessThan":
+        return typeof value === "number" && value < meta.exclusiveMaximum
+      case "isLessThanOrEqualTo":
+        return typeof value === "number" && value <= meta.maximum
+      default:
+        return false
     }
   }
 
+  function satisfiesLiteral(type: String | Number, literal: Literal): boolean {
+    const value = literal.literal
+    if (type._tag === "String" ? typeof value !== "string" : typeof value !== "number") {
+      return false
+    }
+    return type.checks.every((check) => satisfiesPrimitiveCheck(check, value))
+  }
+
   function collectProperties(js: JsonSchema.JsonSchema): Array<PropertySignature> {
     const properties: Record<string, unknown> = Predicate.isObject(js.properties) ? js.properties : {}
     const required = Array.isArray(js.required) ? js.required : []
@@ -3446,35 +3412,32 @@ export function fromJsonSchemaMultiDocument(document: JsonSchema.MultiDocument<"
     return out
   }
 
-  function combineElements(a: ReadonlyArray<Element>, b: ReadonlyArray<Element>): Array<Element> {
-    const len = Math.max(a.length, b.length)
-    let out: Array<Element> = []
+  function combineArrays(a: Arrays, b: Arrays): Pick<Arrays, "elements" | "rest"> | undefined {
+    const elements: Array<Element> = []
+    const len = Math.max(a.elements.length, b.elements.length)
     for (let i = 0; i < len; i++) {
-      out.push({
-        isOptional: a[i].isOptional && b[i].isOptional,
-        type: combine(a[i].type, b[i].type)
-      })
-    }
-    if (a.length > len) {
-      out = [...out, ...a.slice(len)]
-    } else if (b.length > len) {
-      out = [...out, ...b.slice(len)]
+      const ae = a.elements[i]
+      const be = b.elements[i]
+      const isOptional = ae?.isOptional !== false && be?.isOptional !== false
+      const at = ae?.type ?? a.rest[0]
+      const bt = be?.type ?? b.rest[0]
+      if (at === undefined || bt === undefined) {
+        return isOptional ? { elements, rest: [] } : undefined
+      }
+      const type = combine(at, bt)
+      if (type === never) {
+        return isOptional ? { elements, rest: [] } : undefined
+      }
+      elements.push({ isOptional, type })
     }
-    return out
-  }
 
-  function combineRest(a: ReadonlyArray<Representation>, b: ReadonlyArray<Representation>): Array<Representation> {
-    const len = Math.max(a.length, b.length)
-    let out: Array<Representation> = []
-    for (let i = 0; i < len; i++) {
-      out.push(combine(a[i], b[i]))
+    const ar = a.rest[0]
+    const br = b.rest[0]
+    if (ar === undefined || br === undefined) {
+      return { elements, rest: [] }
     }
-    if (a.length > len) {
-      out = [...out, ...a.slice(len)]
-    } else if (b.length > len) {
-      out = [...out, ...b.slice(len)]
-    }
-    return out
+    const rest = combine(ar, br)
+    return { elements, rest: rest === never ? [] : [rest] }
   }
 
   function combinePropertySignatures(

package/src/index.ts

@@ -296,6 +296,11 @@ export * as Layer from "./Layer.ts"
  */
 export * as LayerMap from "./LayerMap.ts"
 
+/**
+ * @since 4.0.0
+ */
+export * as LayerRef from "./LayerRef.ts"
+
 /**
  * @since 2.0.0
  */
@@ -521,6 +526,11 @@ export * as Schema from "./Schema.ts"
  */
 export * as SchemaAST from "./SchemaAST.ts"
 
+/**
+ * @since 4.0.0
+ */
+export * as SchemaError from "./SchemaError.ts"
+
 /**
  * @since 4.0.0
  */

package/src/internal/effect.ts

@@ -851,10 +851,12 @@ export const fiberInterruptAll = <A extends Iterable<Fiber.Fiber<any, any>>>(
 ): Effect.Effect<void> =>
   withFiber((parent) => {
     const annotations = fiberStackAnnotations(parent)
+    let fiberArr = Arr.empty<Fiber.Fiber<any, any>>()
     for (const fiber of fibers) {
       fiber.interruptUnsafe(parent.id, annotations)
+      fiberArr.push(fiber)
     }
-    return asVoid(fiberAwaitAll(fibers))
+    return asVoid(fiberAwaitAll(fiberArr))
   })
 
 /** @internal */
@@ -867,8 +869,12 @@ export const fiberInterruptAllAs: {
 ): Effect.Effect<void> =>
   withFiber((parent) => {
     const annotations = fiberStackAnnotations(parent)
-    for (const fiber of fibers) fiber.interruptUnsafe(fiberId, annotations)
-    return asVoid(fiberAwaitAll(fibers))
+    const fiberArr = Arr.empty<Fiber.Fiber<any, any>>()
+    for (const fiber of fibers) {
+      fiber.interruptUnsafe(fiberId, annotations)
+      fiberArr.push(fiber)
+    }
+    return asVoid(fiberAwaitAll(fiberArr))
   }))
 
 /** @internal */
@@ -4585,17 +4591,20 @@ const forEachSequential = <A, B, E, R>(
     )
   })
 
+type IterateEagerOptions = {
+  readonly concurrency?: number | undefined
+  readonly start?: number | undefined
+  readonly end?: number | undefined
+  readonly orderedStep?: boolean | undefined
+}
+
 const iterateEagerImpl = <S, A, X, E, R, E2>(options: {
   readonly onItem: (state: S, item: A, index: number) => Effect.Effect<X, E, R>
   readonly step: (state: NoInfer<S>, item: A, exit: Exit.Exit<X, E>, index: number) => Exit.Exit<void, E2> | void
 }): (
   initialState: S,
   items: ReadonlyArray<A>,
-  options?: {
-    readonly concurrency?: number | undefined
-    readonly start?: number | undefined
-    readonly end?: number | undefined
-  }
+  options?: IterateEagerOptions
 ) => Effect.Effect<void, E | E2, R> | undefined => {
   const onItem = options.onItem
   const step = options.step
@@ -4603,15 +4612,12 @@ const iterateEagerImpl = <S, A, X, E, R, E2>(options: {
   return (
     state: S,
     items: ReadonlyArray<A>,
-    opts: {
-      readonly concurrency?: number | undefined
-      readonly start?: number | undefined
-      readonly end?: number | undefined
-    } | undefined
+    opts: IterateEagerOptions | undefined
   ): Effect.Effect<void, E | E2, R> | undefined => {
     let index = opts?.start ?? 0
     const end = opts?.end ?? items.length
     const concurrency = opts?.concurrency ?? 1
+    const orderedStep = opts?.orderedStep === true && concurrency > 1
     let done = false
     let parentFiber: Fiber.Fiber<any, any> | undefined
     let fibers: Set<Fiber.Fiber<any, any>> | undefined
@@ -4619,6 +4625,22 @@ const iterateEagerImpl = <S, A, X, E, R, E2>(options: {
     let interrupted = false
     let terminal: Exit.Exit<void, E | E2> | void
     let effect: Effect.Effect<X, E, R> | undefined
+    let nextIndex = index
+    const exits: Array<Exit.Exit<X, E> | undefined> | undefined = orderedStep ? new Array(end) : undefined
+
+    const runStep = (item: A, exit: Exit.Exit<X, E>, currentIndex: number): Exit.Exit<void, E | E2> | void => {
+      if (!orderedStep) return step(state, item, exit, currentIndex)
+      if (terminal) return terminal
+      exits![currentIndex] = exit
+      while (nextIndex < end) {
+        const nextExit = exits![nextIndex]
+        if (nextExit === undefined) return
+        exits![nextIndex] = undefined
+        const index = nextIndex++
+        const result = step(state, items[index], nextExit, index)
+        if (result) return result
+      }
+    }
 
     const go = (): Effect.Effect<void, E | E2, R> | undefined => {
       let paused = false
@@ -4628,13 +4650,13 @@ const iterateEagerImpl = <S, A, X, E, R, E2>(options: {
 
         // fast case (already an exit)
         if (effectIsExit(eff)) {
-          terminal = step(state, item, eff, index)
+          terminal = runStep(item, eff, index)
           if (terminal) break
 
           // Use flatMap for concurrency of 1
         } else if (concurrency === 1) {
           return flatMap(exit(eff), (exit) => {
-            terminal = step(state, item, exit, index)
+            terminal = runStep(item, exit, index)
             index++
             return terminal ?? go() ?? void_
           })
@@ -4661,7 +4683,7 @@ const iterateEagerImpl = <S, A, X, E, R, E2>(options: {
 
           const fiber = forkUnsafe(parentFiber, eff, true, true, "inherit")
           if (fiber._exit) {
-            terminal = step(state, item, fiber._exit, index)
+            terminal = runStep(item, fiber._exit, index)
             if (terminal) break
             continue
           }
@@ -4685,7 +4707,7 @@ const iterateEagerImpl = <S, A, X, E, R, E2>(options: {
                 }
               }
             } else {
-              const result = step(state, item, exit, currentIndex)
+              const result = runStep(item, exit, currentIndex)
               if (result) {
                 terminal = result._tag === "Failure"
                   ? exitFailCause(causeFromReasons(result.cause.reasons.slice()))
@@ -4741,11 +4763,7 @@ export const iterateEager = <S, A>(): <X, E, R, E2>(options: {
 }) => (
   initialState: S,
   items: ReadonlyArray<A>,
-  options?: {
-    readonly concurrency?: number | undefined
-    readonly start?: number | undefined
-    readonly end?: number | undefined
-  }
+  options?: IterateEagerOptions
 ) => Effect.Effect<void, E | E2, R> | undefined => iterateEagerImpl
 
 const forEachConcurrent = iterateEagerImpl({
@@ -5835,11 +5853,16 @@ class ClockImpl implements Clock.Clock {
   }
   readonly currentTimeNanos: Effect.Effect<bigint> = sync(() => this.currentTimeNanosUnsafe())
   sleep(duration: Duration.Duration): Effect.Effect<void> {
-    const millis = Duration.toMillis(duration)
+    return this.sleepMillis(Duration.toMillis(duration))
+  }
+  private sleepMillis(millis: number): Effect.Effect<void> {
     if (millis <= 0) return yieldNow
+    else if (!Number.isFinite(millis)) return never
     return callback((resume) => {
-      if (millis > MAX_TIMER_MILLIS) return
-      const handle = setTimeout(() => resume(void_), millis)
+      const continuation = millis > MAX_TIMER_MILLIS
+        ? this.sleepMillis(millis - MAX_TIMER_MILLIS)
+        : void_
+      const handle = setTimeout(() => resume(continuation), Math.min(millis, MAX_TIMER_MILLIS))
       return sync(() => clearTimeout(handle))
     })
   }

package/src/internal/schema/equivalence.ts

@@ -78,8 +78,7 @@ function recur(ast: SchemaAST.AST, path: ReadonlyArray<PropertyKey>): Equivalenc
           // handle post rest elements
           // ---------------------------------------------
           for (let j = 0; j < tail.length; j++) {
-            i += j
-            if (!tail[j](a[i], b[i])) {
+            if (!tail[j](a[i + j], b[i + j])) {
               return false
             }
           }

package/src/internal/schema/representation.ts

@@ -95,12 +95,12 @@ export function fromASTs(asts: readonly [SchemaAST.AST, ...Array<SchemaAST.AST>]
     return out
   }
 
-  function getEncodedSchema(last: SchemaAST.Declaration): SchemaAST.AST {
+  function getEncodedSchema(last: SchemaAST.Declaration): SchemaAST.Declaration | SchemaAST.Null {
     const getLink = last.annotations?.toCodecJson ?? last.annotations?.toCodec
     if (Predicate.isFunction(getLink)) {
-      const tps = last.typeParameters.map((tp) => InternalSchema.make(SchemaAST.toEncoded(tp)))
-      const link = getLink(tps)
-      return SchemaAST.replaceEncoding(last, [link])
+      return SchemaAST.replaceEncoding(last, [
+        getLink(last.typeParameters.map((tp) => InternalSchema.make(SchemaAST.toEncoded(tp))))
+      ])
     }
     return SchemaAST.null
   }