effect 4.0.0-beta.6 → 4.0.0-beta.62

package/src/internal/hashMap.ts

@@ -12,6 +12,7 @@ import * as Option from "../Option.ts"
 import type { Pipeable } from "../Pipeable.ts"
 import { pipeArguments } from "../Pipeable.ts"
 import { hasProperty } from "../Predicate.ts"
+import * as Result from "../Result.ts"
 import type { NoInfer } from "../Types.ts"
 
 /** @internal */
@@ -83,7 +84,7 @@ function mergeLeaves<K, V>(
   }
 
   const bitmap = bit1 | bit2
-  const children: Array<Node<K, V>> = bit1 < bit2
+  const children: Array<Node<K, V>> = (bit1 >>> 0) < (bit2 >>> 0)
     ? [node1, node2]
     : [node2, node1]
 
@@ -248,7 +249,7 @@ class LeafNode<K, V> extends Node<K, V> {
     }
 
     const bitmap = newBit | existingBit
-    const nodes: Array<Node<K, V>> = newBit < existingBit
+    const nodes: Array<Node<K, V>> = (newBit >>> 0) < (existingBit >>> 0)
       ? [new LeafNode(edit, hash, key, value), this]
       : [this, new LeafNode(edit, hash, key, value)]
 
@@ -1255,14 +1256,14 @@ export const compact = <K, A>(self: HashMap<K, Option.Option<A>>): HashMap<K, A>
 
 /** @internal */
 export const filterMap = dual<
-  <A, K, B>(f: (value: A, key: K) => Option.Option<B>) => (self: HashMap<K, A>) => HashMap<K, B>,
-  <K, A, B>(self: HashMap<K, A>, f: (value: A, key: K) => Option.Option<B>) => HashMap<K, B>
->(2, <K, A, B>(self: HashMap<K, A>, f: (value: A, key: K) => Option.Option<B>): HashMap<K, B> => {
+  <A, K, B, X>(f: (input: A, key: K) => Result.Result<B, X>) => (self: HashMap<K, A>) => HashMap<K, B>,
+  <K, A, B, X>(self: HashMap<K, A>, f: (input: A, key: K) => Result.Result<B, X>) => HashMap<K, B>
+>(2, <K, A, B, X>(self: HashMap<K, A>, f: (input: A, key: K) => Result.Result<B, X>): HashMap<K, B> => {
   let result = empty<K, B>()
   for (const [key, value] of self) {
     const mapped = f(value, key)
-    if (Option.isSome(mapped)) {
-      result = set(result, key, mapped.value)
+    if (Result.isSuccess(mapped)) {
+      result = set(result, key, mapped.success)
     }
   }
   return result
@@ -1270,14 +1271,15 @@ export const filterMap = dual<
 
 /** @internal */
 export const findFirst = dual<
-  <K, A>(predicate: (a: NoInfer<A>, k: K) => boolean) => (self: HashMap<K, A>) => [K, A] | undefined,
-  <K, A>(self: HashMap<K, A>, predicate: (a: A, k: K) => boolean) => [K, A] | undefined
+  <K, A>(predicate: (a: NoInfer<A>, k: K) => boolean) => (self: HashMap<K, A>) => Option.Option<[K, A]>,
+  <K, A>(self: HashMap<K, A>, predicate: (a: A, k: K) => boolean) => Option.Option<[K, A]>
 >(2, <K, A>(self: HashMap<K, A>, predicate: (a: A, k: K) => boolean) => {
   for (const [key, value] of self) {
     if (predicate(value, key)) {
-      return [key, value]
+      return Option.some([key, value])
     }
   }
+  return Option.none()
 })
 
 /** @internal */

package/src/internal/layer.ts

@@ -1,7 +1,7 @@
+import * as Context from "../Context.ts"
 import type { Effect } from "../Effect.ts"
 import { dual } from "../Function.ts"
 import * as Layer from "../Layer.ts"
-import * as ServiceMap from "../ServiceMap.ts"
 import { isEffect } from "./core.ts"
 import * as effect from "./effect.ts"
 
@@ -17,7 +17,7 @@ const provideLayer = <A, E, R, ROut, E2, RIn>(
       options?.local
         ? Layer.buildWithMemoMap(layer, Layer.makeMemoMapUnsafe(), scope)
         : Layer.buildWithScope(layer, scope),
-      (context) => effect.provideServices(self, context)
+      (context) => effect.provideContext(self, context)
     )
   )
 
@@ -43,7 +43,7 @@ export const provide = dual<
         readonly local?: boolean | undefined
       } | undefined
     ): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E | E2, RIn | Exclude<R, ROut>>
-    <R2>(services: ServiceMap.ServiceMap<R2>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, R2>>
+    <R2>(context: Context.Context<R2>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, R2>>
   },
   {
     <A, E, R, const Layers extends [Layer.Any, ...Array<Layer.Any>]>(
@@ -67,7 +67,7 @@ export const provide = dual<
     ): Effect<A, E | E2, RIn | Exclude<R, ROut>>
     <A, E, R, R2>(
       self: Effect<A, E, R>,
-      services: ServiceMap.ServiceMap<R2>
+      context: Context.Context<R2>
     ): Effect<A, E, Exclude<R, R2>>
   }
 >(
@@ -76,13 +76,13 @@ export const provide = dual<
     self: Effect<A, E, R>,
     source:
       | Layer.Layer<ROut, any, any>
-      | ServiceMap.ServiceMap<ROut>
+      | Context.Context<ROut>
       | Array<Layer.Any>,
     options?: {
       readonly local?: boolean | undefined
     } | undefined
   ): Effect<any, any, Exclude<R, ROut>> =>
-    ServiceMap.isServiceMap(source)
-      ? effect.provideServices(self, source)
+    Context.isContext(source)
+      ? effect.provideContext(self, source)
       : provideLayer(self, Array.isArray(source) ? Layer.mergeAll(...source as any) : source, options)
 )

package/src/internal/option.ts

@@ -45,10 +45,17 @@ const SomeProto = Object.assign(Object.create(CommonProto), {
   }
 })
 
+Object.defineProperty(SomeProto, "valueOrUndefined", {
+  get() {
+    return this.value
+  }
+})
+
 const NoneHash = Hash.hash("None")
 const NoneProto = Object.assign(Object.create(CommonProto), {
   _tag: "None",
   _op: "None",
+  valueOrUndefined: undefined,
   [Equal.symbol]<A>(this: Option.None<A>, that: unknown): boolean {
     return isOption(that) && isNone(that)
   },

package/src/internal/random.ts

@@ -0,0 +1,20 @@
+import * as Context from "../Context.ts"
+
+/** @internal */
+export interface Random {
+  nextIntUnsafe(): number
+  nextDoubleUnsafe(): number
+}
+
+/** @internal */
+export const Random: Context.Reference<Random> = Context.Reference<Random>("effect/Random", {
+  defaultValue: () => ({
+    nextIntUnsafe() {
+      return Math.floor(Math.random() * (Number.MAX_SAFE_INTEGER - Number.MIN_SAFE_INTEGER + 1)) +
+        Number.MIN_SAFE_INTEGER
+    },
+    nextDoubleUnsafe() {
+      return Math.random()
+    }
+  })
+})

package/src/internal/rcRef.ts

@@ -1,3 +1,4 @@
+import * as Context from "../Context.ts"
 import * as Duration from "../Duration.ts"
 import * as Effect from "../Effect.ts"
 import * as Exit from "../Exit.ts"
@@ -7,7 +8,6 @@ import { pipeArguments } from "../Pipeable.ts"
 import type * as RcRef from "../RcRef.ts"
 import * as Scope from "../Scope.ts"
 import * as Semaphore from "../Semaphore.ts"
-import * as ServiceMap from "../ServiceMap.ts"
 
 const TypeId = "~effect/RcRef"
 
@@ -50,18 +50,18 @@ class RcRefImpl<A, E> implements RcRef.RcRef<A, E> {
   state: State<A> = stateEmpty
   readonly semaphore = Semaphore.makeUnsafe(1)
   readonly acquire: Effect.Effect<A, E>
-  readonly services: ServiceMap.ServiceMap<never>
+  readonly context: Context.Context<never>
   readonly scope: Scope.Scope
   readonly idleTimeToLive: Duration.Duration | undefined
 
   constructor(
     acquire: Effect.Effect<A, E>,
-    services: ServiceMap.ServiceMap<never>,
+    context: Context.Context<never>,
     scope: Scope.Scope,
     idleTimeToLive: Duration.Duration | undefined
   ) {
     this.acquire = acquire
-    this.services = services
+    this.context = context
     this.scope = scope
     this.idleTimeToLive = idleTimeToLive
   }
@@ -70,16 +70,16 @@ class RcRefImpl<A, E> implements RcRef.RcRef<A, E> {
 /** @internal */
 export const make = <A, E, R>(options: {
   readonly acquire: Effect.Effect<A, E, R>
-  readonly idleTimeToLive?: Duration.DurationInput | undefined
+  readonly idleTimeToLive?: Duration.Input | undefined
 }) =>
   Effect.withFiber<RcRef.RcRef<A, E>, never, R | Scope.Scope>((fiber) => {
-    const services = fiber.services as ServiceMap.ServiceMap<R | Scope.Scope>
-    const scope = ServiceMap.get(services, Scope.Scope)
+    const context = fiber.context as Context.Context<R | Scope.Scope>
+    const scope = Context.get(context, Scope.Scope)
     const ref = new RcRefImpl<A, E>(
       options.acquire as Effect.Effect<A, E>,
-      services,
+      context,
       scope,
-      options.idleTimeToLive ? Duration.fromDurationInputUnsafe(options.idleTimeToLive) : undefined
+      options.idleTimeToLive ? Duration.fromInputUnsafe(options.idleTimeToLive) : undefined
     )
     return Effect.as(
       Scope.addFinalizerExit(scope, () => {
@@ -108,9 +108,9 @@ const getState = <A, E>(self: RcRefImpl<A, E>) =>
       case "Empty": {
         const scope = Scope.makeUnsafe()
         return self.semaphore.withPermits(1)(
-          restore(Effect.provideServices(
+          restore(Effect.provideContext(
             self.acquire as Effect.Effect<A, E>,
-            ServiceMap.add(self.services, Scope.Scope, scope)
+            Context.add(self.context, Scope.Scope, scope)
           )).pipe(Effect.map((value) => {
             const state: State.Acquired<A> = {
               _tag: "Acquired",
@@ -160,7 +160,7 @@ export const get = Effect.fnUntraced(function*<A, E>(
       Effect.ensuring(Effect.sync(() => {
         state.fiber = undefined
       })),
-      Effect.runForkWith(self.services),
+      Effect.runForkWith(self.context),
       Fiber.runIn(self.scope)
     )
     return Effect.void

package/src/internal/references.ts

@@ -0,0 +1,72 @@
+import * as Context from "../Context.ts"
+import type { ErrorReporter } from "../ErrorReporter.ts"
+import { constTrue, constUndefined } from "../Function.ts"
+import type { LogLevel, Severity } from "../LogLevel.ts"
+import type { ReadonlyRecord } from "../Record.ts"
+import type { StackFrame } from "../References.ts"
+import type { SpanLink } from "../Tracer.ts"
+
+/** @internal */
+export const CurrentConcurrency = Context.Reference<"unbounded" | number>("effect/References/CurrentConcurrency", {
+  defaultValue: () => "unbounded"
+})
+
+/** @internal */
+export const CurrentErrorReporters = Context.Reference<ReadonlySet<ErrorReporter>>(
+  "effect/ErrorReporter/CurrentErrorReporters",
+  { defaultValue: () => new Set() }
+)
+
+/** @internal */
+export const CurrentStackFrame = Context.Reference<StackFrame | undefined>("effect/References/CurrentStackFrame", {
+  defaultValue: constUndefined
+})
+
+/** @internal */
+export const TracerEnabled = Context.Reference<boolean>("effect/References/TracerEnabled", {
+  defaultValue: constTrue
+})
+
+/** @internal */
+export const TracerTimingEnabled = Context.Reference<boolean>("effect/References/TracerTimingEnabled", {
+  defaultValue: constTrue
+})
+
+/** @internal */
+export const TracerSpanAnnotations = Context.Reference<ReadonlyRecord<string, unknown>>(
+  "effect/References/TracerSpanAnnotations",
+  { defaultValue: () => ({}) }
+)
+
+/** @internal */
+export const TracerSpanLinks = Context.Reference<ReadonlyArray<SpanLink>>("effect/References/TracerSpanLinks", {
+  defaultValue: () => []
+})
+
+/** @internal */
+export const CurrentLogAnnotations = Context.Reference<ReadonlyRecord<string, unknown>>(
+  "effect/References/CurrentLogAnnotations",
+  { defaultValue: () => ({}) }
+)
+
+/** @internal */
+export const CurrentLogLevel: Context.Reference<Severity> = Context.Reference<Severity>(
+  "effect/References/CurrentLogLevel",
+  { defaultValue: () => "Info" }
+)
+
+/** @internal */
+export const MinimumLogLevel = Context.Reference<
+  LogLevel
+>("effect/References/MinimumLogLevel", { defaultValue: () => "Info" })
+
+/** @internal */
+export const UnhandledLogLevel: Context.Reference<Severity | undefined> = Context.Reference(
+  "effect/References/UnhandledLogLevel",
+  { defaultValue: (): Severity | undefined => "Error" }
+)
+
+/** @internal */
+export const CurrentLogSpans = Context.Reference<
+  ReadonlyArray<[label: string, timestamp: number]>
+>("effect/References/CurrentLogSpans", { defaultValue: () => [] })

package/src/internal/request.ts

@@ -1,4 +1,5 @@
 import type { NonEmptyArray } from "../Array.ts"
+import * as Context from "../Context.ts"
 import type { Effect } from "../Effect.ts"
 import type { Exit } from "../Exit.ts"
 import type { Fiber } from "../Fiber.ts"
@@ -7,7 +8,6 @@ import type * as Request from "../Request.ts"
 import { makeEntry } from "../Request.ts"
 import type { RequestResolver } from "../RequestResolver.ts"
 import { Scheduler } from "../Scheduler.ts"
-import * as ServiceMap from "../ServiceMap.ts"
 import { exitDie, isEffect } from "./core.ts"
 import * as effect from "./effect.ts"
 
@@ -57,12 +57,12 @@ export const requestUnsafe = <A extends Request.Any>(
   options: {
     readonly resolver: RequestResolver<A>
     readonly onExit: (exit: Exit<Request.Success<A>, Request.Error<A>>) => void
-    readonly services: ServiceMap.ServiceMap<never>
+    readonly context: Context.Context<never>
   }
 ): () => void => {
   const entry = addEntry(options.resolver, self, options.onExit, {
-    services: options.services,
-    currentScheduler: ServiceMap.get(options.services, Scheduler)
+    context: options.context,
+    currentScheduler: Context.get(options.context, Scheduler)
   })
   return () => removeEntryUnsafe(options.resolver, entry)
 }
@@ -86,7 +86,7 @@ const addEntry = <A extends Request.Any>(
   request: A,
   resume: (exit: Exit<any, any>) => void,
   fiber: {
-    readonly services: ServiceMap.ServiceMap<never>
+    readonly context: Context.Context<never>
     readonly currentScheduler: Scheduler
     readonly id?: number
   }
@@ -100,7 +100,7 @@ const addEntry = <A extends Request.Any>(
   let completed = false
   const entry = makeEntry({
     request,
-    services: fiber.services as any,
+    context: fiber.context as any,
     uninterruptible: false,
     completeUnsafe(effect) {
       if (completed) return
@@ -159,7 +159,7 @@ const addEntry = <A extends Request.Any>(
       batch = newBatch
     }
     batchMap.set(key, batch)
-    batch.fiber = effect.runFork(batch.delayEffect, { scheduler: fiber.currentScheduler })
+    batch.fiber = effect.runForkWith(fiber.context)(batch.delayEffect, { scheduler: fiber.currentScheduler })
   }
 
   batch.entrySet.add(entry)
@@ -167,7 +167,7 @@ const addEntry = <A extends Request.Any>(
   if (batch.resolver.collectWhile(batch.entries)) return entry
 
   batch.fiber!.interruptUnsafe(fiber.id)
-  batch.fiber = effect.runFork(runBatch(batch), { scheduler: fiber.currentScheduler })
+  batch.fiber = effect.runForkWith(fiber.context)(runBatch(batch), { scheduler: fiber.currentScheduler })
   return entry
 }
 

package/src/internal/schedule.ts

@@ -226,7 +226,9 @@ export const buildFromOptions = <Input>(options: {
   until?: ((input: Input) => boolean | Effect<boolean, any, any>) | undefined
   times?: number | undefined
 }) => {
-  let schedule: Schedule.Schedule<any, Input, any, any> = options.schedule ?? passthroughForever
+  let schedule: Schedule.Schedule<any, Input, any, any> = options.schedule
+    ? Schedule.passthrough(options.schedule)
+    : passthroughForever
   if (options.while) {
     schedule = Schedule.while(schedule, ({ input }) => {
       const applied = options.while!(input)

package/src/internal/schema/annotations.ts

@@ -26,6 +26,8 @@ export const resolveBrands = resolveAt<ReadonlyArray<string>>("brands")
 
 /** @internal */
 export const getExpected = memoize((ast: AST.AST): string => {
+  const identifier = resolveIdentifier(ast)
+  if (typeof identifier === "string") return identifier
   return ast.getExpected(getExpected)
 })
 

package/src/internal/schema/representation.ts

@@ -1,4 +1,5 @@
 import * as Arr from "../../Array.ts"
+import * as Equal from "../../Equal.ts"
 import { format } from "../../Formatter.ts"
 import { escapeToken } from "../../JsonPointer.ts"
 import type * as JsonSchema from "../../JsonSchema.ts"
@@ -10,7 +11,6 @@ import * as AST from "../../SchemaAST.ts"
 import type * as SchemaRepresentation from "../../SchemaRepresentation.ts"
 import * as InternalAnnotations from "./annotations.ts"
 import * as InternalSchema from "./schema.ts"
-import * as InternalToCodec from "./to-codec.ts"
 
 /** @internal */
 export function fromAST(ast: AST.AST): SchemaRepresentation.Document {
@@ -24,83 +24,16 @@ export function fromASTs(asts: readonly [AST.AST, ...Array<AST.AST>]): SchemaRep
 
   const referenceMap = new Map<AST.AST, string>()
   const uniqueReferences = new Set<string>()
-  const usedReferences = new Set<string>()
+  const visiting = new Set<AST.AST>()
 
   const schemas = Arr.map(asts, (ast) => recur(ast))
 
   return {
-    representations: Arr.map(schemas, compact),
-    references: Rec.map(Rec.filter(references, (_, k) => !isCompactable(k)), compact)
+    representations: schemas,
+    references
   }
 
-  function isCompactable($ref: string): boolean {
-    return !usedReferences.has($ref)
-  }
-
-  function compact(s: SchemaRepresentation.Representation): SchemaRepresentation.Representation {
-    switch (s._tag) {
-      default:
-        return s
-      case "Declaration":
-        return {
-          ...s,
-          typeParameters: s.typeParameters.map(compact),
-          encodedSchema: compact(s.encodedSchema)
-        }
-      case "Reference": {
-        if (isCompactable(s.$ref)) {
-          return compact(references[s.$ref])
-        }
-        return s
-      }
-      case "Suspend":
-        return { ...s, thunk: compact(s.thunk) }
-      case "String":
-        return {
-          ...s,
-          ...(s.contentSchema ? { contentSchema: compact(s.contentSchema) } : undefined)
-        }
-      case "TemplateLiteral":
-        return { ...s, parts: s.parts.map(compact) }
-      case "Arrays":
-        return {
-          ...s,
-          elements: s.elements.map((e) => ({ ...e, type: compact(e.type) })),
-          rest: s.rest.map(compact)
-        }
-      case "Objects":
-        return {
-          ...s,
-          checks: s.checks.map(compactCheck),
-          propertySignatures: s.propertySignatures.map((ps) => ({ ...ps, type: compact(ps.type) })),
-          indexSignatures: s.indexSignatures.map((is) => ({
-            ...is,
-            parameter: compact(is.parameter),
-            type: compact(is.type)
-          }))
-        }
-      case "Union":
-        return { ...s, types: s.types.map(compact) }
-    }
-  }
-
-  function compactCheck<M extends SchemaRepresentation.Meta>(
-    check: SchemaRepresentation.Check<M>
-  ): SchemaRepresentation.Check<M> {
-    switch (check._tag) {
-      case "Filter":
-        return {
-          ...check,
-          meta: check.meta._tag === "isPropertyNames"
-            ? { _tag: "isPropertyNames", propertyNames: compact(check.meta.propertyNames) } as M
-            : check.meta
-        }
-      case "FilterGroup":
-        return { ...check, checks: Arr.map(check.checks, compactCheck) }
-    }
-  }
-
-  function gen(prefix: string = "_"): string {
+  function gen(prefix: string): string {
     let candidate = prefix
     let suffix = 0
 
@@ -115,32 +48,51 @@ export function fromASTs(asts: readonly [AST.AST, ...Array<AST.AST>]): SchemaRep
   function recur(ast: AST.AST, prefix?: string): SchemaRepresentation.Representation {
     const found = referenceMap.get(ast)
     if (found !== undefined) {
-      usedReferences.add(found)
       return { _tag: "Reference", $ref: found }
     }
 
-    const last = getLastEncoding(ast)
+    const last = AST.getLastEncoding(ast)
+    const identifier = InternalAnnotations.resolveIdentifier(ast) ?? prefix
 
-    if (ast === last) {
-      const reference = ast._tag === "Declaration"
-        ? gen(ast._tag)
-        : gen(InternalAnnotations.resolveIdentifier(ast) ?? prefix ?? `${ast._tag}_`)
-
-      const encodedSchemaPrefix = ast._tag === "Declaration"
-        ? InternalAnnotations.resolveIdentifier(ast) ?? prefix
-        : prefix
+    if (ast !== last) {
+      return recur(last, identifier)
+    }
 
+    // Has identifier → always create reference
+    if (identifier !== undefined) {
+      const reference = gen(identifier)
       referenceMap.set(ast, reference)
-      const out = on(ast, encodedSchemaPrefix)
+      const out = on(ast)
+      const found = references[identifier]
+      // Reuse existing references when duplicate identifiers have the same representation
+      if (found !== undefined && Equal.equals(out, found)) {
+        referenceMap.set(ast, identifier)
+        return { _tag: "Reference", $ref: identifier }
+      }
       references[reference] = out
       return { _tag: "Reference", $ref: reference }
-    } else {
-      return recur(last, InternalAnnotations.resolveIdentifier(ast) ?? prefix)
     }
-  }
 
-  function getLastEncoding(ast: AST.AST): AST.AST {
-    return ast.encoding ? ast.encoding[ast.encoding.length - 1].to : ast
+    // Recursion detected → create reference
+    if (visiting.has(ast)) {
+      const reference = gen(`${ast._tag}_`)
+      referenceMap.set(ast, reference)
+      return { _tag: "Reference", $ref: reference }
+    }
+
+    // Normal case → inline
+    visiting.add(ast)
+    const out = on(ast)
+    visiting.delete(ast)
+
+    // A descendant triggered reference creation (recursion)
+    const ref = referenceMap.get(ast)
+    if (ref !== undefined) {
+      references[ref] = out
+      return { _tag: "Reference", $ref: ref }
+    }
+
+    return out
   }
 
   function getEncodedSchema(last: AST.Declaration): AST.AST {
@@ -153,12 +105,12 @@ export function fromASTs(asts: readonly [AST.AST, ...Array<AST.AST>]): SchemaRep
     return AST.null
   }
 
-  function on(last: AST.AST, encodedSchemaPrefix?: string): SchemaRepresentation.Representation {
+  function on(last: AST.AST): SchemaRepresentation.Representation {
     const annotations = fromASTAnnotations(last.annotations)
     switch (last._tag) {
       case "Declaration": {
         // this must be executed before transforming the type parameters
-        const encodedSchema = recur(getEncodedSchema(last), encodedSchemaPrefix)
+        const encodedSchema = recur(getEncodedSchema(last))
         return {
           _tag: "Declaration",
           typeParameters: last.typeParameters.map((ast) => recur(ast)),
@@ -228,7 +180,7 @@ export function fromASTs(asts: readonly [AST.AST, ...Array<AST.AST>]): SchemaRep
         return {
           _tag: last._tag,
           elements: last.elements.map((e) => {
-            const last = getLastEncoding(e)
+            const last = AST.getLastEncoding(e)
             return {
               isOptional: AST.isOptional(last),
               type: recur(e),
@@ -243,7 +195,7 @@ export function fromASTs(asts: readonly [AST.AST, ...Array<AST.AST>]): SchemaRep
         return {
           _tag: last._tag,
           propertySignatures: last.propertySignatures.map((ps) => {
-            const last = getLastEncoding(ps.type)
+            const last = AST.getLastEncoding(ps.type)
             return {
               name: ps.name,
               type: recur(ps.type),
@@ -260,7 +212,7 @@ export function fromASTs(asts: readonly [AST.AST, ...Array<AST.AST>]): SchemaRep
           ...annotations
         }
       case "Union": {
-        const types = InternalToCodec.jsonReorder(last.types)
+        const types = InternalSchema.jsonReorder(last.types)
         return {
           _tag: last._tag,
           types: types.map((ast) => recur(ast)),
@@ -322,6 +274,7 @@ export function fromASTs(asts: readonly [AST.AST, ...Array<AST.AST>]): SchemaRep
 export const fromASTBlacklist: Set<string> = new Set([
   // `expected` is preserved because is useful to generate descriptions in JSON Schemas
   "~structural",
+  "~sentinels",
   "meta",
   "toArbitrary",
   "toArbitraryConstraint",
@@ -394,11 +347,11 @@ export function toJsonSchemaMultiDocument(
   function on(schema: SchemaRepresentation.Representation): JsonSchema.JsonSchema {
     switch (schema._tag) {
       case "Any":
-        return {}
       case "Unknown":
+      case "ObjectKeyword":
+        return {}
       case "Void":
       case "Undefined":
-      case "ObjectKeyword":
         return { type: "null" }
       case "BigInt":
         return {
@@ -547,10 +500,14 @@ export function toJsonSchemaMultiDocument(
         }
 
         out.additionalProperties = additionalProperties
-        const patternProperties: Record<string, JsonSchema.JsonSchema> = {}
+        const patternProperties: Record<string, JsonSchema.JsonSchema | false> = {}
         // Handle index signatures
         for (const is of schema.indexSignatures) {
-          const type = recur(is.type)
+          let type: JsonSchema.JsonSchema | false = recur(is.type)
+          // Collapse unannotated Never ({ not: {} }) to false, but keep annotated schemas as objects.
+          if (Object.keys(type).length === 1 && "not" in type) {
+            type = false
+          }
           const patterns = getParameterPatterns(is.parameter)
           if (patterns.length > 0) {
             for (const pattern of patterns) {
@@ -576,11 +533,39 @@ export function toJsonSchemaMultiDocument(
           // anyOf MUST be a non-empty array
           return { not: {} }
         }
+        if (types.length > 1) {
+          const compacted = compactEnums(types)
+          if (compacted) return compacted
+        }
         return schema.mode === "anyOf" ? { anyOf: types } : { oneOf: types }
       }
     }
   }
 
+  // Collapses [{type:"string",enum:["a"]},{type:"string",enum:["b"]}] into {type:"string",enum:["a","b"]}.
+  // Returns undefined if members have different types, extra keys (e.g. title), or empty enums.
+  function compactEnums(
+    types: ReadonlyArray<JsonSchema.JsonSchema>
+  ): JsonSchema.JsonSchema | undefined {
+    let sharedType: string | undefined
+    const values: Array<unknown> = []
+    for (const t of types) {
+      const keys = Object.keys(t)
+      if (keys.length !== 2 || t.type === undefined || !Array.isArray(t.enum) || t.enum.length === 0) {
+        return undefined
+      }
+      if (sharedType === undefined) {
+        sharedType = t.type as string
+      } else if (t.type !== sharedType) {
+        return undefined
+      }
+      for (const v of t.enum) {
+        values.push(v)
+      }
+    }
+    return { type: sharedType, enum: values }
+  }
+
   function collectJsonSchemaAnnotations(
     annotations: Schema.Annotations.Annotations | undefined
   ): JsonSchema.JsonSchema | undefined {