effect 4.0.4 → 4.0.6

package/src/internal/schema/interpreter.ts

@@ -22,6 +22,17 @@ const flatMapTransformation = (
   result === InternalParser.sameExit ? f(current) : Effect.flatMapEager(result, f)
 
 function compileTransformation(transformation: SchemaAST.Link["transformation"]): ApplyTransformation {
+  const apply = compileTransformationUnsafe(transformation)
+  return (result, current, options) => {
+    try {
+      return apply(result, current, options)
+    } catch (error) {
+      return Effect.die(error)
+    }
+  }
+}
+
+function compileTransformationUnsafe(transformation: SchemaAST.Link["transformation"]): ApplyTransformation {
   if (transformation._tag === "Middleware") {
     return (result, current, options) => {
       const transformed = result === InternalParser.sameExit
@@ -143,63 +154,65 @@ export function compile(
     return parser
   }
   let encodingParsers: ReadonlyArray<Parser> | undefined
-  const parseChecks = (
-    input: unknown,
-    options: SchemaAST.ParseOptions
-  ) => {
+  const parseChecks: Parser = (input, options) => {
+    // Keep lazy child compilation outside the callback exception boundary.
     let result = parser(input, options)
-    if (encodingChecks && !options.disableChecks) {
-      if (effectIsExit(result)) {
-        if (result._tag === "Success") {
-          const output = result === InternalParser.sameExit
-            ? input
-            : (result as InternalParser.Success<unknown, SchemaIssue.Issue>)[InternalParser.args]
-          if (input !== InternalParser.missing && output !== InternalParser.missing) {
-            const issues = SchemaAST.collectIssues(encodingChecks, input, undefined, ast, options)
-            if (issues) {
-              result = Effect.fail(new SchemaIssue.Composite(ast, issues, input, options))
+    try {
+      if (encodingChecks && !options.disableChecks) {
+        if (effectIsExit(result)) {
+          if (result._tag === "Success") {
+            const output = result === InternalParser.sameExit
+              ? input
+              : (result as InternalParser.Success<unknown, SchemaIssue.Issue>)[InternalParser.args]
+            if (input !== InternalParser.missing && output !== InternalParser.missing) {
+              const issues = SchemaAST.collectIssues(encodingChecks, input, undefined, ast, options)
+              if (issues) {
+                result = Effect.fail(new SchemaIssue.Composite(ast, issues, input, options))
+              }
             }
           }
-        }
-      } else {
-        result = Effect.flatMap(result, (value) => {
-          if (input !== InternalParser.missing && value !== InternalParser.missing) {
-            const issues = SchemaAST.collectIssues(encodingChecks, input, undefined, ast, options)
-            if (issues) {
-              return Effect.fail(new SchemaIssue.Composite(ast, issues, input, options))
+        } else {
+          result = Effect.flatMap(result, (value) => {
+            if (input !== InternalParser.missing && value !== InternalParser.missing) {
+              const issues = SchemaAST.collectIssues(encodingChecks, input, undefined, ast, options)
+              if (issues) {
+                return Effect.fail(new SchemaIssue.Composite(ast, issues, input, options))
+              }
             }
-          }
-          return Effect.succeed(value)
-        })
+            return Effect.succeed(value)
+          })
+        }
       }
-    }
 
-    if (checks && !options.disableChecks) {
-      if (effectIsExit(result)) {
-        if (result._tag === "Success") {
-          const value = result === InternalParser.sameExit
-            ? input
-            : (result as InternalParser.Success<unknown, SchemaIssue.Issue>)[InternalParser.args]
-          if (value === InternalParser.missing) return result
-          const issues = SchemaAST.collectIssues(checks, value, undefined, ast, options)
-          if (issues) {
-            result = Effect.fail(new SchemaIssue.Composite(ast, issues, value, options))
-          }
-        }
-      } else {
-        result = Effect.flatMap(result, (value) => {
-          if (value !== InternalParser.missing) {
+      if (checks && !options.disableChecks) {
+        if (effectIsExit(result)) {
+          if (result._tag === "Success") {
+            const value = result === InternalParser.sameExit
+              ? input
+              : (result as InternalParser.Success<unknown, SchemaIssue.Issue>)[InternalParser.args]
+            if (value === InternalParser.missing) return result
             const issues = SchemaAST.collectIssues(checks, value, undefined, ast, options)
             if (issues) {
-              return Effect.fail(new SchemaIssue.Composite(ast, issues, value, options))
+              result = Effect.fail(new SchemaIssue.Composite(ast, issues, value, options))
             }
           }
-          return Effect.succeed(value)
-        })
+        } else {
+          result = Effect.flatMap(result, (value) => {
+            if (value !== InternalParser.missing) {
+              const issues = SchemaAST.collectIssues(checks, value, undefined, ast, options)
+              if (issues) {
+                return Effect.fail(new SchemaIssue.Composite(ast, issues, value, options))
+              }
+            }
+            return Effect.succeed(value)
+          })
+        }
       }
-    }
 
-    return result
+      return result
+    } catch (error) {
+      return Effect.die(error)
+    }
   }
   const parseLocal = specialize === undefined ? parseChecks : specialize(parseChecks)
   if (!links) {

package/src/internal/schema/standardSchema.ts

@@ -53,18 +53,31 @@ export function toStandardSchemaV1<S extends Schema.ConstraintDecoder<unknown>>(
       })
     })
   }
-  if (Object.hasOwn(self, "~standard")) {
-    const out = self as any
-    if ("validate" in out["~standard"]) return out
-    Object.assign(out["~standard"], { validate })
-    return out
+  return attach(self, { validate })
+}
+
+function attach(self: any, members: object): any {
+  const standard = {
+    version: 1,
+    vendor: "effect",
+    // Only an own adapter describes `self`; an inherited one describes a parent class.
+    ...(Object.hasOwn(self, "~standard") ? self["~standard"] : undefined),
+    ...members
   }
-  return Object.assign(self, {
+  // A bound function preserves construction; private static brands are not copied.
+  const out = typeof self === "function"
+    ? Function.prototype.bind.call(self, undefined)
+    : Object.create(Object.getPrototypeOf(self))
+  return Object.defineProperties(out, {
+    ...Object.getOwnPropertyDescriptors(self),
+    // Initialize a class's lazy AST with the original constructor as its receiver.
+    ast: { value: self.ast, enumerable: true, configurable: true },
     "~standard": {
-      version: 1,
-      vendor: "effect",
-      validate
-    } as const
+      value: standard,
+      writable: true,
+      enumerable: true,
+      configurable: true
+    }
   })
 }
 
@@ -101,25 +114,14 @@ function toBaseStandardJSONSchemaV1(
 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 (Object.hasOwn(self, "~standard")) {
-    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
+  return attach(self, {
+    jsonSchema: {
+      input(options) {
+        return toBaseStandardJSONSchemaV1(self.ast, options.target)
+      },
+      output(options) {
+        return toBaseStandardJSONSchemaV1(SchemaAST.toType(self.ast), options.target)
+      }
+    } satisfies StandardJSONSchemaV1.Converter
   })
 }

package/src/internal/schema/toCodeDocument.ts

@@ -48,7 +48,12 @@ function renderEmittableAnnotation(input: unknown): string | undefined {
   return entries.length === 0 ? "{}" : `{ ${entries.join(", ")} }`
 }
 
-const canonicalFiniteCheck = `Schema.isFinite().annotate({ "expected": "a finite number" })`
+// Leading checks that turn a bare `Schema.Number` into a built-in schema.
+const canonicalNumberChecks: Record<string, string> = {
+  [`Schema.isFinite().annotate({ "expected": "a finite number" })`]: "Schema.Finite",
+  ["Schema.isInt()"]: "Schema.Int",
+  [`Schema.isInt().annotate({ "expected": "an integer" })`]: "Schema.Int"
+}
 
 function renderAnnotations(
   annotations: Schema.Annotations.Annotations | undefined
@@ -345,8 +350,8 @@ export function toCodeDocument(
       const check = representation.checks[index]
       const compiledCheck = compileCheck(check, [...path, "checks", index])
       // Only collapse a bare number's leading canonical check.
-      runtime = runtime === "Schema.Number" && compiledCheck === canonicalFiniteCheck
-        ? "Schema.Finite"
+      runtime = runtime === "Schema.Number" && Object.hasOwn(canonicalNumberChecks, compiledCheck)
+        ? canonicalNumberChecks[compiledCheck]
         : `${runtime}.check(${compiledCheck})`
     }
     return makeCode(runtime, base.Type)

package/src/internal/schema/toCodec.ts

@@ -1,8 +1,10 @@
-import { memoize } from "../../Function.ts"
+import { identity, memoize, memoizeIdempotent } from "../../Function.ts"
+import * as Option from "../../Option.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 SchemaParser from "../../SchemaParser.ts"
 import * as InternalTransformation from "../../SchemaTransformation.ts"
 import * as InternalMake from "./make.ts"
 
@@ -13,6 +15,14 @@ export function toCodecJson<S extends PublicSchema.Constraint>(schema: S): Publi
 
 /** @internal */
 export const toCodecJsonAST = SchemaAST.applyToSelfOrLastLinkEncodingIdempotent((ast) => {
+  const owner = SchemaAST.getContextOwner(ast)
+  if (owner !== ast) {
+    // A context-only copy reuses the owner's rebuilt body, so both keep one identity.
+    // Encoded derivations already share their body and take the regular step.
+    const fromOwner = toCodecJsonAST(owner)
+    if (fromOwner === owner) return ast
+    if (fromOwner.encoding === undefined) return SchemaAST.replaceContext(fromOwner, ast.context)
+  }
   const out = toCodecJsonASTStep(ast, toCodecJsonAST)
   const context = ast.context
   if (out === ast || context === undefined) return out
@@ -291,6 +301,111 @@ const toCodecArrayFromSingleAST = SchemaAST.applyToSelfOrLastLinkEncodingIdempot
   return out
 }, { stopAt: isCodecArrayFromSingleLink })
 
+/** @internal */
+export function toCodecGoJson<S extends PublicSchema.Constraint>(
+  schema: S
+): PublicSchema.toCodecGoJson<S> {
+  return InternalMake.make(toCodecGoJsonAST(schema.ast), { schema })
+}
+
+// Keep the canonical member first to preserve accepted nulls and union branch
+// selection. Added members (`never`, `[]`, `{}`) do not widen the decoded type.
+const toCodecGoJsonAST = memoizeIdempotent((ast: SchemaAST.AST): SchemaAST.AST =>
+  nilAsEmptyAtEncoded(goNilAST(toCodecJsonAST(ast)))
+)
+
+const goNilAST: (ast: SchemaAST.AST) => SchemaAST.AST = SchemaAST.applyToSelfOrLastLinkEncodingIdempotent((ast) => {
+  switch (ast._tag) {
+    case "Objects":
+      return ast.recur((type) => nilAsMissingOrEmptyAtEncoded(goNilAST(type)), identity)
+    case "Arrays":
+      return ast.recur((type) => nilAsEmptyAtEncoded(goNilAST(type)))
+    case "Declaration":
+    case "Union":
+    case "Suspend":
+      return ast.recur(goNilAST)
+  }
+  return ast
+})
+
+const nilAsMissingOrEmptyAtEncoded = SchemaAST.applyToSelfOrLastLinkEncoding((ast) =>
+  SchemaAST.isOptional(ast) ? nilAsMissingAtEncoded(ast) : nilAsEmptyAtEncoded(ast)
+)
+
+const nilAsMissingAtEncoded: (ast: SchemaAST.AST) => SchemaAST.AST = SchemaAST.applyToSelfOrLastLinkEncoding(
+  (ast) => {
+    if (SchemaAST.isSuspend(ast)) return ast.recur(nilAsMissingAtEncoded)
+    if (isGoNil(ast) || acceptsNull(ast)) return ast
+    return orNull(ast, decodeNull(SchemaAST.never, nullAsMissing))
+  }
+)
+
+// Only a plain `Schema.Array` or `Schema.Record` can be a Go slice or map, so
+// tuples, non-empty arrays, and structs keep rejecting `null`. The empty value
+// still has to pass the collection's checks.
+const nilAsEmptyAtEncoded: (ast: SchemaAST.AST) => SchemaAST.AST = SchemaAST.applyToSelfOrLastLinkEncoding((ast) => {
+  if (SchemaAST.isSuspend(ast)) return ast.recur(nilAsEmptyAtEncoded)
+  if (SchemaAST.isArrays(ast) && ast.elements.length === 0 && ast.rest.length === 1) {
+    return orNull(ast, decodeNull(SchemaAST.replaceChecks(emptyArray, ast.checks), nullAsEmptyArray))
+  }
+  if (SchemaAST.isObjects(ast) && ast.propertySignatures.length === 0 && ast.indexSignatures.length > 0) {
+    return orNull(ast, decodeNull(SchemaAST.replaceChecks(emptyRecord, ast.checks), nullAsEmptyRecord))
+  }
+  return ast
+})
+
+// Only skips the `null` member when the schema certainly accepts `null`, to
+// keep the JSON Schema tidy. Suspended schemas are not resolved, so recursive
+// definitions stay lazy.
+function acceptsNull(ast: SchemaAST.AST): boolean {
+  const encoded = SchemaAST.getLastEncoding(ast)
+  switch (encoded._tag) {
+    case "Union":
+      return encoded.checks === undefined && encoded.types.some(acceptsNull)
+    case "Null":
+    case "Unknown":
+    case "Any":
+    case "Declaration":
+      return SchemaParser.is(InternalMake.make(SchemaAST.replaceContext(encoded, undefined)))(null)
+  }
+  return false
+}
+
+function orNull(ast: SchemaAST.AST, member: SchemaAST.AST): SchemaAST.AST {
+  return SchemaAST.replaceContext(new SchemaAST.Union([SchemaAST.replaceContext(ast, undefined), member]), ast.context)
+}
+
+const nullTo = (decode: SchemaGetter.Getter<unknown, null>) =>
+  new InternalTransformation.Transformation(
+    decode,
+    SchemaGetter.forbidden<null, unknown>(() => "Go nil values are never encoded")
+  )
+
+const nullAsMissing = nullTo(SchemaGetter.transformOptional<unknown, null>(() => Option.none()))
+
+const nullAsEmptyArray = nullTo(SchemaGetter.transform<unknown, null>(() => []))
+
+const nullAsEmptyRecord = nullTo(SchemaGetter.transform<unknown, null>(() => ({})))
+
+const emptyArray = new SchemaAST.Arrays(false, [], [])
+
+const emptyRecord = SchemaAST.record(SchemaAST.string, SchemaAST.never)
+
+function decodeNull(
+  to: SchemaAST.AST,
+  transformation: InternalTransformation.Transformation<unknown, null>
+): SchemaAST.AST {
+  return SchemaAST.decodeTo(SchemaAST.null, to, transformation)
+}
+
+// A union this codec already built, so applying it again changes nothing.
+function isGoNil(ast: SchemaAST.AST): boolean {
+  if (!SchemaAST.isUnion(ast)) return false
+  const transformation = ast.types[ast.types.length - 1].encoding?.[0].transformation
+  return transformation === nullAsMissing || transformation === nullAsEmptyArray ||
+    transformation === nullAsEmptyRecord
+}
+
 function toCodecArrayFromSingleASTStep(ast: SchemaAST.AST): SchemaAST.AST {
   return ast._tag === "Declaration" || ast._tag === "Arrays" || ast._tag === "Objects" || ast._tag === "Union" ||
       ast._tag === "Suspend"

package/src/internal/schema/toFormatter.ts

@@ -110,9 +110,9 @@ export function toFormatter<T>(ast: SchemaAST.AST, options?: {
             return (map: globalThis.ReadonlyMap<unknown, unknown>) => {
               const size = map.size
               if (size === 0) return "ReadonlyMap(0) {}"
-              const entries = globalThis.Array.from(map.entries()).sort().map(([key_, value_]) =>
+              const entries = globalThis.Array.from(map.entries()).map(([key_, value_]) =>
                 `${key(key_)} => ${value(value_)}`
-              )
+              ).sort()
               return `ReadonlyMap(${size}) { ${entries.join(", ")} }`
             }
           }
@@ -121,7 +121,7 @@ export function toFormatter<T>(ast: SchemaAST.AST, options?: {
             return (map: HashMap.HashMap<unknown, unknown>) => {
               const size = HashMap.size(map)
               if (size === 0) return "HashMap(0) {}"
-              const entries = HashMap.toEntries(map).sort().map(([key_, value_]) => `${key(key_)} => ${value(value_)}`)
+              const entries = HashMap.toEntries(map).map(([key_, value_]) => `${key(key_)} => ${value(value_)}`).sort()
               return `HashMap(${size}) { ${entries.join(", ")} }`
             }
           }
@@ -130,7 +130,7 @@ export function toFormatter<T>(ast: SchemaAST.AST, options?: {
             return (set: globalThis.ReadonlySet<unknown>) => {
               const size = set.size
               if (size === 0) return "ReadonlySet(0) {}"
-              const values = globalThis.Array.from(set.values()).sort().map((item) => `${value(item)}`)
+              const values = globalThis.Array.from(set.values()).map((item) => `${value(item)}`).sort()
               return `ReadonlySet(${size}) { ${values.join(", ")} }`
             }
           }
@@ -139,7 +139,7 @@ export function toFormatter<T>(ast: SchemaAST.AST, options?: {
             return (set: HashSet.HashSet<unknown>) => {
               const size = HashSet.size(set)
               if (size === 0) return "HashSet(0) {}"
-              const values = globalThis.Array.from(set).sort().map((item) => `${value(item)}`)
+              const values = globalThis.Array.from(set).map((item) => `${value(item)}`).sort()
               return `HashSet(${size}) { ${values.join(", ")} }`
             }
           }
@@ -148,7 +148,7 @@ export function toFormatter<T>(ast: SchemaAST.AST, options?: {
             return (chunk: Chunk.Chunk<unknown>) => {
               const size = Chunk.size(chunk)
               if (size === 0) return "Chunk(0) {}"
-              const values = globalThis.Array.from(chunk).sort().map((item) => `${value(item)}`)
+              const values = globalThis.Array.from(chunk).map((item) => `${value(item)}`)
               return `Chunk(${size}) { ${values.join(", ")} }`
             }
           }

package/src/internal/schema/toJsonSchemaDocument.ts

@@ -30,27 +30,23 @@ function collectJsonSchemaAnnotations(
   if (annotations === undefined) return undefined
 
   const out: JsonSchema.JsonSchema = {}
-  const title = annotations.title
-  if (typeof title === "string") out.title = title
-  const description = annotations.description
+  for (const key of ["title", "description", "format", "contentEncoding", "contentMediaType"] as const) {
+    const value = annotations[key]
+    if (typeof value === "string") out[key] = value
+  }
+  for (const key of ["readOnly", "writeOnly"] as const) {
+    const value = annotations[key]
+    if (typeof value === "boolean") out[key] = value
+  }
   const expected = annotations.expected
-  if (typeof description === "string") out.description = description
-  else if (options?.generateDescriptions === true && typeof expected === "string") out.description = expected
+  if (out.description === undefined && options?.generateDescriptions === true && typeof expected === "string") {
+    out.description = expected
+  }
 
   const defaultValue = annotations.default
   if (InternalAST.isJson(defaultValue)) out.default = defaultValue
   const examples = annotations.examples
   if (Array.isArray(examples) && InternalAST.isJson(examples)) out.examples = examples
-  const readOnly = annotations.readOnly
-  if (typeof readOnly === "boolean") out.readOnly = readOnly
-  const writeOnly = annotations.writeOnly
-  if (typeof writeOnly === "boolean") out.writeOnly = writeOnly
-  const format = annotations.format
-  if (typeof format === "string") out.format = format
-  const contentEncoding = annotations.contentEncoding
-  if (typeof contentEncoding === "string") out.contentEncoding = contentEncoding
-  const contentMediaType = annotations.contentMediaType
-  if (typeof contentMediaType === "string") out.contentMediaType = contentMediaType
   const contentSchema = annotations.contentSchema
   if (InternalAST.isJson(contentSchema)) out.contentSchema = contentSchema
 
@@ -450,23 +446,16 @@ function compileJsonSchema(
           : { type: typeof literal, enum: [literal] }
       }
       case "Enum": {
-        const types = representation.enums.map(([title, literal], index) => {
-          if (typeof literal === "number" && !globalThis.Number.isFinite(literal)) {
-            throw errorWithPath(
-              `Invalid numeric enum value ${globalThis.String(literal)}`,
-              [...path, "enums", index, 1]
-            )
-          }
-          return { type: typeof literal, enum: [literal], title }
-        })
+        const types = representation.enums.map(([title, literal]) => ({
+          type: typeof literal,
+          enum: [literal],
+          title
+        }))
         return types.length === 0 ? { not: {} } : { anyOf: types }
       }
       case "TemplateLiteral":
         return { type: "string", pattern: `^${representation.parts.map(getPartPattern).join("")}$` }
       case "Arrays": {
-        if (representation.rest.length > 1) {
-          throw errorWithPath("Invalid schema representation document", [...path, "rest"])
-        }
         const out: JsonSchema.JsonSchema = { type: "array" }
         let minItems = representation.elements.length
         const prefixItems = representation.elements.map((element, index) => {
@@ -489,6 +478,11 @@ function compileJsonSchema(
           const rest = recur(representation.rest[0], [...path, "rest", 0], dependencies)
           if (Object.keys(rest).length > 0) out.items = rest
           else delete out.items
+        } else if (representation.rest.length > 1) {
+          delete out.maxItems
+          delete out.items
+          out.minItems = minItems + representation.rest.length - 1
+          dependencies.push(false)
         }
         return out
       }
@@ -502,7 +496,7 @@ function compileJsonSchema(
         for (let index = 0; index < representation.propertySignatures.length; index++) {
           const property = representation.propertySignatures[index]
           if (typeof property.name !== "string") {
-            throw errorWithPath("Invalid schema representation document", [
+            throw errorWithPath("Objects property names must be strings", [
               ...path,
               "propertySignatures",
               index,
@@ -574,10 +568,11 @@ function compileJsonSchema(
           }
           for (let index = 0; index < representation.indexSignatures.length; index++) {
             propertyNames.push(
-              recur(
+              getPropertyNameSchema(
                 representation.indexSignatures[index].parameter,
                 [...path, "indexSignatures", index, "parameter"],
-                dependencies
+                dependencies,
+                new Set()
               )
             )
           }
@@ -613,17 +608,49 @@ function compileJsonSchema(
         const types = representation.types.map((type, index) => recur(type, [...path, "types", index], branches))
         dependencies.push(branches)
         if (types.length === 0) return { not: {} }
-        const mode = representation.options?.mode ?? "anyOf"
-        if (mode === "anyOf" && types.length > 1) {
+        if (representation.options?.mode === "oneOf") {
+          pendingOneOf.set(types, [branches, []])
+          return { oneOf: types }
+        }
+        if (types.length > 1) {
           const compacted = compactEnums(types)
           if (compacted !== undefined) return compacted
         }
-        if (mode === "oneOf") pendingOneOf.set(types, [branches, []])
-        return { [mode]: types }
+        // A member that is only an `anyOf` adds no constraints of its own, so its alternatives can be spliced in.
+        return {
+          anyOf: types.flatMap((type) =>
+            Array.isArray(type.anyOf) && Object.keys(type).length === 1 ? type.anyOf : [type]
+          )
+        }
       }
     }
   }
 
+  function getPropertyNameSchema(
+    parameter: SchemaRepresentation.Representation,
+    path: Path,
+    dependencies: Array<Exactness>,
+    seenReferences: ReadonlySet<string>
+  ): JsonSchema.JsonSchema {
+    switch (parameter._tag) {
+      case "Number":
+        return { type: "string", pattern: `^(?:${InternalAST.FINITE_PATTERN}|Infinity|-Infinity|NaN)$` }
+      case "Reference": {
+        if (seenReferences.has(parameter.$ref)) return { type: "string" }
+        return getPropertyNameSchema(
+          references[parameter.$ref],
+          ["references", parameter.$ref],
+          dependencies,
+          new Set(seenReferences).add(parameter.$ref)
+        )
+      }
+      case "Union":
+        return { anyOf: parameter.types.map((type) => getPropertyNameSchema(type, path, dependencies, seenReferences)) }
+      default:
+        return recur(parameter, path, dependencies)
+    }
+  }
+
   function getParameterPatterns(
     parameter: SchemaRepresentation.Representation,
     path: Path,
@@ -631,9 +658,6 @@ function compileJsonSchema(
   ): ReadonlyArray<string> | undefined {
     switch (parameter._tag) {
       case "Reference": {
-        if (!Object.hasOwn(references, parameter.$ref)) {
-          throw errorWithPath(`Invalid reference ${parameter.$ref}`, [...path, "$ref"])
-        }
         compileDefinition(parameter.$ref, path)
         if (seenReferences.has(parameter.$ref)) return undefined
         const next = new Set(seenReferences).add(parameter.$ref)
@@ -671,8 +695,12 @@ function compileJsonSchema(
         }
         return patterns
       }
+      case "Number":
+        return parameter.checks.length === 0
+          ? [`^(?:${InternalAST.FINITE_PATTERN}|Infinity|-Infinity|NaN)$`]
+          : undefined
       default:
-        throw errorWithPath("Invalid schema representation document", path)
+        throw errorWithPath(`Invalid index signature parameter ${parameter._tag}`, path)
     }
   }
 }
@@ -710,12 +738,14 @@ function getPartPattern(part: SchemaRepresentation.Representation): string {
       return InternalAST.STRING_PATTERN
     case "Number":
       return InternalAST.FINITE_PATTERN
+    case "BigInt":
+      return "-?\\d+"
     case "TemplateLiteral":
       return part.parts.map(getPartPattern).join("")
     case "Union":
       return `(?:${part.types.map(getPartPattern).join("|")})`
     default:
-      throw errorWithPath("Invalid schema representation document", [])
+      throw errorWithPath(`Invalid TemplateLiteral part ${part._tag}`, [])
   }
 }
 

package/src/internal/trie.ts

@@ -79,7 +79,6 @@ const makeImpl = <V>(root: Node<V> | undefined): TrieImpl<V> => {
 
 class TrieIterator<in out V, out T> implements IterableIterator<T> {
   stack: Array<[Node<V>, string, boolean]> = []
-  readonly trie: TrieImpl<V>
   readonly f: TraversalMap<string, V, T>
   readonly filter: TraversalFilter<string, V>
 
@@ -88,7 +87,6 @@ class TrieIterator<in out V, out T> implements IterableIterator<T> {
     f: TraversalMap<string, V, T>,
     filter: TraversalFilter<string, V>
   ) {
-    this.trie = trie
     this.f = f
     this.filter = filter
     const root = trie._root !== undefined ? trie._root : undefined
@@ -131,7 +129,7 @@ class TrieIterator<in out V, out T> implements IterableIterator<T> {
   }
 
   [Symbol.iterator](): IterableIterator<T> {
-    return new TrieIterator(this.trie, this.f, this.filter)
+    return this
   }
 }