effect 3.21.5 → 3.22.1

package/dist/esm/internal/version.js

@@ -1,4 +1,4 @@
-let moduleVersion = "3.21.5";
+let moduleVersion = "3.22.1";
 export const getCurrentVersion = () => moduleVersion;
 export const setCurrentVersion = version => {
   moduleVersion = version;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect",
-  "version": "3.21.5",
+  "version": "3.22.1",
   "description": "The missing standard library for TypeScript, for writing production-grade software.",
   "license": "MIT",
   "repository": {

package/src/Context.ts

@@ -165,7 +165,7 @@ export declare namespace Tag {
 }
 
 /**
- * Creates a new `Tag` instance with an optional key parameter.
+ * Creates a new `Tag` instance with the specified key.
  *
  * @example
  * ```ts

package/src/Graph.ts

@@ -872,6 +872,29 @@ export const mapEdges = <N, E, T extends Kind = "directed">(
   }
 }
 
+/** @internal */
+const rebuildAdjacency = <N, E, T extends Kind = "directed">(
+  mutable: MutableGraph<N, E, T>
+): void => {
+  mutable.adjacency.clear()
+  mutable.reverseAdjacency.clear()
+
+  for (const nodeIndex of mutable.nodes.keys()) {
+    mutable.adjacency.set(nodeIndex, [])
+    mutable.reverseAdjacency.set(nodeIndex, [])
+  }
+
+  for (const [edgeIndex, edgeData] of mutable.edges) {
+    mutable.adjacency.get(edgeData.source)!.push(edgeIndex)
+    mutable.reverseAdjacency.get(edgeData.target)!.push(edgeIndex)
+
+    if (mutable.type === "undirected") {
+      mutable.adjacency.get(edgeData.target)!.push(edgeIndex)
+      mutable.reverseAdjacency.get(edgeData.source)!.push(edgeIndex)
+    }
+  }
+}
+
 /**
  * Reverses all edge directions in a mutable graph by swapping source and target nodes.
  *
@@ -898,6 +921,10 @@ export const mapEdges = <N, E, T extends Kind = "directed">(
 export const reverse = <N, E, T extends Kind = "directed">(
   mutable: MutableGraph<N, E, T>
 ): void => {
+  if (mutable.type === "undirected") {
+    return
+  }
+
   // Reverse all edges by swapping source and target
   for (const [index, edgeData] of mutable.edges) {
     mutable.edges.set(index, {
@@ -907,22 +934,7 @@ export const reverse = <N, E, T extends Kind = "directed">(
     })
   }
 
-  // Clear and rebuild adjacency lists with reversed directions
-  mutable.adjacency.clear()
-  mutable.reverseAdjacency.clear()
-
-  // Rebuild adjacency lists with reversed directions
-  for (const [edgeIndex, edgeData] of mutable.edges) {
-    // Add to forward adjacency (source -> target)
-    const sourceEdges = mutable.adjacency.get(edgeData.source) || []
-    sourceEdges.push(edgeIndex)
-    mutable.adjacency.set(edgeData.source, sourceEdges)
-
-    // Add to reverse adjacency (target <- source)
-    const targetEdges = mutable.reverseAdjacency.get(edgeData.target) || []
-    targetEdges.push(edgeIndex)
-    mutable.reverseAdjacency.set(edgeData.target, targetEdges)
-  }
+  rebuildAdjacency(mutable)
 
   // Invalidate cycle flag since edge directions changed
   mutable.isAcyclic = Option.none()
@@ -1452,8 +1464,11 @@ export const hasEdge = <N, E, T extends Kind = "directed">(
   // Check if any edge in the adjacency list connects to the target
   for (const edgeIndex of adjacencyList) {
     const edge = graph.edges.get(edgeIndex)
-    if (edge !== undefined && edge.target === target) {
-      return true
+    if (edge !== undefined) {
+      const neighbor = graph.type === "undirected" && edge.target === source ? edge.source : edge.target
+      if (neighbor === target) {
+        return true
+      }
     }
   }
 
@@ -1489,6 +1504,31 @@ export const edgeCount = <N, E, T extends Kind = "directed">(
   graph: Graph<N, E, T> | MutableGraph<N, E, T>
 ): number => graph.edges.size
 
+const getDirectedNeighbors = <N, E>(
+  graph: Graph<N, E, "directed"> | MutableGraph<N, E, "directed">,
+  nodeIndex: NodeIndex,
+  direction: Direction
+): Array<NodeIndex> => {
+  const adjacencyMap = direction === "incoming"
+    ? graph.reverseAdjacency
+    : graph.adjacency
+
+  const adjacencyList = adjacencyMap.get(nodeIndex)
+  if (adjacencyList === undefined) {
+    return []
+  }
+
+  const result: Array<NodeIndex> = []
+  for (const edgeIndex of adjacencyList) {
+    const edge = graph.edges.get(edgeIndex)
+    if (edge !== undefined) {
+      result.push(direction === "incoming" ? edge.source : edge.target)
+    }
+  }
+
+  return result
+}
+
 /**
  * Returns the neighboring nodes (targets of outgoing edges) for a given node.
  *
@@ -1527,24 +1567,47 @@ export const neighbors = <N, E, T extends Kind = "directed">(
     return getUndirectedNeighbors(graph as any, nodeIndex)
   }
 
-  const adjacencyList = graph.adjacency.get(nodeIndex)
-  if (adjacencyList === undefined) {
-    return []
-  }
+  return getDirectedNeighbors(graph as Graph<N, E, "directed"> | MutableGraph<N, E, "directed">, nodeIndex, "outgoing")
+}
 
-  const result: Array<NodeIndex> = []
-  for (const edgeIndex of adjacencyList) {
-    const edge = graph.edges.get(edgeIndex)
-    if (edge !== undefined) {
-      result.push(edge.target)
-    }
+/**
+ * Returns the outgoing neighbor node indices for a node in a directed graph.
+ *
+ * Throws a `GraphError` when used with an undirected graph.
+ *
+ * @since 3.22.0
+ * @category queries
+ */
+export const successors = <N, E>(
+  graph: Graph<N, E, "directed"> | MutableGraph<N, E, "directed">,
+  nodeIndex: NodeIndex
+): Array<NodeIndex> => {
+  if ((graph as Graph<N, E, Kind> | MutableGraph<N, E, Kind>).type === "undirected") {
+    throw new GraphError({ message: "Cannot get successors of undirected graph" })
   }
+  return getDirectedNeighbors(graph, nodeIndex, "outgoing")
+}
 
-  return result
+/**
+ * Returns the incoming neighbor node indices for a node in a directed graph.
+ *
+ * Throws a `GraphError` when used with an undirected graph.
+ *
+ * @since 3.22.0
+ * @category queries
+ */
+export const predecessors = <N, E>(
+  graph: Graph<N, E, "directed"> | MutableGraph<N, E, "directed">,
+  nodeIndex: NodeIndex
+): Array<NodeIndex> => {
+  if ((graph as Graph<N, E, Kind> | MutableGraph<N, E, Kind>).type === "undirected") {
+    throw new GraphError({ message: "Cannot get predecessors of undirected graph" })
+  }
+  return getDirectedNeighbors(graph, nodeIndex, "incoming")
 }
 
 /**
- * Get neighbors of a node in a specific direction for bidirectional traversal.
+ * Get directed neighbors of a node in a specific direction.
  *
  * @example
  * ```ts
@@ -1566,36 +1629,19 @@ export const neighbors = <N, E, T extends Kind = "directed">(
  * const incoming = Graph.neighborsDirected(graph, nodeB, "incoming")
  * ```
  *
+ * @deprecated Use {@link successors} for outgoing neighbors or {@link predecessors} for incoming neighbors.
  * @since 3.18.0
  * @category queries
  */
-export const neighborsDirected = <N, E, T extends Kind = "directed">(
-  graph: Graph<N, E, T> | MutableGraph<N, E, T>,
+export const neighborsDirected = <N, E>(
+  graph: Graph<N, E, "directed"> | MutableGraph<N, E, "directed">,
   nodeIndex: NodeIndex,
   direction: Direction
 ): Array<NodeIndex> => {
-  const adjacencyMap = direction === "incoming"
-    ? graph.reverseAdjacency
-    : graph.adjacency
-
-  const adjacencyList = adjacencyMap.get(nodeIndex)
-  if (adjacencyList === undefined) {
-    return []
-  }
-
-  const result: Array<NodeIndex> = []
-  for (const edgeIndex of adjacencyList) {
-    const edge = graph.edges.get(edgeIndex)
-    if (edge !== undefined) {
-      // For incoming direction, we want the source node instead of target
-      const neighborNode = direction === "incoming"
-        ? edge.source
-        : edge.target
-      result.push(neighborNode)
-    }
+  if ((graph as Graph<N, E, Kind> | MutableGraph<N, E, Kind>).type === "undirected") {
+    throw new GraphError({ message: "Cannot get directed neighbors of undirected graph" })
   }
-
-  return result
+  return getDirectedNeighbors(graph, nodeIndex, direction)
 }
 
 // =============================================================================
@@ -1990,7 +2036,11 @@ export const isAcyclic = <N, E, T extends Kind = "directed">(
         recursionStack.add(node)
 
         // Get neighbors for this node
-        const nodeNeighbors = Array.from(neighborsDirected(graph, node, "outgoing"))
+        const nodeNeighbors = getDirectedNeighbors(
+          graph as Graph<N, E, "directed"> | MutableGraph<N, E, "directed">,
+          node,
+          "outgoing"
+        )
         stack[stack.length - 1] = [node, nodeNeighbors, 0, false]
         continue
       }
@@ -2141,7 +2191,7 @@ const getTraversalNeighbors = <N, E, T extends Kind>(
 ): Array<NodeIndex> =>
   graph.type === "undirected"
     ? getUndirectedNeighbors(graph as any, nodeIndex)
-    : neighborsDirected(graph, nodeIndex, direction)
+    : getDirectedNeighbors(graph as Graph<N, E, "directed"> | MutableGraph<N, E, "directed">, nodeIndex, direction)
 
 const getTraversableNeighbor = <N, E, T extends Kind>(
   graph: Graph<N, E, T> | MutableGraph<N, E, T>,
@@ -2231,9 +2281,13 @@ export const connectedComponents = <N, E>(
  * @since 3.18.0
  * @category algorithms
  */
-export const stronglyConnectedComponents = <N, E, T extends Kind = "directed">(
-  graph: Graph<N, E, T> | MutableGraph<N, E, T>
+export const stronglyConnectedComponents = <N, E>(
+  graph: Graph<N, E, "directed"> | MutableGraph<N, E, "directed">
 ): Array<Array<NodeIndex>> => {
+  if ((graph as Graph<N, E, Kind> | MutableGraph<N, E, Kind>).type === "undirected") {
+    throw new GraphError({ message: "Cannot find strongly connected components of undirected graph" })
+  }
+
   const visited = new Set<NodeIndex>()
   const finishOrder: Array<NodeIndex> = []
   // Iterate directly over node keys
@@ -2259,7 +2313,7 @@ export const stronglyConnectedComponents = <N, E, T extends Kind = "directed">(
         }
 
         visited.add(node)
-        const nodeNeighborsList = neighbors(graph, node)
+        const nodeNeighborsList = getDirectedNeighbors(graph, node, "outgoing")
         stack[stack.length - 1] = [node, nodeNeighborsList, 0, false]
         continue
       }
@@ -2377,6 +2431,22 @@ export interface BellmanFordConfig<E> {
   cost: (edgeData: E) => number
 }
 
+const validateNonNegativeEdgeWeights = <N, E, T extends Kind = "directed">(
+  graph: Graph<N, E, T> | MutableGraph<N, E, T>,
+  cost: (edgeData: E) => number,
+  algorithm: string
+): Map<EdgeIndex, number> => {
+  const edgeWeights = new Map<EdgeIndex, number>()
+  for (const [edgeIndex, edgeData] of graph.edges) {
+    const weight = cost(edgeData.data)
+    if (weight < 0 || Number.isNaN(weight)) {
+      throw new GraphError({ message: `${algorithm} requires non-negative edge weights` })
+    }
+    edgeWeights.set(edgeIndex, weight)
+  }
+  return edgeWeights
+}
+
 /**
  * Find the shortest path between two nodes using Dijkstra's algorithm.
  *
@@ -2419,6 +2489,8 @@ export const dijkstra = <N, E, T extends Kind = "directed">(
     throw missingNode(target)
   }
 
+  const edgeWeights = validateNonNegativeEdgeWeights(graph, cost, "Dijkstra's algorithm")
+
   // Early return if source equals target
   if (source === target) {
     return Option.some({
@@ -2479,12 +2551,7 @@ export const dijkstra = <N, E, T extends Kind = "directed">(
         const edge = graph.edges.get(edgeIndex)
         if (edge !== undefined) {
           const neighbor = getTraversableNeighbor(graph, currentNode, edge)
-          const weight = cost(edge.data)
-
-          // Validate non-negative weights
-          if (weight < 0) {
-            throw new Error(`Dijkstra's algorithm requires non-negative edge weights, found ${weight}`)
-          }
+          const weight = edgeWeights.get(edgeIndex)!
 
           const newDistance = currentDistance + weight
           const neighborDistance = distances.get(neighbor)!
@@ -2738,6 +2805,8 @@ export const astar = <N, E, T extends Kind = "directed">(
     throw missingNode(target)
   }
 
+  const edgeWeights = validateNonNegativeEdgeWeights(graph, cost, "A* algorithm")
+
   // Early return if source equals target
   if (source === target) {
     return Option.some({
@@ -2813,12 +2882,7 @@ export const astar = <N, E, T extends Kind = "directed">(
         const edge = graph.edges.get(edgeIndex)
         if (edge !== undefined) {
           const neighbor = getTraversableNeighbor(graph, currentNode, edge)
-          const weight = cost(edge.data)
-
-          // Validate non-negative weights
-          if (weight < 0) {
-            throw new Error(`A* algorithm requires non-negative edge weights, found ${weight}`)
-          }
+          const weight = edgeWeights.get(edgeIndex)!
 
           const tentativeGScore = currentGScore + weight
           const neighborGScore = gScore.get(neighbor)!
@@ -3497,6 +3561,7 @@ export const topo = <N, E, T extends Kind = "directed">(
     [Symbol.iterator]: () => {
       const inDegree = new Map<NodeIndex, number>()
       const remaining = new Set<NodeIndex>()
+      const initialSet = new Set(initials)
       const queue = [...initials]
 
       // Initialize in-degree counts
@@ -3511,12 +3576,15 @@ export const topo = <N, E, T extends Kind = "directed">(
         inDegree.set(edgeData.target, currentInDegree + 1)
       }
 
-      // Add nodes with zero in-degree to queue if no initials provided
-      if (initials.length === 0) {
-        for (const [nodeIndex, degree] of inDegree) {
-          if (degree === 0) {
-            queue.push(nodeIndex)
-          }
+      for (const nodeIndex of initials) {
+        if (inDegree.get(nodeIndex)! !== 0) {
+          throw new GraphError({ message: `Initial node ${nodeIndex} has incoming edges` })
+        }
+      }
+
+      for (const [nodeIndex, degree] of inDegree) {
+        if (degree === 0 && !initialSet.has(nodeIndex)) {
+          queue.push(nodeIndex)
         }
       }
 
@@ -3528,7 +3596,11 @@ export const topo = <N, E, T extends Kind = "directed">(
             remaining.delete(current)
 
             // Process outgoing edges, reducing in-degree of targets
-            const neighbors = neighborsDirected(graph, current, "outgoing")
+            const neighbors = getDirectedNeighbors(
+              graph as Graph<N, E, "directed"> | MutableGraph<N, E, "directed">,
+              current,
+              "outgoing"
+            )
             for (const neighbor of neighbors) {
               if (remaining.has(neighbor)) {
                 const currentInDegree = inDegree.get(neighbor) || 0

package/src/Mailbox.ts

@@ -9,6 +9,7 @@ import type { Effect } from "./Effect.js"
 import type { Exit } from "./Exit.js"
 import type { Inspectable } from "./Inspectable.js"
 import * as internal from "./internal/mailbox.js"
+import * as internalStream from "./internal/stream.js"
 import type { Option } from "./Option.js"
 import { hasProperty } from "./Predicate.js"
 import type { Scope } from "./Scope.js"
@@ -258,7 +259,7 @@ export const toChannel: <A, E>(self: ReadonlyMailbox<A, E>) => Channel<Chunk<A>,
  * @experimental
  * @category conversions
  */
-export const toStream: <A, E>(self: ReadonlyMailbox<A, E>) => Stream<A, E> = internal.toStream
+export const toStream: <A, E>(self: ReadonlyMailbox<A, E>) => Stream<A, E> = internalStream.mailboxToStream
 
 /**
  * Create a `ReadonlyMailbox` from a `Stream`.
@@ -295,4 +296,4 @@ export const fromStream: {
      readonly strategy?: "suspend" | "dropping" | "sliding" | undefined
    }
   ): Effect<ReadonlyMailbox<A, E>, never, R | Scope>
-} = internal.fromStream
+} = internalStream.mailboxFromStream

package/src/ParseResult.ts

@@ -914,6 +914,24 @@ const go = (ast: AST.AST, isDecoding: boolean): Parser => {
     case "Enums":
       return fromRefinement(ast, (u): u is any => ast.enums.some(([_, value]) => value === u))
     case "TemplateLiteral": {
+      if (ast.spans.every((span) => AST.isStringKeyword(span.type))) {
+        return fromRefinement(ast, (u): u is any => {
+          if (!Predicate.isString(u) || !u.startsWith(ast.head)) {
+            return false
+          }
+          let position = ast.head.length
+          for (let i = 0; i < ast.spans.length - 1; i++) {
+            const literal = ast.spans[i].literal
+            const index = u.indexOf(literal, position)
+            if (index === -1) {
+              return false
+            }
+            position = index + literal.length
+          }
+          const literal = ast.spans[ast.spans.length - 1].literal
+          return u.endsWith(literal) && u.length - literal.length >= position
+        })
+      }
       const regex = AST.getTemplateLiteralRegExp(ast)
       return fromRefinement(ast, (u): u is any => Predicate.isString(u) && regex.test(u))
     }

package/src/internal/config.ts

@@ -39,6 +39,7 @@ export type ConfigPrimitive =
   | MapOrFail
   | Nested
   | Primitive
+  | RedactedConfig
   | Sequence
   | Table
   | Zipped
@@ -125,6 +126,14 @@ export interface Primitive extends
   }>
 {}
 
+/** @internal */
+export interface RedactedConfig extends
+  Op<OpCodes.OP_REDACTED, {
+    readonly original: Config.Config<unknown>
+    redact(value: unknown): Redacted.Redacted<unknown>
+  }>
+{}
+
 /** @internal */
 export interface Sequence extends
   Op<OpCodes.OP_SEQUENCE, {
@@ -475,7 +484,11 @@ export const redacted = <A>(
   nameOrConfig?: string | Config.Config<A>
 ): Config.Config<Redacted.Redacted<A | string>> => {
   const config: Config.Config<A | string> = isConfig(nameOrConfig) ? nameOrConfig : string(nameOrConfig)
-  return map(config, redacted_.make)
+  const redacted = Object.create(proto)
+  redacted._tag = OpCodes.OP_REDACTED
+  redacted.original = config
+  redacted.redact = redacted_.make
+  return redacted
 }
 
 /** @internal */

package/src/internal/configProvider.ts

@@ -236,6 +236,18 @@ const appendConfigPath = (path: ReadonlyArray<string>, config: Config.Config<unk
   return path
 }
 
+const RedactedConfigErrorReducer: ConfigError.ConfigErrorReducer<unknown, ConfigError.ConfigError> = {
+  andCase: (_, left, right) => configError.And(left, right),
+  orCase: (_, left, right) => configError.Or(left, right),
+  invalidDataCase: (_, path) => configError.InvalidData(path, "<redacted>"),
+  missingDataCase: (_, path) => configError.MissingData(path, "<redacted>"),
+  sourceUnavailableCase: (_, path, _message, cause) => configError.SourceUnavailable(path, "<redacted>", cause),
+  unsupportedCase: (_, path) => configError.Unsupported(path, "<redacted>")
+}
+
+const redactConfigError = (error: ConfigError.ConfigError): ConfigError.ConfigError =>
+  configError.reduceWithContext(error, void 0, RedactedConfigErrorReducer)
+
 const fromFlatLoop = <A>(
   flat: ConfigProvider.ConfigProvider.Flat,
   prefix: ReadonlyArray<string>,
@@ -320,6 +332,15 @@ const fromFlatLoop = <A>(
         )
       ) as unknown as Effect.Effect<Array<A>, ConfigError.ConfigError>
     }
+    case OpCodes.OP_REDACTED: {
+      return core.suspend(() =>
+        pipe(
+          fromFlatLoop(flat, prefix, op.original, split),
+          core.mapError(redactConfigError),
+          core.map(Arr.map(op.redact))
+        )
+      ) as unknown as Effect.Effect<Array<A>, ConfigError.ConfigError>
+    }
     case OpCodes.OP_SEQUENCE: {
       return pipe(
         pathPatch.patch(prefix, flat.patch),
@@ -719,7 +740,9 @@ interface JsonArray extends Array<string | number | boolean | null | JsonArray |
 export const fromJson = (json: unknown): ConfigProvider.ConfigProvider => {
   const hiddenDelimiter = "\ufeff"
   const indexedEntries = Arr.map(
-    getIndexedEntries(json as JsonMap),
+    getIndexedEntries(json as JsonMap).filter(([path]) =>
+      path.every((component) => component._tag === "KeyIndex" || !component.name.includes(hiddenDelimiter))
+    ),
     ([key, value]): [string, string] => [configPathToString(key).join(hiddenDelimiter), value]
   )
   return fromMap(new Map(indexedEntries), {

package/src/internal/effect/circular.ts

@@ -604,26 +604,27 @@ export const timeoutTo = dual<
     core.fiberIdWith((parentFiberId) =>
       core.uninterruptibleMask((restore) =>
         fiberRuntime.raceFibersWith(
-          restore(self),
+          core.exit(restore(self)),
           core.interruptible(effect.sleep(duration)),
           {
             onSelfWin: (winner, loser) =>
               core.flatMap(
                 winner.await,
                 (exit) => {
-                  if (exit._tag === "Success") {
+                  const selfExit = core.exitFlatten(exit)
+                  if (selfExit._tag === "Success") {
                     return core.flatMap(
                       winner.inheritAll,
                       () =>
                         core.as(
                           core.interruptAsFiber(loser, parentFiberId),
-                          onSuccess(exit.value)
+                          onSuccess(selfExit.value)
                         )
                     )
                   } else {
                     return core.flatMap(
                       core.interruptAsFiber(loser, parentFiberId),
-                      () => core.exitFailCause(exit.cause)
+                      () => core.exitFailCause(selfExit.cause)
                     )
                   }
                 }

package/src/internal/mailbox.ts

@@ -13,15 +13,9 @@ import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import { hasProperty } from "../Predicate.js"
 import type { Scheduler } from "../Scheduler.js"
-import type { Scope } from "../Scope.js"
-import type { Stream } from "../Stream.js"
 import * as channel from "./channel.js"
-import * as channelExecutor from "./channel/channelExecutor.js"
 import * as coreChannel from "./core-stream.js"
 import * as core from "./core.js"
-import * as circular from "./effect/circular.js"
-import * as fiberRuntime from "./fiberRuntime.js"
-import * as stream from "./stream.js"
 
 /** @internal */
 export const TypeId: Api.TypeId = Symbol.for("effect/Mailbox") as Api.TypeId
@@ -255,8 +249,17 @@ class MailboxImpl<A, E> extends Effectable.Class<readonly [messages: Chunk.Chunk
         return core.exitAs(this.state.exit, constDone)
       } else if (n <= 0) {
         return core.succeed([empty, false])
+      } else if (
+        this.capacity <= 0 && this.messages.length === 0 && this.messagesChunk.length === 0 &&
+        this.state.offers.size > 0
+      ) {
+        this.capacity = 1
+        this.releaseCapacity()
+        this.capacity = 0
+        const messages = Chunk.of(this.messages.pop()!)
+        return core.succeed([messages, this.releaseCapacity()])
       }
-      n = Math.min(n, this.capacity)
+      n = Math.min(n, this.capacity || 1)
       let messages: Chunk.Chunk<A>
       if (n <= this.messagesChunk.length) {
         messages = Chunk.take(this.messagesChunk, n)
@@ -288,7 +291,9 @@ class MailboxImpl<A, E> extends Effectable.Class<readonly [messages: Chunk.Chunk
       this.capacity = 1
       this.releaseCapacity()
       this.capacity = 0
-      return this.messages.length > 0 ? core.exitSucceed(this.messages.pop()!) : undefined
+      const message = this.messages.pop()!
+      this.releaseCapacity()
+      return core.exitSucceed(message)
     } else {
       return undefined
     }
@@ -515,47 +520,3 @@ export const toChannel = <A, E>(self: Api.ReadonlyMailbox<A, E>): Channel<Chunk.
       : channel.zipRight(coreChannel.write(messages), loop))
   return loop
 }
-
-/** @internal */
-export const toStream = <A, E>(self: Api.ReadonlyMailbox<A, E>): Stream<A, E> => stream.fromChannel(toChannel(self))
-
-/** @internal */
-export const fromStream: {
-  (options?: {
-    readonly capacity?: number | undefined
-    readonly strategy?: "suspend" | "dropping" | "sliding" | undefined
-  }): <A, E, R>(self: Stream<A, E, R>) => Effect<Api.ReadonlyMailbox<A, E>, never, R | Scope>
-  <A, E, R>(
-    self: Stream<A, E, R>,
-    options?: {
-      readonly capacity?: number | undefined
-      readonly strategy?: "suspend" | "dropping" | "sliding" | undefined
-    }
-  ): Effect<Api.ReadonlyMailbox<A, E>, never, R | Scope>
-} = dual((args) => stream.isStream(args[0]), <A, E, R>(
-  self: Stream<A, E, R>,
-  options?: {
-    readonly capacity?: number | undefined
-    readonly strategy?: "suspend" | "dropping" | "sliding" | undefined
-  }
-): Effect<Api.ReadonlyMailbox<A, E>, never, R | Scope> =>
-  core.tap(
-    fiberRuntime.acquireRelease(
-      make<A, E>(options),
-      (mailbox) => mailbox.shutdown
-    ),
-    (mailbox) => {
-      const writer: Channel<never, Chunk.Chunk<A>, never, E> = coreChannel.readWithCause({
-        onInput: (input: Chunk.Chunk<A>) => coreChannel.flatMap(mailbox.offerAll(input), () => writer),
-        onFailure: (cause: Cause<E>) => mailbox.failCause(cause),
-        onDone: () => mailbox.end
-      })
-      return fiberRuntime.scopeWith((scope) =>
-        stream.toChannel(self).pipe(
-          coreChannel.pipeTo(writer),
-          channelExecutor.runIn(scope),
-          circular.forkIn(scope)
-        )
-      )
-    }
-  ))

package/src/internal/opCodes/config.ts

@@ -46,6 +46,12 @@ export type OP_PRIMITIVE = typeof OP_PRIMITIVE
 /** @internal */
 export const OP_PRIMITIVE = "Primitive" as const
 
+/** @internal */
+export type OP_REDACTED = typeof OP_REDACTED
+
+/** @internal */
+export const OP_REDACTED = "Redacted" as const
+
 /** @internal */
 export type OP_SEQUENCE = typeof OP_SEQUENCE