effect 3.11.10 → 3.12.1

package/src/internal/core-effect.ts

@@ -99,13 +99,11 @@ export const try_: {
     evaluate = arg.try
     onFailure = arg.catch
   }
-  return core.sync(() => {
+  return core.suspend(() => {
     try {
-      return evaluate()
+      return core.succeed(internalCall(evaluate))
     } catch (error) {
-      throw core.makeEffectError(internalCause.fail(
-        onFailure ? onFailure(error) : new core.UnknownException(error)
-      ))
+      return core.fail(onFailure ? internalCall(() => onFailure(error)) : new core.UnknownException(error))
     }
   })
 }
@@ -1600,7 +1598,7 @@ export const tapErrorCause = dual<
 /* @internal */
 export const timed = <A, E, R>(
   self: Effect.Effect<A, E, R>
-): Effect.Effect<[Duration.Duration, A], E, R> => timedWith(self, Clock.currentTimeNanos)
+): Effect.Effect<[duration: Duration.Duration, result: A], E, R> => timedWith(self, Clock.currentTimeNanos)
 
 /* @internal */
 export const timedWith = dual<
@@ -2020,61 +2018,75 @@ export const linkSpans = dual<
 
 const bigint0 = BigInt(0)
 
+const filterDisablePropagation: (self: Option.Option<Tracer.AnySpan>) => Option.Option<Tracer.AnySpan> = Option.flatMap(
+  (span) =>
+    Context.get(span.context, internalTracer.DisablePropagation)
+      ? span._tag === "Span" ? filterDisablePropagation(span.parent) : Option.none()
+      : Option.some(span)
+)
+
 /** @internal */
 export const unsafeMakeSpan = <XA, XE>(
   fiber: FiberRuntime<XA, XE>,
   name: string,
   options: Tracer.SpanOptions
 ) => {
-  const enabled = fiber.getFiberRef(core.currentTracerEnabled)
-  if (enabled === false) {
-    return core.noopSpan(name)
-  }
-
+  const disablePropagation = !fiber.getFiberRef(core.currentTracerEnabled) ||
+    (options.context && Context.get(options.context, internalTracer.DisablePropagation))
   const context = fiber.getFiberRef(core.currentContext)
-  const services = fiber.getFiberRef(defaultServices.currentServices)
-
-  const tracer = Context.get(services, internalTracer.tracerTag)
-  const clock = Context.get(services, Clock.Clock)
-  const timingEnabled = fiber.getFiberRef(core.currentTracerTimingEnabled)
-
-  const fiberRefs = fiber.getFiberRefs()
-  const annotationsFromEnv = FiberRefs.get(fiberRefs, core.currentTracerSpanAnnotations)
-  const linksFromEnv = FiberRefs.get(fiberRefs, core.currentTracerSpanLinks)
-
   const parent = options.parent
     ? Option.some(options.parent)
     : options.root
     ? Option.none()
-    : Context.getOption(context, internalTracer.spanTag)
-
-  const links = linksFromEnv._tag === "Some" ?
-    options.links !== undefined ?
-      [
-        ...Chunk.toReadonlyArray(linksFromEnv.value),
-        ...(options.links ?? [])
-      ] :
-      Chunk.toReadonlyArray(linksFromEnv.value) :
-    options.links ?? Arr.empty()
-
-  const span = tracer.span(
-    name,
-    parent,
-    options.context ?? Context.empty(),
-    links,
-    timingEnabled ? clock.unsafeCurrentTimeNanos() : bigint0,
-    options.kind ?? "internal"
-  )
+    : filterDisablePropagation(Context.getOption(context, internalTracer.spanTag))
 
-  if (typeof options.captureStackTrace === "function") {
-    internalCause.spanToTrace.set(span, options.captureStackTrace)
-  }
+  let span: Tracer.Span
 
-  if (annotationsFromEnv._tag === "Some") {
-    HashMap.forEach(annotationsFromEnv.value, (value, key) => span.attribute(key, value))
+  if (disablePropagation) {
+    span = core.noopSpan({
+      name,
+      parent,
+      context: Context.add(options.context ?? Context.empty(), internalTracer.DisablePropagation, true)
+    })
+  } else {
+    const services = fiber.getFiberRef(defaultServices.currentServices)
+
+    const tracer = Context.get(services, internalTracer.tracerTag)
+    const clock = Context.get(services, Clock.Clock)
+    const timingEnabled = fiber.getFiberRef(core.currentTracerTimingEnabled)
+
+    const fiberRefs = fiber.getFiberRefs()
+    const annotationsFromEnv = FiberRefs.get(fiberRefs, core.currentTracerSpanAnnotations)
+    const linksFromEnv = FiberRefs.get(fiberRefs, core.currentTracerSpanLinks)
+
+    const links = linksFromEnv._tag === "Some" ?
+      options.links !== undefined ?
+        [
+          ...Chunk.toReadonlyArray(linksFromEnv.value),
+          ...(options.links ?? [])
+        ] :
+        Chunk.toReadonlyArray(linksFromEnv.value) :
+      options.links ?? Arr.empty()
+
+    span = tracer.span(
+      name,
+      parent,
+      options.context ?? Context.empty(),
+      links,
+      timingEnabled ? clock.unsafeCurrentTimeNanos() : bigint0,
+      options.kind ?? "internal"
+    )
+
+    if (annotationsFromEnv._tag === "Some") {
+      HashMap.forEach(annotationsFromEnv.value, (value, key) => span.attribute(key, value))
+    }
+    if (options.attributes !== undefined) {
+      Object.entries(options.attributes).forEach(([k, v]) => span.attribute(k, v))
+    }
   }
-  if (options.attributes !== undefined) {
-    Object.entries(options.attributes).forEach(([k, v]) => span.attribute(k, v))
+
+  if (typeof options.captureStackTrace === "function") {
+    internalCause.spanToTrace.set(span, options.captureStackTrace)
   }
 
   return span

package/src/internal/core.ts

@@ -38,7 +38,7 @@ import type * as Scope from "../Scope.js"
 import type * as Tracer from "../Tracer.js"
 import type { NoInfer, NotFunction } from "../Types.js"
 import { internalCall, YieldWrap } from "../Utils.js"
-import * as _blockedRequests from "./blockedRequests.js"
+import * as blockedRequests_ from "./blockedRequests.js"
 import * as internalCause from "./cause.js"
 import * as deferred from "./deferred.js"
 import * as internalDiffer from "./differ.js"
@@ -48,39 +48,13 @@ import type * as FiberRuntime from "./fiberRuntime.js"
 import type * as fiberScope from "./fiberScope.js"
 import * as DeferredOpCodes from "./opCodes/deferred.js"
 import * as OpCodes from "./opCodes/effect.js"
-import * as _runtimeFlags from "./runtimeFlags.js"
+import * as runtimeFlags_ from "./runtimeFlags.js"
 import { SingleShotGen } from "./singleShotGen.js"
 
 // -----------------------------------------------------------------------------
 // Effect
 // -----------------------------------------------------------------------------
 
-/** @internal */
-const EffectErrorSymbolKey = "effect/EffectError"
-
-/** @internal */
-export const EffectErrorTypeId = Symbol.for(EffectErrorSymbolKey)
-
-/** @internal */
-export type EffectErrorTypeId = typeof EffectErrorTypeId
-
-/** @internal */
-export interface EffectError<out E> {
-  readonly [EffectErrorTypeId]: EffectErrorTypeId
-  readonly _tag: "EffectError"
-  readonly cause: Cause.Cause<E>
-}
-
-/** @internal */
-export const isEffectError = (u: unknown): u is EffectError<unknown> => hasProperty(u, EffectErrorTypeId)
-
-/** @internal */
-export const makeEffectError = <E>(cause: Cause.Cause<E>): EffectError<E> => ({
-  [EffectErrorTypeId]: EffectErrorTypeId,
-  _tag: "EffectError",
-  cause
-})
-
 /**
  * @internal
  */
@@ -677,7 +651,7 @@ export const catchSome = dual<
 /* @internal */
 export const checkInterruptible = <A, E, R>(
   f: (isInterruptible: boolean) => Effect.Effect<A, E, R>
-): Effect.Effect<A, E, R> => withFiberRuntime((_, status) => f(_runtimeFlags.interruption(status.runtimeFlags)))
+): Effect.Effect<A, E, R> => withFiberRuntime((_, status) => f(runtimeFlags_.interruption(status.runtimeFlags)))
 
 const spanSymbol = Symbol.for("effect/SpanAnnotation")
 const originalSymbol = Symbol.for("effect/OriginalAnnotation")
@@ -1027,7 +1001,7 @@ export const interruptWith = (fiberId: FiberId.FiberId): Effect.Effect<never> =>
 /* @internal */
 export const interruptible = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> => {
   const effect = new EffectPrimitive(OpCodes.OP_UPDATE_RUNTIME_FLAGS) as any
-  effect.effect_instruction_i0 = RuntimeFlagsPatch.enable(_runtimeFlags.Interruption)
+  effect.effect_instruction_i0 = RuntimeFlagsPatch.enable(runtimeFlags_.Interruption)
   effect.effect_instruction_i1 = () => self
   return effect
 }
@@ -1038,9 +1012,9 @@ export const interruptibleMask = <A, E, R>(
 ): Effect.Effect<A, E, R> =>
   custom(f, function() {
     const effect = new EffectPrimitive(OpCodes.OP_UPDATE_RUNTIME_FLAGS) as any
-    effect.effect_instruction_i0 = RuntimeFlagsPatch.enable(_runtimeFlags.Interruption)
+    effect.effect_instruction_i0 = RuntimeFlagsPatch.enable(runtimeFlags_.Interruption)
     effect.effect_instruction_i1 = (oldFlags: RuntimeFlags.RuntimeFlags) =>
-      _runtimeFlags.interruption(oldFlags)
+      runtimeFlags_.interruption(oldFlags)
         ? internalCall(() => this.effect_instruction_i0(interruptible))
         : internalCall(() => this.effect_instruction_i0(uninterruptible))
     return effect
@@ -1356,7 +1330,7 @@ export const uninterruptible: <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.
   self: Effect.Effect<A, E, R>
 ): Effect.Effect<A, E, R> => {
   const effect = new EffectPrimitive(OpCodes.OP_UPDATE_RUNTIME_FLAGS) as any
-  effect.effect_instruction_i0 = RuntimeFlagsPatch.disable(_runtimeFlags.Interruption)
+  effect.effect_instruction_i0 = RuntimeFlagsPatch.disable(runtimeFlags_.Interruption)
   effect.effect_instruction_i1 = () => self
   return effect
 }
@@ -1367,9 +1341,9 @@ export const uninterruptibleMask = <A, E, R>(
 ): Effect.Effect<A, E, R> =>
   custom(f, function() {
     const effect = new EffectPrimitive(OpCodes.OP_UPDATE_RUNTIME_FLAGS) as any
-    effect.effect_instruction_i0 = RuntimeFlagsPatch.disable(_runtimeFlags.Interruption)
+    effect.effect_instruction_i0 = RuntimeFlagsPatch.disable(runtimeFlags_.Interruption)
     effect.effect_instruction_i1 = (oldFlags: RuntimeFlags.RuntimeFlags) =>
-      _runtimeFlags.interruption(oldFlags)
+      runtimeFlags_.interruption(oldFlags)
         ? internalCall(() => this.effect_instruction_i0(interruptible))
         : internalCall(() => this.effect_instruction_i0(uninterruptible))
     return effect
@@ -1427,13 +1401,23 @@ export const whileLoop = <A, E, R>(
 }
 
 /* @internal */
-export const gen: typeof Effect.gen = function() {
-  const f = arguments.length === 1 ? arguments[0] : arguments[1].bind(arguments[0])
-  return suspend(() => {
+export const fromIterator = <Eff extends YieldWrap<Effect.Effect<any, any, any>>, AEff>(
+  iterator: LazyArg<Iterator<Eff, AEff, never>>
+): Effect.Effect<
+  AEff,
+  [Eff] extends [never] ? never : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E : never,
+  [Eff] extends [never] ? never : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R : never
+> =>
+  suspend(() => {
     const effect = new EffectPrimitive(OpCodes.OP_ITERATOR) as any
-    effect.effect_instruction_i0 = f(pipe)
+    effect.effect_instruction_i0 = iterator()
     return effect
   })
+
+/* @internal */
+export const gen: typeof Effect.gen = function() {
+  const f = arguments.length === 1 ? arguments[0] : arguments[1].bind(arguments[0])
+  return fromIterator(() => f(pipe))
 }
 
 /* @internal */
@@ -1894,17 +1878,17 @@ export const requestBlockLocally = <A>(
   self: BlockedRequests.RequestBlock,
   ref: FiberRef.FiberRef<A>,
   value: A
-): BlockedRequests.RequestBlock => _blockedRequests.reduce(self, LocallyReducer(ref, value))
+): BlockedRequests.RequestBlock => blockedRequests_.reduce(self, LocallyReducer(ref, value))
 
 const LocallyReducer = <A>(
   ref: FiberRef.FiberRef<A>,
   value: A
 ): BlockedRequests.RequestBlock.Reducer<BlockedRequests.RequestBlock> => ({
-  emptyCase: () => _blockedRequests.empty,
-  parCase: (left, right) => _blockedRequests.par(left, right),
-  seqCase: (left, right) => _blockedRequests.seq(left, right),
+  emptyCase: () => blockedRequests_.empty,
+  parCase: (left, right) => blockedRequests_.par(left, right),
+  seqCase: (left, right) => blockedRequests_.seq(left, right),
   singleCase: (dataSource, blockedRequest) =>
-    _blockedRequests.single(
+    blockedRequests_.single(
       resolverLocally(dataSource, ref, value),
       blockedRequest as any
     )
@@ -2007,8 +1991,8 @@ export const fiberRefUnsafeMakeRuntimeFlags = (
   initial: RuntimeFlags.RuntimeFlags
 ): FiberRef.FiberRef<RuntimeFlags.RuntimeFlags> =>
   fiberRefUnsafeMakePatch(initial, {
-    differ: _runtimeFlags.differ,
-    fork: _runtimeFlags.differ.empty
+    differ: runtimeFlags_.differ,
+    fork: runtimeFlags_.differ.empty
   })
 
 /** @internal */
@@ -3014,9 +2998,9 @@ export const contextWith = <R0, A>(
 ): Effect.Effect<A, never, R0> => map(context<R0>(), f)
 
 /* @internal */
-export const contextWithEffect = <R0, A, E, R>(
-  f: (context: Context.Context<R0>) => Effect.Effect<A, E, R>
-): Effect.Effect<A, E, R | R0> => flatMap(context<R0>(), f)
+export const contextWithEffect = <R2, A, E, R>(
+  f: (context: Context.Context<R2>) => Effect.Effect<A, E, R>
+): Effect.Effect<A, E, R | R2> => flatMap(context<R2>(), f)
 
 /* @internal */
 export const provideContext = dual<
@@ -3040,17 +3024,17 @@ export const provideSomeContext = dual<
 
 /* @internal */
 export const mapInputContext = dual<
-  <R0, R>(
-    f: (context: Context.Context<R0>) => Context.Context<R>
-  ) => <A, E>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R0>,
-  <A, E, R, R0>(
+  <R2, R>(
+    f: (context: Context.Context<R2>) => Context.Context<R>
+  ) => <A, E>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R2>,
+  <A, E, R, R2>(
     self: Effect.Effect<A, E, R>,
-    f: (context: Context.Context<R0>) => Context.Context<R>
-  ) => Effect.Effect<A, E, R0>
->(2, <A, E, R, R0>(
+    f: (context: Context.Context<R2>) => Context.Context<R>
+  ) => Effect.Effect<A, E, R2>
+>(2, <A, E, R, R2>(
   self: Effect.Effect<A, E, R>,
-  f: (context: Context.Context<R0>) => Context.Context<R>
-) => contextWithEffect((context: Context.Context<R0>) => provideContext(self, f(context))))
+  f: (context: Context.Context<R2>) => Context.Context<R>
+) => contextWithEffect((context: Context.Context<R2>) => provideContext(self, f(context))))
 
 // -----------------------------------------------------------------------------
 // Tracing
@@ -3062,14 +3046,11 @@ export const currentSpanFromFiber = <A, E>(fiber: Fiber.RuntimeFiber<A, E>): Opt
   return span !== undefined && span._tag === "Span" ? Option.some(span) : Option.none()
 }
 
-const NoopSpanProto: Tracer.Span = {
+const NoopSpanProto: Omit<Tracer.Span, "parent" | "name" | "context"> = {
   _tag: "Span",
   spanId: "noop",
   traceId: "noop",
-  name: "noop",
   sampled: false,
-  parent: Option.none(),
-  context: Context.empty(),
   status: {
     _tag: "Ended",
     startTime: BigInt(0),
@@ -3085,8 +3066,8 @@ const NoopSpanProto: Tracer.Span = {
 }
 
 /** @internal */
-export const noopSpan = (name: string): Tracer.Span => {
-  const span = Object.create(NoopSpanProto)
-  span.name = name
-  return span
-}
+export const noopSpan = (options: {
+  readonly name: string
+  readonly parent: Option.Option<Tracer.AnySpan>
+  readonly context: Context.Context<never>
+}): Tracer.Span => Object.assign(Object.create(NoopSpanProto), options)

package/src/internal/defaultServices.ts

@@ -64,29 +64,29 @@ export const currentTimeNanos: Effect.Effect<bigint> = clockWith((clock) => cloc
 
 /** @internal */
 export const withClock = dual<
-  <X extends Clock.Clock>(value: X) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <X extends Clock.Clock, A, E, R>(effect: Effect.Effect<A, E, R>, value: X) => Effect.Effect<A, E, R>
->(2, (effect, value) =>
+  <C extends Clock.Clock>(clock: C) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <C extends Clock.Clock, A, E, R>(effect: Effect.Effect<A, E, R>, clock: C) => Effect.Effect<A, E, R>
+>(2, (effect, c) =>
   core.fiberRefLocallyWith(
     currentServices,
-    Context.add(clock.clockTag, value)
+    Context.add(clock.clockTag, c)
   )(effect))
 
 // circular with ConfigProvider
 
 /** @internal */
 export const withConfigProvider = dual<
-  (value: ConfigProvider.ConfigProvider) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <A, E, R>(effect: Effect.Effect<A, E, R>, value: ConfigProvider.ConfigProvider) => Effect.Effect<A, E, R>
->(2, (effect, value) =>
+  (provider: ConfigProvider.ConfigProvider) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(self: Effect.Effect<A, E, R>, provider: ConfigProvider.ConfigProvider) => Effect.Effect<A, E, R>
+>(2, (self, provider) =>
   core.fiberRefLocallyWith(
     currentServices,
-    Context.add(configProvider.configProviderTag, value)
-  )(effect))
+    Context.add(configProvider.configProviderTag, provider)
+  )(self))
 
 /** @internal */
 export const configProviderWith = <A, E, R>(
-  f: (configProvider: ConfigProvider.ConfigProvider) => Effect.Effect<A, E, R>
+  f: (provider: ConfigProvider.ConfigProvider) => Effect.Effect<A, E, R>
 ): Effect.Effect<A, E, R> =>
   defaultServicesWith((services) => f(services.unsafeMap.get(configProvider.configProviderTag.key)))
 

package/src/internal/effect/circular.ts

@@ -32,7 +32,7 @@ import * as internalFiber from "../fiber.js"
 import * as fiberRuntime from "../fiberRuntime.js"
 import { globalScope } from "../fiberScope.js"
 import * as internalRef from "../ref.js"
-import * as _schedule from "../schedule.js"
+import * as schedule_ from "../schedule.js"
 import * as supervisor from "../supervisor.js"
 
 /** @internal */
@@ -480,7 +480,7 @@ export const scheduleForked = dual<
     self: Effect.Effect<A, E, R>,
     schedule: Schedule.Schedule<Out, unknown, R2>
   ) => Effect.Effect<Fiber.RuntimeFiber<Out, E>, never, R | R2 | Scope.Scope>
->(2, (self, schedule) => pipe(self, _schedule.schedule_Effect(schedule), forkScoped))
+>(2, (self, schedule) => pipe(self, schedule_.schedule_Effect(schedule), forkScoped))
 
 /** @internal */
 export const supervised = dual<
@@ -583,58 +583,63 @@ export const timeoutTo = dual<
       readonly duration: Duration.DurationInput
     }
   ) => Effect.Effect<B | B1, E, R>
->(2, (self, { duration, onSuccess, onTimeout }) =>
-  core.fiberIdWith((parentFiberId) =>
-    fiberRuntime.raceFibersWith(
-      self,
-      core.interruptible(effect.sleep(duration)),
-      {
-        onSelfWin: (winner, loser) =>
-          core.flatMap(
-            winner.await,
-            (exit) => {
-              if (exit._tag === "Success") {
-                return core.flatMap(
-                  winner.inheritAll,
-                  () =>
-                    core.as(
+>(
+  2,
+  (self, { duration, onSuccess, onTimeout }) =>
+    core.fiberIdWith((parentFiberId) =>
+      core.uninterruptibleMask((restore) =>
+        fiberRuntime.raceFibersWith(
+          restore(self),
+          core.interruptible(effect.sleep(duration)),
+          {
+            onSelfWin: (winner, loser) =>
+              core.flatMap(
+                winner.await,
+                (exit) => {
+                  if (exit._tag === "Success") {
+                    return core.flatMap(
+                      winner.inheritAll,
+                      () =>
+                        core.as(
+                          core.interruptAsFiber(loser, parentFiberId),
+                          onSuccess(exit.value)
+                        )
+                    )
+                  } else {
+                    return core.flatMap(
                       core.interruptAsFiber(loser, parentFiberId),
-                      onSuccess(exit.value)
+                      () => core.exitFailCause(exit.cause)
                     )
-                )
-              } else {
-                return core.flatMap(
-                  core.interruptAsFiber(loser, parentFiberId),
-                  () => core.exitFailCause(exit.cause)
-                )
-              }
-            }
-          ),
-        onOtherWin: (winner, loser) =>
-          core.flatMap(
-            winner.await,
-            (exit) => {
-              if (exit._tag === "Success") {
-                return core.flatMap(
-                  winner.inheritAll,
-                  () =>
-                    core.as(
+                  }
+                }
+              ),
+            onOtherWin: (winner, loser) =>
+              core.flatMap(
+                winner.await,
+                (exit) => {
+                  if (exit._tag === "Success") {
+                    return core.flatMap(
+                      winner.inheritAll,
+                      () =>
+                        core.as(
+                          core.interruptAsFiber(loser, parentFiberId),
+                          onTimeout()
+                        )
+                    )
+                  } else {
+                    return core.flatMap(
                       core.interruptAsFiber(loser, parentFiberId),
-                      onTimeout()
+                      () => core.exitFailCause(exit.cause)
                     )
-                )
-              } else {
-                return core.flatMap(
-                  core.interruptAsFiber(loser, parentFiberId),
-                  () => core.exitFailCause(exit.cause)
-                )
-              }
-            }
-          ),
-        otherScope: globalScope
-      }
+                  }
+                }
+              ),
+            otherScope: globalScope
+          }
+        )
+      )
     )
-  ))
+)
 
 // circular with Synchronized
 

package/src/internal/encoding/common.ts

@@ -23,6 +23,27 @@ export const DecodeException = (input: string, message?: string): Encoding.Decod
 /** @internal */
 export const isDecodeException = (u: unknown): u is Encoding.DecodeException => hasProperty(u, DecodeExceptionTypeId)
 
+/** @internal */
+export const EncodeExceptionTypeId: Encoding.EncodeExceptionTypeId = Symbol.for(
+  "effect/Encoding/errors/Encode"
+) as Encoding.EncodeExceptionTypeId
+
+/** @internal */
+export const EncodeException = (input: string, message?: string): Encoding.EncodeException => {
+  const out: Mutable<Encoding.EncodeException> = {
+    _tag: "EncodeException",
+    [EncodeExceptionTypeId]: EncodeExceptionTypeId,
+    input
+  }
+  if (isString(message)) {
+    out.message = message
+  }
+  return out
+}
+
+/** @internal */
+export const isEncodeException = (u: unknown): u is Encoding.EncodeException => hasProperty(u, EncodeExceptionTypeId)
+
 /** @interal */
 export const encoder = new TextEncoder()
 

package/src/internal/fiberRefs/patch.ts

@@ -4,7 +4,7 @@ import type * as FiberId from "../../FiberId.js"
 import type * as FiberRefs from "../../FiberRefs.js"
 import type * as FiberRefsPatch from "../../FiberRefsPatch.js"
 import { dual } from "../../Function.js"
-import * as _fiberRefs from "../fiberRefs.js"
+import * as fiberRefs_ from "../fiberRefs.js"
 
 /** @internal */
 export const OP_EMPTY = "Empty" as const
@@ -111,7 +111,7 @@ export const patch = dual<
         break
       }
       case OP_ADD: {
-        fiberRefs = _fiberRefs.updateAs(fiberRefs, {
+        fiberRefs = fiberRefs_.updateAs(fiberRefs, {
           fiberId,
           fiberRef: head.fiberRef,
           value: head.value
@@ -120,13 +120,13 @@ export const patch = dual<
         break
       }
       case OP_REMOVE: {
-        fiberRefs = _fiberRefs.delete_(fiberRefs, head.fiberRef)
+        fiberRefs = fiberRefs_.delete_(fiberRefs, head.fiberRef)
         patches = tail
         break
       }
       case OP_UPDATE: {
-        const value = _fiberRefs.getOrDefault(fiberRefs, head.fiberRef)
-        fiberRefs = _fiberRefs.updateAs(fiberRefs, {
+        const value = fiberRefs_.getOrDefault(fiberRefs, head.fiberRef)
+        fiberRefs = fiberRefs_.updateAs(fiberRefs, {
           fiberId,
           fiberRef: head.fiberRef,
           value: head.fiberRef.patch(head.patch)(value)