effect 3.9.1 → 3.10.0

package/src/internal/core-effect.ts

@@ -85,7 +85,7 @@ export const try_: {
     readonly try: LazyArg<A>
     readonly catch: (error: unknown) => E
   }): Effect.Effect<A, E>
-  <A>(evaluate: LazyArg<A>): Effect.Effect<A, Cause.UnknownException>
+  <A>(thunk: LazyArg<A>): Effect.Effect<A, Cause.UnknownException>
 } = <A, E>(
   arg: LazyArg<A> | {
     readonly try: LazyArg<A>
@@ -375,14 +375,14 @@ export const Do: Effect.Effect<{}> = core.succeed({})
 export const bind: {
   <N extends string, A extends object, B, E2, R2>(
     name: Exclude<N, keyof A>,
-    f: (a: A) => Effect.Effect<B, E2, R2>
+    f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>
   ): <E1, R1>(
     self: Effect.Effect<A, E1, R1>
   ) => Effect.Effect<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E2 | E1, R2 | R1>
   <A extends object, N extends string, E1, R1, B, E2, R2>(
     self: Effect.Effect<A, E1, R1>,
     name: Exclude<N, keyof A>,
-    f: (a: A) => Effect.Effect<B, E2, R2>
+    f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>
   ): Effect.Effect<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E1 | E2, R1 | R2>
 } = doNotation.bind<Effect.EffectTypeLambda>(core.map, core.flatMap)
 
@@ -396,14 +396,14 @@ export const bindTo: {
 export const let_: {
   <N extends string, A extends object, B>(
     name: Exclude<N, keyof A>,
-    f: (a: A) => B
+    f: (a: NoInfer<A>) => B
   ): <E, R>(
     self: Effect.Effect<A, E, R>
   ) => Effect.Effect<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E, R>
   <A extends object, N extends string, E, R, B>(
     self: Effect.Effect<A, E, R>,
     name: Exclude<N, keyof A>,
-    f: (a: A) => B
+    f: (a: NoInfer<A>) => B
   ): Effect.Effect<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E, R>
 } = doNotation.let_<Effect.EffectTypeLambda>(core.map)
 
@@ -1656,7 +1656,7 @@ export const tryPromise: {
       readonly catch: (error: unknown) => E
     }
   ): Effect.Effect<A, E>
-  <A>(try_: (signal: AbortSignal) => PromiseLike<A>): Effect.Effect<A, Cause.UnknownException>
+  <A>(evaluate: (signal: AbortSignal) => PromiseLike<A>): Effect.Effect<A, Cause.UnknownException>
 } = <A, E>(
   arg: ((signal: AbortSignal) => PromiseLike<A>) | {
     readonly try: (signal: AbortSignal) => PromiseLike<A>

package/src/internal/core.ts

@@ -521,13 +521,13 @@ export const unsafeAsync = <A, E = never, R = never>(
 
 /* @internal */
 export const async = <A, E = never, R = never>(
-  register: (
+  resume: (
     callback: (_: Effect.Effect<A, E, R>) => void,
     signal: AbortSignal
   ) => void | Effect.Effect<void, never, R>,
   blockingOn: FiberId.FiberId = FiberId.none
 ): Effect.Effect<A, E, R> => {
-  return custom(register, function() {
+  return custom(resume, function() {
     let backingResume: ((_: Effect.Effect<A, E, R>) => void) | undefined = undefined
     let pendingEffect: Effect.Effect<A, E, R> | undefined = undefined
     function proxyResume(effect: Effect.Effect<A, E, R>) {
@@ -1216,9 +1216,9 @@ export const suspend = <A, E, R>(effect: LazyArg<Effect.Effect<A, E, R>>): Effec
   flatMap(sync(effect), identity)
 
 /* @internal */
-export const sync = <A>(evaluate: LazyArg<A>): Effect.Effect<A> => {
+export const sync = <A>(thunk: LazyArg<A>): Effect.Effect<A> => {
   const effect = new EffectPrimitive(OpCodes.OP_SYNC) as any
-  effect.effect_instruction_i0 = evaluate
+  effect.effect_instruction_i0 = thunk
   return effect
 }
 

package/src/internal/doNotation.ts

@@ -1,3 +1,4 @@
+import type { NoInfer } from "effect/Types"
 import { dual } from "../Function.js"
 import type { Kind, TypeLambda } from "../HKT.js"
 
@@ -22,20 +23,20 @@ export const let_ = <F extends TypeLambda>(
 ): {
   <N extends string, A extends object, B>(
     name: Exclude<N, keyof A>,
-    f: (a: A) => B
+    f: (a: NoInfer<A>) => B
   ): <R, O, E>(
     self: Kind<F, R, O, E, A>
   ) => Kind<F, R, O, E, { [K in keyof A | N]: K extends keyof A ? A[K] : B }>
   <R, O, E, A extends object, N extends string, B>(
     self: Kind<F, R, O, E, A>,
     name: Exclude<N, keyof A>,
-    f: (a: A) => B
+    f: (a: NoInfer<A>) => B
   ): Kind<F, R, O, E, { [K in keyof A | N]: K extends keyof A ? A[K] : B }>
 } =>
   dual(3, <R, O, E, A extends object, N extends string, B>(
     self: Kind<F, R, O, E, A>,
     name: Exclude<N, keyof A>,
-    f: (a: A) => B
+    f: (a: NoInfer<A>) => B
   ): Kind<F, R, O, E, { [K in keyof A | N]: K extends keyof A ? A[K] : B }> =>
     map(self, (a) => Object.assign({}, a, { [name]: f(a) }) as any))
 
@@ -58,20 +59,20 @@ export const bindTo = <F extends TypeLambda>(map: Map<F>): {
 export const bind = <F extends TypeLambda>(map: Map<F>, flatMap: FlatMap<F>): {
   <N extends string, A extends object, R2, O2, E2, B>(
     name: Exclude<N, keyof A>,
-    f: (a: A) => Kind<F, R2, O2, E2, B>
+    f: (a: NoInfer<A>) => Kind<F, R2, O2, E2, B>
   ): <R1, O1, E1>(
     self: Kind<F, R1, O1, E1, A>
   ) => Kind<F, R1 & R2, O1 | O2, E1 | E2, { [K in keyof A | N]: K extends keyof A ? A[K] : B }>
   <R1, O1, E1, A extends object, N extends string, R2, O2, E2, B>(
     self: Kind<F, R1, O1, E1, A>,
     name: Exclude<N, keyof A>,
-    f: (a: A) => Kind<F, R2, O2, E2, B>
+    f: (a: NoInfer<A>) => Kind<F, R2, O2, E2, B>
   ): Kind<F, R1 & R2, O1 | O2, E1 | E2, { [K in keyof A | N]: K extends keyof A ? A[K] : B }>
 } =>
   dual(3, <R1, O1, E1, A, N extends string, R2, O2, E2, B>(
     self: Kind<F, R1, O1, E1, A>,
     name: Exclude<N, keyof A>,
-    f: (a: A) => Kind<F, R2, O2, E2, B>
+    f: (a: NoInfer<A>) => Kind<F, R2, O2, E2, B>
   ): Kind<F, R1 & R2, O1 | O2, E1 | E2, { [K in keyof A | N]: K extends keyof A ? A[K] : B }> =>
     flatMap(self, (a) =>
       map(f(a), (b) => Object.assign({}, a, { [name]: b }) as { [K in keyof A | N]: K extends keyof A ? A[K] : B })))

package/src/internal/fiberRuntime.ts

@@ -827,18 +827,20 @@ export class FiberRuntime<in out A, in out E = never> extends Effectable.Class<A
     if (HashSet.size(loggers) > 0) {
       const clockService = Context.get(this.getFiberRef(defaultServices.currentServices), clock.clockTag)
       const date = new Date(clockService.unsafeCurrentTimeMillis())
-      for (const logger of loggers) {
-        logger.log({
-          fiberId: this.id(),
-          logLevel,
-          message,
-          cause,
-          context: contextMap,
-          spans,
-          annotations,
-          date
-        })
-      }
+      Inspectable.withRedactableContext(contextMap, () => {
+        for (const logger of loggers) {
+          logger.log({
+            fiberId: this.id(),
+            logLevel,
+            message,
+            cause,
+            context: contextMap,
+            spans,
+            annotations,
+            date
+          })
+        }
+      })
     }
   }
 

package/src/internal/groupBy.ts

@@ -277,7 +277,7 @@ export const mapEffectOptions = dual<
 export const bindEffect = dual<
   <N extends string, A, B, E2, R2>(
     tag: Exclude<N, keyof A>,
-    f: (_: A) => Effect.Effect<B, E2, R2>,
+    f: (_: NoInfer<A>) => Effect.Effect<B, E2, R2>,
     options?: {
       readonly concurrency?: number | "unbounded" | undefined
       readonly bufferSize?: number | undefined
@@ -290,7 +290,7 @@ export const bindEffect = dual<
   <A, E, R, N extends string, B, E2, R2>(
     self: Stream.Stream<A, E, R>,
     tag: Exclude<N, keyof A>,
-    f: (_: A) => Effect.Effect<B, E2, R2>,
+    f: (_: NoInfer<A>) => Effect.Effect<B, E2, R2>,
     options?: {
       readonly concurrency?: number | "unbounded" | undefined
       readonly unordered?: boolean | undefined

package/src/internal/logger.ts

@@ -341,7 +341,7 @@ export const structuredMessage = (u: unknown): unknown => {
       return String(u)
     }
     default: {
-      return u
+      return Inspectable.toJSON(u)
     }
   }
 }
@@ -488,13 +488,13 @@ const prettyLoggerTty = (options: {
 
       if (messageIndex < message.length) {
         for (; messageIndex < message.length; messageIndex++) {
-          log(message[messageIndex])
+          log(Inspectable.redact(message[messageIndex]))
         }
       }
 
       if (HashMap.size(annotations) > 0) {
         for (const [key, value] of annotations) {
-          log(color(`${key}:`, colors.bold, colors.white), value)
+          log(color(`${key}:`, colors.bold, colors.white), Inspectable.redact(value))
         }
       }
 
@@ -553,16 +553,17 @@ const prettyLoggerBrowser = (options: {
 
       if (messageIndex < message.length) {
         for (; messageIndex < message.length; messageIndex++) {
-          console.log(message[messageIndex])
+          console.log(Inspectable.redact(message[messageIndex]))
         }
       }
 
       if (HashMap.size(annotations) > 0) {
         for (const [key, value] of annotations) {
+          const redacted = Inspectable.redact(value)
           if (options.colors) {
-            console.log(`%c${key}:`, "color:gray", value)
+            console.log(`%c${key}:`, "color:gray", redacted)
           } else {
-            console.log(`${key}:`, value)
+            console.log(`${key}:`, redacted)
           }
         }
       }

package/src/internal/redacted.ts

@@ -1,3 +1,4 @@
+import { NodeInspectSymbol } from "effect/Inspectable"
 import * as Equal from "../Equal.js"
 import { pipe } from "../Function.js"
 import { globalValue } from "../GlobalValue.js"
@@ -34,6 +35,9 @@ export const proto = {
   toJSON() {
     return "<redacted>"
   },
+  [NodeInspectSymbol]() {
+    return "<redacted>"
+  },
   [Hash.symbol]<T>(this: Redacted.Redacted<T>): number {
     return pipe(
       Hash.hash(RedactedSymbolKey),

package/src/internal/schema/errors.ts

@@ -0,0 +1,189 @@
+import * as array_ from "effect/Array"
+import type * as AST from "../../SchemaAST.js"
+import * as util_ from "./util.js"
+
+const getErrorMessage = (
+  reason: string,
+  details?: string,
+  path?: ReadonlyArray<PropertyKey>,
+  ast?: AST.AST
+): string => {
+  let out = reason
+
+  if (path && array_.isNonEmptyReadonlyArray(path)) {
+    out += `\nat path: ${util_.formatPath(path)}`
+  }
+
+  if (details !== undefined) {
+    out += `\ndetails: ${details}`
+  }
+
+  if (ast) {
+    out += `\nschema (${ast._tag}): ${ast}`
+  }
+
+  return out
+}
+
+// ---------------------------------------------
+// generic
+// ---------------------------------------------
+
+/** @internal */
+export const getInvalidArgumentErrorMessage = (details: string) => getErrorMessage("Invalid Argument", details)
+
+const getUnsupportedSchemaErrorMessage = (details?: string, path?: ReadonlyArray<PropertyKey>, ast?: AST.AST): string =>
+  getErrorMessage("Unsupported schema", details, path, ast)
+
+const getMissingAnnotationErrorMessage = (details?: string, path?: ReadonlyArray<PropertyKey>, ast?: AST.AST): string =>
+  getErrorMessage("Missing annotation", details, path, ast)
+
+// ---------------------------------------------
+// Arbitrary
+// ---------------------------------------------
+
+/** @internal */
+export const getArbitraryUnsupportedErrorMessage = (path: ReadonlyArray<PropertyKey>, ast: AST.AST) =>
+  getUnsupportedSchemaErrorMessage("Cannot build an Arbitrary for this schema", path, ast)
+
+/** @internal */
+export const getArbitraryMissingAnnotationErrorMessage = (
+  path: ReadonlyArray<PropertyKey>,
+  ast: AST.AST
+) =>
+  getMissingAnnotationErrorMessage(
+    `Generating an Arbitrary for this schema requires an "arbitrary" annotation`,
+    path,
+    ast
+  )
+
+/** @internal */
+export const getArbitraryEmptyEnumErrorMessage = (path: ReadonlyArray<PropertyKey>) =>
+  getErrorMessage("Empty Enums schema", "Generating an Arbitrary for this schema requires at least one enum", path)
+
+// ---------------------------------------------
+// Equivalence
+// ---------------------------------------------
+
+/** @internal */
+export const getEquivalenceUnsupportedErrorMessage = (ast: AST.AST, path: ReadonlyArray<PropertyKey>) =>
+  getUnsupportedSchemaErrorMessage("Cannot build an Equivalence", path, ast)
+
+// ---------------------------------------------
+// JSON Schema
+// ---------------------------------------------
+
+/** @internal */
+export const getJSONSchemaMissingAnnotationErrorMessage = (
+  path: ReadonlyArray<PropertyKey>,
+  ast: AST.AST
+) =>
+  getMissingAnnotationErrorMessage(
+    `Generating a JSON Schema for this schema requires a "jsonSchema" annotation`,
+    path,
+    ast
+  )
+
+/** @internal */
+export const getJSONSchemaMissingIdentifierAnnotationErrorMessage = (
+  path: ReadonlyArray<PropertyKey>,
+  ast: AST.AST
+) =>
+  getMissingAnnotationErrorMessage(
+    `Generating a JSON Schema for this schema requires an "identifier" annotation`,
+    path,
+    ast
+  )
+
+/** @internal */
+export const getJSONSchemaUnsupportedParameterErrorMessage = (
+  path: ReadonlyArray<PropertyKey>,
+  parameter: AST.AST
+): string => getErrorMessage("Unsupported index signature parameter", undefined, path, parameter)
+
+/** @internal */
+export const getJSONSchemaUnsupportedPostRestElementsErrorMessage = (path: ReadonlyArray<PropertyKey>): string =>
+  getErrorMessage(
+    "Generating a JSON Schema for post-rest elements is not currently supported. You're welcome to contribute by submitting a Pull Request",
+    undefined,
+    path
+  )
+
+/** @internal */
+export const getJSONSchemaUnsupportedKeyErrorMessage = (key: PropertyKey, path: ReadonlyArray<PropertyKey>): string =>
+  getErrorMessage("Unsupported key", `Cannot encode ${util_.formatPropertyKey(key)} key to JSON Schema`, path)
+
+// ---------------------------------------------
+// Pretty
+// ---------------------------------------------
+
+/** @internal */
+export const getPrettyMissingAnnotationErrorMessage = (
+  path: ReadonlyArray<PropertyKey>,
+  ast: AST.AST
+) => getMissingAnnotationErrorMessage(`Generating a Pretty for this schema requires a "pretty" annotation`, path, ast)
+
+/** @internal */
+export const getPrettyNeverErrorMessage = "Cannot pretty print a `never` value"
+
+/** @internal */
+export const getPrettyNoMatchingSchemaErrorMessage = (
+  actual: unknown,
+  path: ReadonlyArray<PropertyKey>,
+  ast: AST.AST
+) => getErrorMessage("Unexpected Error", `Cannot find a matching schema for ${util_.formatUnknown(actual)}`, path, ast)
+
+// ---------------------------------------------
+// Schema
+// ---------------------------------------------
+
+/** @internal */
+export const getSchemaExtendErrorMessage = (x: AST.AST, y: AST.AST, path: ReadonlyArray<PropertyKey>) =>
+  getErrorMessage("Unsupported schema or overlapping types", `cannot extend ${x} with ${y}`, path)
+
+/** @internal */
+export const getSchemaUnsupportedLiteralSpanErrorMessage = (ast: AST.AST) =>
+  getErrorMessage("Unsupported template literal span", undefined, undefined, ast)
+
+// ---------------------------------------------
+// AST
+// ---------------------------------------------
+
+/** @internal */
+export const getASTUnsupportedSchema = (ast: AST.AST) => getUnsupportedSchemaErrorMessage(undefined, undefined, ast)
+
+/** @internal */
+export const getASTUnsupportedKeySchema = (ast: AST.AST) =>
+  getErrorMessage("Unsupported key schema", undefined, undefined, ast)
+
+/** @internal */
+export const getASTUnsupportedLiteral = (literal: AST.LiteralValue) =>
+  getErrorMessage("Unsupported literal", `literal value: ${util_.formatUnknown(literal)}`)
+
+/** @internal */
+export const getASTDuplicateIndexSignatureErrorMessage = (type: "string" | "symbol"): string =>
+  getErrorMessage("Duplicate index signature", `${type} index signature`)
+
+/** @internal */
+export const getASTIndexSignatureParameterErrorMessage = getErrorMessage(
+  "Unsupported index signature parameter",
+  "An index signature parameter type must be `string`, `symbol`, a template literal type or a refinement of the previous types"
+)
+
+/** @internal */
+export const getASTRequiredElementFollowinAnOptionalElementErrorMessage = getErrorMessage(
+  "Invalid element",
+  "A required element cannot follow an optional element. ts(1257)"
+)
+
+/** @internal */
+export const getASTDuplicatePropertySignatureTransformationErrorMessage = (key: PropertyKey): string =>
+  getErrorMessage("Duplicate property signature transformation", `Duplicate key ${util_.formatUnknown(key)}`)
+
+/** @internal */
+export const getASTUnsupportedRenameSchema = (ast: AST.AST): string =>
+  getUnsupportedSchemaErrorMessage(undefined, undefined, ast)
+
+/** @internal */
+export const getASTDuplicatePropertySignatureErrorMessage = (key: PropertyKey): string =>
+  getErrorMessage("Duplicate property signature", `Duplicate key ${util_.formatUnknown(key)}`)

package/src/internal/schema/filters.ts

@@ -0,0 +1,86 @@
+import type * as Schema from "../../Schema.js"
+
+/** @internal */
+export const GreaterThanSchemaId: Schema.GreaterThanSchemaId = Symbol.for(
+  "effect/schema/GreaterThan"
+) as Schema.GreaterThanSchemaId
+
+/** @internal */
+export const GreaterThanOrEqualToSchemaId: Schema.GreaterThanOrEqualToSchemaId = Symbol.for(
+  "effect/schema/GreaterThanOrEqualTo"
+) as Schema.GreaterThanOrEqualToSchemaId
+
+/** @internal */
+export const LessThanSchemaId: Schema.LessThanSchemaId = Symbol.for(
+  "effect/schema/LessThan"
+) as Schema.LessThanSchemaId
+
+/** @internal */
+export const LessThanOrEqualToSchemaId: Schema.LessThanOrEqualToSchemaId = Symbol.for(
+  "effect/schema/LessThanOrEqualTo"
+) as Schema.LessThanOrEqualToSchemaId
+
+/** @internal */
+export const IntSchemaId: Schema.IntSchemaId = Symbol.for(
+  "effect/schema/Int"
+) as Schema.IntSchemaId
+
+/** @internal */
+export const BetweenSchemaId: Schema.BetweenSchemaId = Symbol.for(
+  "effect/schema/Between"
+) as Schema.BetweenSchemaId
+
+/** @internal */
+export const GreaterThanBigintSchemaId: Schema.GreaterThanBigIntSchemaId = Symbol.for(
+  "effect/schema/GreaterThanBigint"
+) as Schema.GreaterThanBigIntSchemaId
+
+/** @internal */
+export const GreaterThanOrEqualToBigIntSchemaId: Schema.GreaterThanOrEqualToBigIntSchemaId = Symbol.for(
+  "effect/schema/GreaterThanOrEqualToBigint"
+) as Schema.GreaterThanOrEqualToBigIntSchemaId
+
+/** @internal */
+export const LessThanBigIntSchemaId: Schema.LessThanBigIntSchemaId = Symbol.for(
+  "effect/schema/LessThanBigint"
+) as Schema.LessThanBigIntSchemaId
+
+/** @internal */
+export const LessThanOrEqualToBigIntSchemaId: Schema.LessThanOrEqualToBigIntSchemaId = Symbol.for(
+  "effect/schema/LessThanOrEqualToBigint"
+) as Schema.LessThanOrEqualToBigIntSchemaId
+
+/** @internal */
+export const BetweenBigintSchemaId: Schema.BetweenBigIntSchemaId = Symbol.for(
+  "effect/schema/BetweenBigint"
+) as Schema.BetweenBigIntSchemaId
+
+/** @internal */
+export const MinLengthSchemaId: Schema.MinLengthSchemaId = Symbol.for(
+  "effect/schema/MinLength"
+) as Schema.MinLengthSchemaId
+
+/** @internal */
+export const MaxLengthSchemaId: Schema.MaxLengthSchemaId = Symbol.for(
+  "effect/schema/MaxLength"
+) as Schema.MaxLengthSchemaId
+
+/** @internal */
+export const LengthSchemaId: Schema.LengthSchemaId = Symbol.for(
+  "effect/schema/Length"
+) as Schema.LengthSchemaId
+
+/** @internal */
+export const MinItemsSchemaId: Schema.MinItemsSchemaId = Symbol.for(
+  "effect/schema/MinItems"
+) as Schema.MinItemsSchemaId
+
+/** @internal */
+export const MaxItemsSchemaId: Schema.MaxItemsSchemaId = Symbol.for(
+  "effect/schema/MaxItems"
+) as Schema.MaxItemsSchemaId
+
+/** @internal */
+export const ItemsCountSchemaId: Schema.ItemsCountSchemaId = Symbol.for(
+  "effect/schema/ItemsCount"
+) as Schema.ItemsCountSchemaId

package/src/internal/schema/util.ts

@@ -0,0 +1,113 @@
+import * as array_ from "effect/Array"
+import * as Predicate from "effect/Predicate"
+import type * as ParseResult from "../../ParseResult.js"
+import type * as AST from "../../SchemaAST.js"
+
+/** @internal */
+export const getKeysForIndexSignature = (
+  input: { readonly [x: PropertyKey]: unknown },
+  parameter: AST.Parameter
+): ReadonlyArray<string> | ReadonlyArray<symbol> => {
+  switch (parameter._tag) {
+    case "StringKeyword":
+    case "TemplateLiteral":
+      return Object.keys(input)
+    case "SymbolKeyword":
+      return Object.getOwnPropertySymbols(input)
+    case "Refinement":
+      return getKeysForIndexSignature(input, parameter.from)
+  }
+}
+
+/**
+ * JavaScript does not store the insertion order of properties in a way that
+ * combines both string and symbol keys. The internal order groups string keys
+ * and symbol keys separately. Hence concatenating the keys is fine.
+ *
+ * @internal
+ */
+export const ownKeys = (o: object): Array<PropertyKey> =>
+  (Object.keys(o) as Array<PropertyKey>).concat(Object.getOwnPropertySymbols(o))
+
+/** @internal */
+export const memoizeThunk = <A>(f: () => A): () => A => {
+  let done = false
+  let a: A
+  return () => {
+    if (done) {
+      return a
+    }
+    a = f()
+    done = true
+    return a
+  }
+}
+
+/** @internal */
+export const formatDate = (date: Date): string => {
+  try {
+    return date.toISOString()
+  } catch (e) {
+    return String(date)
+  }
+}
+
+/** @internal */
+export const formatUnknown = (u: unknown): string => {
+  if (Predicate.isString(u)) {
+    return JSON.stringify(u)
+  } else if (
+    Predicate.isNumber(u)
+    || u == null
+    || Predicate.isBoolean(u)
+    || Predicate.isSymbol(u)
+  ) {
+    return String(u)
+  } else if (Predicate.isDate(u)) {
+    return formatDate(u)
+  } else if (Predicate.isBigInt(u)) {
+    return String(u) + "n"
+  } else if (
+    !array_.isArray(u)
+    && Predicate.hasProperty(u, "toString")
+    && Predicate.isFunction(u["toString"])
+    && u["toString"] !== Object.prototype.toString
+  ) {
+    return u["toString"]()
+  }
+  try {
+    JSON.stringify(u)
+    if (array_.isArray(u)) {
+      return `[${u.map(formatUnknown).join(",")}]`
+    } else {
+      return `{${
+        ownKeys(u).map((k) =>
+          `${Predicate.isString(k) ? JSON.stringify(k) : String(k)}:${formatUnknown((u as any)[k])}`
+        ).join(",")
+      }}`
+    }
+  } catch (e) {
+    return String(u)
+  }
+}
+
+/** @internal */
+export const formatPropertyKey = (name: PropertyKey): string =>
+  typeof name === "string" ? JSON.stringify(name) : String(name)
+
+/** @internal */
+export type SingleOrArray<A> = A | ReadonlyArray<A>
+
+/** @internal */
+export const isNonEmpty = <A>(x: ParseResult.SingleOrNonEmpty<A>): x is array_.NonEmptyReadonlyArray<A> =>
+  Array.isArray(x)
+
+/** @internal */
+export const isSingle = <A>(x: A | ReadonlyArray<A>): x is A => !Array.isArray(x)
+
+/** @internal */
+export const formatPathKey = (key: PropertyKey): string => `[${formatPropertyKey(key)}]`
+
+/** @internal */
+export const formatPath = (path: ParseResult.Path): string =>
+  isNonEmpty(path) ? path.map(formatPathKey).join("") : formatPathKey(path)

package/src/internal/stm/core.ts

@@ -15,11 +15,10 @@ import { pipeArguments } from "../../Pipeable.js"
 import { hasProperty } from "../../Predicate.js"
 import type * as Scheduler from "../../Scheduler.js"
 import type * as STM from "../../STM.js"
-import { StreamTypeId } from "../../Stream.js"
 import { YieldWrap } from "../../Utils.js"
 import { ChannelTypeId } from "../core-stream.js"
 import { withFiberRuntime } from "../core.js"
-import { effectVariance } from "../effectable.js"
+import { effectVariance, StreamTypeId } from "../effectable.js"
 import { OP_COMMIT } from "../opCodes/effect.js"
 import { SingleShotGen } from "../singleShotGen.js"
 import { SinkTypeId } from "../sink.js"

package/src/internal/stm/tPubSub.ts

@@ -201,6 +201,7 @@ class TPubSubSubscriptionImpl<in out A> implements TQueue.TDequeue<A> {
   capacity(): number {
     return this.requestedCapacity
   }
+
   size: STM.STM<number> = core.withSTMRuntime((runtime) => {
     let currentSubscriberHead = tRef.unsafeGet(this.subscriberHead, runtime.journal)
     if (currentSubscriberHead === undefined) {

package/src/internal/stm/tQueue.ts

@@ -3,7 +3,7 @@ import * as Chunk from "../../Chunk.js"
 import { dual, pipe } from "../../Function.js"
 import * as Option from "../../Option.js"
 import { hasProperty, type Predicate } from "../../Predicate.js"
-import * as STM from "../../STM.js"
+import type * as STM from "../../STM.js"
 import type * as TQueue from "../../TQueue.js"
 import type * as TRef from "../../TRef.js"
 import * as core from "./core.js"
@@ -99,7 +99,7 @@ class TQueueImpl<in out A> implements TQueue.TQueue<A> {
   size: STM.STM<number> = core.withSTMRuntime((runtime) => {
     const queue = tRef.unsafeGet(this.ref, runtime.journal)
     if (queue === undefined) {
-      return STM.interruptAs(runtime.fiberId)
+      return core.interruptAs(runtime.fiberId)
     }
     return core.succeed(queue.length)
   })