effect 2.4.0 → 2.4.2

package/src/Logger.ts

@@ -2,6 +2,7 @@
  * @since 2.0.0
  */
 import type * as Cause from "./Cause.js"
+import type { DurationInput } from "./Duration.js"
 import type { Effect } from "./Effect.js"
 import type * as FiberId from "./FiberId.js"
 import type * as FiberRefs from "./FiberRefs.js"
@@ -158,6 +159,39 @@ export const map: {
   ): Logger<Message, Output2>
 } = internal.map
 
+/**
+ * @since 2.0.0
+ * @category mapping
+ * @example
+ * import { Console, Effect, Logger } from "effect";
+ *
+ * const LoggerLive = Logger.replaceScoped(
+ *   Logger.defaultLogger,
+ *   Logger.logfmtLogger.pipe(
+ *     Logger.batched("500 millis", (messages) =>
+ *       Console.log("BATCH", messages.join("\n"))
+ *     )
+ *   )
+ * );
+ *
+ * Effect.gen(function* (_) {
+ *   yield* _(Effect.log("one"));
+ *   yield* _(Effect.log("two"));
+ *   yield* _(Effect.log("three"));
+ * }).pipe(Effect.provide(LoggerLive), Effect.runFork);
+ */
+export const batched: {
+  <Output, R>(
+    window: DurationInput,
+    f: (messages: Array<Types.NoInfer<Output>>) => Effect<void, never, R>
+  ): <Message>(self: Logger<Message, Output>) => Effect<Logger<Message, void>, never, R | Scope>
+  <Message, Output, R>(
+    self: Logger<Message, Output>,
+    window: DurationInput,
+    f: (messages: Array<Types.NoInfer<Output>>) => Effect<void, never, R>
+  ): Effect<Logger<Message, void>, never, Scope | R>
+} = fiberRuntime.batchedLogger
+
 /**
  * A logger that does nothing in response to logging events.
  *
@@ -298,6 +332,12 @@ export const zipRight: {
  */
 export const defaultLogger: Logger<unknown, void> = fiberRuntime.defaultLogger
 
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const jsonLogger: Logger<unknown, string> = internal.jsonLogger
+
 /**
  * @since 2.0.0
  * @category constructors
@@ -310,20 +350,57 @@ export const logfmtLogger: Logger<unknown, string> = internal.logfmtLogger
  */
 export const stringLogger: Logger<unknown, string> = internal.stringLogger
 
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const structuredLogger: Logger<
+  unknown,
+  {
+    readonly logLevel: string
+    readonly fiberId: string
+    readonly timestamp: string
+    readonly message: unknown
+    readonly cause: string | undefined
+    readonly annotations: Record<string, unknown>
+    readonly spans: Record<string, number>
+  }
+> = internal.structuredLogger
+
 /**
  * @since 2.0.0
  * @category constructors
  */
 export const tracerLogger: Logger<unknown, void> = fiberRuntime.tracerLogger
 
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const json: Layer.Layer<never> = replace(fiberRuntime.defaultLogger, fiberRuntime.jsonLogger)
+
 /**
  * @since 2.0.0
  * @category constructors
  */
 export const logFmt: Layer.Layer<never> = replace(fiberRuntime.defaultLogger, fiberRuntime.logFmtLogger)
 
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const structured: Layer.Layer<never> = replace(fiberRuntime.defaultLogger, fiberRuntime.structuredLogger)
+
 /**
  * @since 2.0.0
  * @category context
  */
 export const minimumLogLevel: (level: LogLevel.LogLevel) => Layer.Layer<never> = circular.minimumLogLevel
+
+/**
+ * Returns `true` if the specified value is a `Logger`, otherwise returns `false`.
+ *
+ * @since 1.0.0
+ * @category guards
+ */
+export const isLogger: (u: unknown) => u is Logger<unknown, unknown> = internal.isLogger

package/src/Option.ts

@@ -14,7 +14,7 @@ import type { Order } from "./Order.js"
 import * as order from "./Order.js"
 import type { Pipeable } from "./Pipeable.js"
 import type { Predicate, Refinement } from "./Predicate.js"
-import type { Covariant, NoInfer } from "./Types.js"
+import type { Covariant, NoInfer, NotFunction } from "./Types.js"
 import type * as Unify from "./Unify.js"
 import * as Gen from "./Utils.js"
 
@@ -75,6 +75,17 @@ export interface OptionUnify<A extends { [Unify.typeSymbol]?: any }> {
   Option?: () => A[Unify.typeSymbol] extends Option<infer A0> | infer _ ? Option<A0> : never
 }
 
+/**
+ * @since 2.0.0
+ */
+export declare namespace Option {
+  /**
+   * @since 2.0.0
+   * @category type-level
+   */
+  export type Value<T extends Option<any>> = [T] extends [Option<infer _A>] ? _A : never
+}
+
 /**
  * @category models
  * @since 2.0.0
@@ -649,11 +660,11 @@ export const andThen: {
   <A, B>(f: (a: A) => Option<B>): (self: Option<A>) => Option<B>
   <B>(f: Option<B>): <A>(self: Option<A>) => Option<B>
   <A, B>(f: (a: A) => B): (self: Option<A>) => Option<B>
-  <B>(f: B): <A>(self: Option<A>) => Option<B>
+  <B>(f: NotFunction<B>): <A>(self: Option<A>) => Option<B>
   <A, B>(self: Option<A>, f: (a: A) => Option<B>): Option<B>
   <A, B>(self: Option<A>, f: Option<B>): Option<B>
   <A, B>(self: Option<A>, f: (a: A) => B): Option<B>
-  <A, B>(self: Option<A>, f: B): Option<B>
+  <A, B>(self: Option<A>, f: NotFunction<B>): Option<B>
 } = dual(
   2,
   <A, B>(self: Option<A>, f: (a: A) => Option<B> | Option<B>): Option<B> =>

package/src/Predicate.ts

@@ -53,6 +53,43 @@ export const mapInput: {
   <A, B>(self: Predicate<A>, f: (b: B) => A): Predicate<B>
 } = dual(2, <A, B>(self: Predicate<A>, f: (b: B) => A): Predicate<B> => (b) => self(f(b)))
 
+/**
+ * Tests if a value is a `Set`.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { isSet } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isSet(new Set([1, 2])), true)
+ * assert.deepStrictEqual(isSet(new Set()), true)
+ * assert.deepStrictEqual(isSet({}), false)
+ * assert.deepStrictEqual(isSet(null), false)
+ * assert.deepStrictEqual(isSet(undefined), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+export const isSet = (input: unknown): input is Set<unknown> => input instanceof Set
+
+/**
+ * Tests if a value is a `Map`.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { isMap } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isMap(new Map()), true)
+ * assert.deepStrictEqual(isMap({}), false)
+ * assert.deepStrictEqual(isMap(null), false)
+ * assert.deepStrictEqual(isMap(undefined), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+export const isMap = (input: unknown): input is Map<unknown, unknown> => input instanceof Map
+
 /**
  * Tests if a value is a `string`.
  *
@@ -192,7 +229,7 @@ export const isUndefined = (input: unknown): input is undefined => input === und
 export const isNotUndefined = <A>(input: A): input is Exclude<A, undefined> => input !== undefined
 
 /**
- * Tests if a value is `undefined`.
+ * Tests if a value is `null`.
  *
  * @param input - The value to test.
  *
@@ -210,7 +247,7 @@ export const isNotUndefined = <A>(input: A): input is Exclude<A, undefined> => i
 export const isNull = (input: unknown): input is null => input === null
 
 /**
- * Tests if a value is not `undefined`.
+ * Tests if a value is not `null`.
  *
  * @param input - The value to test.
  *

package/src/Request.ts

@@ -57,7 +57,7 @@ export declare namespace Request {
    * @category models
    */
   export interface Constructor<R extends Request<any, any>, T extends keyof R = never> {
-    (args: Omit<R, T | keyof (Request.Variance<Request.Error<R>, Request.Success<R>>)>): R
+    (args: Omit<R, T | keyof (Request.Variance<Request.Success<R>, Request.Error<R>>)>): R
   }
 
   /**
@@ -127,17 +127,17 @@ export const tagged: <R extends Request<any, any> & { _tag: string }>(
  * @example
  * import * as Request from "effect/Request"
  *
- * type Error = never
  * type Success = string
+ * type Error = never
  *
- * class MyRequest extends Request.Class<Error, Success, {
+ * class MyRequest extends Request.Class<Success, Error, {
  *   readonly id: string
  * }> {}
  *
  * @since 2.0.0
  * @category constructors
  */
-export const Class: new<Error, Success, A extends Record<string, any>>(
+export const Class: new<Success, Error, A extends Record<string, any>>(
   args: Types.Equals<Omit<A, keyof Request<unknown, unknown>>, {}> extends true ? void
     : { readonly [P in keyof A as P extends keyof Request<unknown, unknown> ? never : P]: A[P] }
 ) => Request<Success, Error> & Readonly<A> = internal.Class as any
@@ -148,10 +148,10 @@ export const Class: new<Error, Success, A extends Record<string, any>>(
  * @example
  * import * as Request from "effect/Request"
  *
- * type Error = never
  * type Success = string
+ * type Error = never
  *
- * class MyRequest extends Request.TaggedClass("MyRequest")<Error, Success, {
+ * class MyRequest extends Request.TaggedClass("MyRequest")<Success, Error, {
  *   readonly name: string
  * }> {}
  *
@@ -160,7 +160,7 @@ export const Class: new<Error, Success, A extends Record<string, any>>(
  */
 export const TaggedClass: <Tag extends string>(
   tag: Tag
-) => new<Error, Success, A extends Record<string, any>>(
+) => new<Success, Error, A extends Record<string, any>>(
   args: Types.Equals<Omit<A, keyof Request<unknown, unknown>>, {}> extends true ? void
     : { readonly [P in keyof A as P extends "_tag" | keyof Request<unknown, unknown> ? never : P]: A[P] }
 ) => Request<Success, Error> & Readonly<A> & { readonly _tag: Tag } = internal.TaggedClass as any

package/src/STM.ts

@@ -103,7 +103,7 @@ export interface STMTypeLambda extends TypeLambda {
  * @category models
  */
 declare module "./Context.js" {
-  interface Tag<Identifier, Service> extends STM<Service, never, Identifier> {}
+  interface Tag<Id, Value> extends STM<Value, never, Id> {}
 }
 
 /**

package/src/SortedSet.ts

@@ -2,6 +2,7 @@
  * @since 2.0.0
  */
 import * as Equal from "./Equal.js"
+import type * as Equivalence from "./Equivalence.js"
 import * as Dual from "./Function.js"
 import { pipe } from "./Function.js"
 import * as Hash from "./Hash.js"
@@ -381,3 +382,9 @@ export const union: {
  * @category getters
  */
 export const values = <A>(self: SortedSet<A>): IterableIterator<A> => RBT.keys(self.keyTree)
+
+/**
+ * @since 2.0.0
+ * @category equivalence
+ */
+export const getEquivalence = <A>(): Equivalence.Equivalence<SortedSet<A>> => (a, b) => isSubset(a, b) && isSubset(b, a)

package/src/Struct.ts

@@ -7,6 +7,7 @@
 import * as Equivalence from "./Equivalence.js"
 import { dual } from "./Function.js"
 import * as order from "./Order.js"
+import * as Predicate from "./Predicate.js"
 import type { MatchRecord, Simplify } from "./Types.js"
 
 /**
@@ -17,23 +18,32 @@ import type { MatchRecord, Simplify } from "./Types.js"
  * import { pipe } from "effect/Function"
  *
  * assert.deepStrictEqual(pipe({ a: "a", b: 1, c: true }, pick("a", "b")), { a: "a", b: 1 })
+ * assert.deepStrictEqual(pick({ a: "a", b: 1, c: true }, "a", "b"), { a: "a", b: 1 })
  *
  * @since 2.0.0
  */
-export const pick = <Keys extends Array<PropertyKey>>(
-  ...keys: Keys
-) =>
-<S extends { [K in Keys[number]]?: any }>(
-  s: S
-): MatchRecord<S, { [K in Keys[number]]?: S[K] }, Simplify<Pick<S, Keys[number]>>> => {
-  const out: any = {}
-  for (const k of keys) {
-    if (k in s) {
-      out[k] = (s as any)[k]
+export const pick: {
+  <Keys extends Array<PropertyKey>>(
+    ...keys: Keys
+  ): <S extends { [K in Keys[number]]?: any }>(
+    s: S
+  ) => MatchRecord<S, { [K in Keys[number]]?: S[K] }, Simplify<Pick<S, Keys[number]>>>
+  <S extends object, Keys extends Array<keyof S>>(
+    s: S,
+    ...keys: Keys
+  ): MatchRecord<S, { [K in Keys[number]]?: S[K] }, Simplify<Pick<S, Keys[number]>>>
+} = dual(
+  (args) => Predicate.isObject(args[0]),
+  <S extends object, Keys extends Array<keyof S>>(s: S, ...keys: Keys) => {
+    const out: any = {}
+    for (const k of keys) {
+      if (k in s) {
+        out[k] = (s as any)[k]
+      }
     }
+    return out
   }
-  return out
-}
+)
 
 /**
  * Create a new object by omitting properties of an existing object.
@@ -43,19 +53,28 @@ export const pick = <Keys extends Array<PropertyKey>>(
  * import { pipe } from "effect/Function"
  *
  * assert.deepStrictEqual(pipe({ a: "a", b: 1, c: true }, omit("c")), { a: "a", b: 1 })
+ * assert.deepStrictEqual(omit({ a: "a", b: 1, c: true }, "c"), { a: "a", b: 1 })
  *
  * @since 2.0.0
  */
-export const omit = <Keys extends Array<PropertyKey>>(
-  ...keys: Keys
-) =>
-<S extends { [K in Keys[number]]?: any }>(s: S): Simplify<Omit<S, Keys[number]>> => {
-  const out: any = { ...s }
-  for (const k of keys) {
-    delete out[k]
+export const omit: {
+  <Keys extends Array<PropertyKey>>(
+    ...keys: Keys
+  ): <S extends { [K in Keys[number]]?: any }>(s: S) => Simplify<Omit<S, Keys[number]>>
+  <S extends object, Keys extends Array<keyof S>>(
+    s: S,
+    ...keys: Keys
+  ): Simplify<Omit<S, Keys[number]>>
+} = dual(
+  (args) => Predicate.isObject(args[0]),
+  <S extends object, Keys extends Array<keyof S>>(s: S, ...keys: Keys) => {
+    const out: any = { ...s }
+    for (const k of keys) {
+      delete out[k]
+    }
+    return out
   }
-  return out
-}
+)
 
 /**
  * Given a struct of `Equivalence`s returns a new `Equivalence` that compares values of a struct

package/src/Types.ts

@@ -190,3 +190,8 @@ export type Contravariant<A> = (_: A) => void
  * @since 2.0.0
  */
 export type MatchRecord<S, onTrue, onFalse> = {} extends S ? onTrue : onFalse
+
+/**
+ * @since 2.0.0
+ */
+export type NotFunction<T> = T extends Function ? never : T

package/src/internal/core-effect.ts

@@ -1871,10 +1871,10 @@ export const serviceFunction = <T extends Effect.Effect<any, any, any>, Args ext
 export const serviceFunctions = <S, SE, SR>(
   getService: Effect.Effect<S, SE, SR>
 ): {
-  [k in { [k in keyof S]: S[k] extends (...args: Array<any>) => Effect.Effect<any, any, any> ? k : never }[keyof S]]:
-    S[k] extends (...args: infer Args) => Effect.Effect<infer A, infer E, infer R>
-      ? (...args: Args) => Effect.Effect<A, E | SE, R | SR>
-      : never
+  [k in keyof S as S[k] extends (...args: Array<any>) => Effect.Effect<any, any, any> ? k : never]: S[k] extends
+    (...args: infer Args) => Effect.Effect<infer A, infer E, infer R>
+    ? (...args: Args) => Effect.Effect<A, E | SE, R | SR>
+    : never
 } =>
   new Proxy({} as any, {
     get(_target: any, prop: any, _receiver) {
@@ -1899,10 +1899,10 @@ export const serviceConstants = <S, SE, SR>(
 /** @internal */
 export const serviceMembers = <S, SE, SR>(getService: Effect.Effect<S, SE, SR>): {
   functions: {
-    [k in { [k in keyof S]: S[k] extends (...args: Array<any>) => Effect.Effect<any, any, any> ? k : never }[keyof S]]:
-      S[k] extends (...args: infer Args) => Effect.Effect<infer A, infer E, infer R>
-        ? (...args: Args) => Effect.Effect<A, E | SE, R | SR>
-        : never
+    [k in keyof S as S[k] extends (...args: Array<any>) => Effect.Effect<any, any, any> ? k : never]: S[k] extends
+      (...args: infer Args) => Effect.Effect<infer A, infer E, infer R>
+      ? (...args: Args) => Effect.Effect<A, E | SE, R | SR>
+      : never
   }
   constants: {
     [k in { [k in keyof S]: k }[keyof S]]: S[k] extends Effect.Effect<infer A, infer E, infer R> ?
@@ -1910,7 +1910,7 @@ export const serviceMembers = <S, SE, SR>(getService: Effect.Effect<S, SE, SR>):
       Effect.Effect<S[k], SE, SR>
   }
 } => ({
-  functions: serviceFunctions(getService),
+  functions: serviceFunctions(getService) as any,
   constants: serviceConstants(getService)
 })
 

package/src/internal/core.ts

@@ -35,7 +35,7 @@ import type * as RuntimeFlags from "../RuntimeFlags.js"
 import * as RuntimeFlagsPatch from "../RuntimeFlagsPatch.js"
 import type * as Scope from "../Scope.js"
 import type * as Tracer from "../Tracer.js"
-import type { NoInfer } from "../Types.js"
+import type { NoInfer, NotFunction } from "../Types.js"
 import * as _blockedRequests from "./blockedRequests.js"
 import * as internalCause from "./cause.js"
 import * as deferred from "./deferred.js"
@@ -697,7 +697,7 @@ export const andThen: {
     : [X] extends [Promise<infer A1>] ? Effect.Effect<A1, E | Cause.UnknownException, R>
     : Effect.Effect<X, E, R>
   <X>(
-    f: X
+    f: NotFunction<X>
   ): <A, E, R>(
     self: Effect.Effect<A, E, R>
   ) => [X] extends [Effect.Effect<infer A1, infer E1, infer R1>] ? Effect.Effect<A1, E | E1, R | R1>
@@ -711,7 +711,7 @@ export const andThen: {
     : Effect.Effect<X, E, R>
   <A, E, R, X>(
     self: Effect.Effect<A, E, R>,
-    f: X
+    f: NotFunction<X>
   ): [X] extends [Effect.Effect<infer A1, infer E1, infer R1>] ? Effect.Effect<A1, E | E1, R | R1>
     : [X] extends [Promise<infer A1>] ? Effect.Effect<A1, E | Cause.UnknownException, R>
     : Effect.Effect<X, E, R>
@@ -1169,7 +1169,7 @@ export const tap = dual<
       : [X] extends [Promise<infer _A1>] ? Effect.Effect<A, E | Cause.UnknownException, R>
       : Effect.Effect<A, E, R>
     <X>(
-      f: X
+      f: NotFunction<X>
     ): <A, E, R>(
       self: Effect.Effect<A, E, R>
     ) => [X] extends [Effect.Effect<infer _A1, infer E1, infer R1>] ? Effect.Effect<A, E | E1, R | R1>
@@ -1185,7 +1185,7 @@ export const tap = dual<
       : Effect.Effect<A, E, R>
     <A, E, R, X>(
       self: Effect.Effect<A, E, R>,
-      f: X
+      f: NotFunction<X>
     ): [X] extends [Effect.Effect<infer _A1, infer E1, infer R1>] ? Effect.Effect<A, E | E1, R | R1>
       : [X] extends [Promise<infer _A1>] ? Effect.Effect<A, E | Cause.UnknownException, R>
       : Effect.Effect<A, E, R>

package/src/internal/fiberRuntime.ts

@@ -5,6 +5,7 @@ import type * as Clock from "../Clock.js"
 import type { ConfigProvider } from "../ConfigProvider.js"
 import * as Context from "../Context.js"
 import * as Deferred from "../Deferred.js"
+import type * as Duration from "../Duration.js"
 import type * as Effect from "../Effect.js"
 import { EffectTypeId } from "../Effectable.js"
 import type * as Either from "../Either.js"
@@ -1361,6 +1362,16 @@ export const defaultLogger: Logger<unknown, void> = globalValue(
     })
 )
 
+/** @internal */
+export const jsonLogger: Logger<unknown, void> = globalValue(
+  Symbol.for("effect/Logger/jsonLogger"),
+  () =>
+    internalLogger.makeLogger((options) => {
+      const formatted = internalLogger.jsonLogger.log(options)
+      getConsole(options.context).log(formatted)
+    })
+)
+
 /** @internal */
 export const logFmtLogger: Logger<unknown, void> = globalValue(
   Symbol.for("effect/Logger/logFmtLogger"),
@@ -1371,6 +1382,16 @@ export const logFmtLogger: Logger<unknown, void> = globalValue(
     })
 )
 
+/** @internal */
+export const structuredLogger: Logger<unknown, void> = globalValue(
+  Symbol.for("effect/Logger/structuredLogger"),
+  () =>
+    internalLogger.makeLogger((options) => {
+      const formatted = internalLogger.structuredLogger.log(options)
+      getConsole(options.context).log(formatted)
+    })
+)
+
 /** @internal */
 export const tracerLogger = globalValue(
   Symbol.for("effect/Logger/tracerLogger"),
@@ -1434,6 +1455,53 @@ export const currentLoggers: FiberRef.FiberRef<
   () => core.fiberRefUnsafeMakeHashSet(HashSet.make(defaultLogger, tracerLogger))
 )
 
+/** @internal */
+export const batchedLogger = dual<
+  <Output, R>(
+    window: Duration.DurationInput,
+    f: (messages: Array<NoInfer<Output>>) => Effect.Effect<void, never, R>
+  ) => <Message>(
+    self: Logger<Message, Output>
+  ) => Effect.Effect<Logger<Message, void>, never, Scope.Scope | R>,
+  <Message, Output, R>(
+    self: Logger<Message, Output>,
+    window: Duration.DurationInput,
+    f: (messages: Array<NoInfer<Output>>) => Effect.Effect<void, never, R>
+  ) => Effect.Effect<Logger<Message, void>, never, Scope.Scope | R>
+>(3, <Message, Output, R>(
+  self: Logger<Message, Output>,
+  window: Duration.DurationInput,
+  f: (messages: Array<NoInfer<Output>>) => Effect.Effect<void, never, R>
+): Effect.Effect<Logger<Message, void>, never, Scope.Scope | R> =>
+  core.flatMap(scope, (scope) => {
+    let buffer: Array<Output> = []
+    const flush = core.suspend(() => {
+      if (buffer.length === 0) {
+        return core.unit
+      }
+      const arr = buffer
+      buffer = []
+      return f(arr)
+    })
+
+    return core.uninterruptibleMask((restore) =>
+      pipe(
+        internalEffect.sleep(window),
+        core.zipRight(flush),
+        internalEffect.forever,
+        restore,
+        forkDaemon,
+        core.flatMap((fiber) => core.scopeAddFinalizer(scope, core.interruptFiber(fiber))),
+        core.zipRight(addFinalizer(() => flush)),
+        core.as(
+          internalLogger.makeLogger((options) => {
+            buffer.push(self.log(options))
+          })
+        )
+      )
+    )
+  }))
+
 // circular with Effect
 
 /* @internal */

package/src/internal/logger.ts

@@ -215,7 +215,7 @@ export const stringLogger: Logger.Logger<unknown, string> = makeLogger<unknown,
 
 export const serializeUnknown = (u: unknown): string => {
   try {
-    return typeof u === "object" ? JSON.stringify(u) : String(u)
+    return typeof u === "object" ? jsonStringifyCircular(u) : String(u)
   } catch (_) {
     return String(u)
   }
@@ -288,6 +288,76 @@ export const logfmtLogger = makeLogger<unknown, string>(
   }
 )
 
+/** @internal */
+export const structuredLogger = makeLogger<unknown, {
+  readonly logLevel: string
+  readonly fiberId: string
+  readonly timestamp: string
+  readonly message: unknown
+  readonly cause: string | undefined
+  readonly annotations: Record<string, unknown>
+  readonly spans: Record<string, number>
+}>(
+  ({ annotations, cause, date, fiberId, logLevel, message, spans }) => {
+    const now = date.getTime()
+    const annotationsObj: Record<string, unknown> = {}
+    const spansObj: Record<string, number> = {}
+
+    if (HashMap.size(annotations) > 0) {
+      for (const [k, v] of annotations) {
+        annotationsObj[k] = structuredMessage(v)
+      }
+    }
+
+    if (List.isCons(spans)) {
+      for (const span of spans) {
+        spansObj[span.label] = now - span.startTime
+      }
+    }
+
+    return {
+      message: structuredMessage(message),
+      logLevel: logLevel.label,
+      timestamp: date.toISOString(),
+      cause: Cause.isEmpty(cause) ? undefined : Cause.pretty(cause),
+      annotations: annotationsObj,
+      spans: spansObj,
+      fiberId: _fiberId.threadName(fiberId)
+    }
+  }
+)
+
+export const structuredMessage = (u: unknown): unknown => {
+  switch (typeof u) {
+    case "bigint":
+    case "function":
+    case "symbol": {
+      return String(u)
+    }
+    default: {
+      return u
+    }
+  }
+}
+
+const jsonStringifyCircular = (obj: unknown) => {
+  let cache: Array<unknown> = []
+  const retVal = JSON.stringify(
+    obj,
+    (_key, value) =>
+      typeof value === "object" && value !== null
+        ? cache.includes(value)
+          ? undefined // circular reference
+          : cache.push(value) && value
+        : value
+  )
+  ;(cache as any) = undefined
+  return retVal
+}
+
+/** @internal */
+export const jsonLogger = map(structuredLogger, jsonStringifyCircular)
+
 /** @internal */
 const filterKeyName = (key: string) => key.replace(/[\s="]/g, "_")
 
@@ -303,3 +373,8 @@ const renderLogSpanLogfmt = (now: number) => (self: LogSpan.LogSpan): string =>
   const label = filterKeyName(self.label)
   return `${label}=${now - self.startTime}ms`
 }
+
+/** @internal */
+export const isLogger = (u: unknown): u is Logger.Logger<unknown, unknown> => {
+  return typeof u === "object" && u != null && LoggerTypeId in u
+}