effect 3.22.0 → 3.22.1

package/dist/esm/internal/version.js

@@ -1,4 +1,4 @@
-let moduleVersion = "3.22.0";
+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.22.0",
+  "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/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
 

package/src/internal/stream/emit.ts

@@ -3,9 +3,8 @@ import * as Chunk from "../../Chunk.js"
 import * as Effect from "../../Effect.js"
 import * as Exit from "../../Exit.js"
 import { pipe } from "../../Function.js"
+import type * as Mailbox from "../../Mailbox.js"
 import * as Option from "../../Option.js"
-import type * as Queue from "../../Queue.js"
-import type * as Scheduler from "../../Scheduler.js"
 import type * as Emit from "../../StreamEmit.js"
 
 /** @internal */
@@ -48,53 +47,23 @@ export const make = <R, E, A, B>(
 }
 
 /** @internal */
-export const makePush = <E, A>(
-  queue: Queue.Queue<Array<A> | Exit.Exit<void, E>>,
-  scheduler: Scheduler.Scheduler
-): Emit.EmitOpsPush<E, A> => {
+export const makePush = <E, A>(mailbox: Mailbox.Mailbox<A, E>): Emit.EmitOpsPush<E, A> => {
   let finished = false
-  let buffer: Array<A> = []
-  let running = false
   function array(items: ReadonlyArray<A>) {
     if (finished) return false
-    if (items.length <= 50_000) {
-      buffer.push.apply(buffer, items as Array<A>)
-    } else {
-      for (let i = 0; i < items.length; i++) {
-        buffer.push(items[0])
-      }
-    }
-    if (!running) {
-      running = true
-      scheduler.scheduleTask(flush, 0)
-    }
-    return true
-  }
-  function flush() {
-    running = false
-    if (buffer.length > 0) {
-      queue.unsafeOffer(buffer)
-      buffer = []
-    }
+    return Chunk.isEmpty(mailbox.unsafeOfferAll(items))
   }
   function done(exit: Exit.Exit<A, E>) {
     if (finished) return
     finished = true
     if (exit._tag === "Success") {
-      buffer.push(exit.value)
+      mailbox.unsafeOffer(exit.value)
     }
-    flush()
-    queue.unsafeOffer(exit._tag === "Success" ? Exit.void : exit)
+    mailbox.unsafeDone(exit._tag === "Success" ? Exit.void : exit)
   }
   return {
     single(value: A) {
-      if (finished) return false
-      buffer.push(value)
-      if (!running) {
-        running = true
-        scheduler.scheduleTask(flush, 0)
-      }
-      return true
+      return finished ? false : mailbox.unsafeOffer(value)
     },
     array,
     chunk(chunk) {
@@ -104,8 +73,7 @@ export const makePush = <E, A>(
     end() {
       if (finished) return
       finished = true
-      flush()
-      queue.unsafeOffer(Exit.void)
+      mailbox.unsafeDone(Exit.void)
     },
     halt(cause: Cause.Cause<E>) {
       return done(Exit.failCause(cause))

package/src/internal/stream.ts

@@ -11,11 +11,11 @@ import * as Equal from "../Equal.js"
 import type { ExecutionPlan } from "../ExecutionPlan.js"
 import * as Exit from "../Exit.js"
 import * as Fiber from "../Fiber.js"
-import * as FiberRef from "../FiberRef.js"
 import type { LazyArg } from "../Function.js"
 import { constTrue, dual, identity, pipe } from "../Function.js"
 import * as internalExecutionPlan from "../internal/executionPlan.js"
 import * as Layer from "../Layer.js"
+import type * as Mailbox from "../Mailbox.js"
 import * as MergeDecision from "../MergeDecision.js"
 import * as Option from "../Option.js"
 import type * as Order from "../Order.js"
@@ -42,7 +42,11 @@ import * as channel from "./channel.js"
 import * as channelExecutor from "./channel/channelExecutor.js"
 import * as MergeStrategy from "./channel/mergeStrategy.js"
 import * as core from "./core-stream.js"
+import * as effectCore from "./core.js"
 import * as doNotation from "./doNotation.js"
+import * as circular from "./effect/circular.js"
+import * as fiberRuntime from "./fiberRuntime.js"
+import * as mailbox from "./mailbox.js"
 import { RingBuffer } from "./ringBuffer.js"
 import * as InternalSchedule from "./schedule.js"
 import * as sink_ from "./sink.js"
@@ -592,21 +596,19 @@ export const asyncEffect = <A, E = never, R = never>(
     fromChannel
   )
 
-const queueFromBufferOptionsPush = <A, E>(
+const mailboxFromBufferOptionsPush = <A, E>(
   options?: { readonly bufferSize: "unbounded" } | {
     readonly bufferSize?: number | undefined
     readonly strategy?: "dropping" | "sliding" | undefined
   } | undefined
-): Effect.Effect<Queue.Queue<Array<A> | Exit.Exit<void, E>>> => {
+): Effect.Effect<Mailbox.Mailbox<A, E>> => {
   if (options?.bufferSize === "unbounded" || (options?.bufferSize === undefined && options?.strategy === undefined)) {
-    return Queue.unbounded()
-  }
-  switch (options?.strategy) {
-    case "sliding":
-      return Queue.sliding(options.bufferSize ?? 16)
-    default:
-      return Queue.dropping(options?.bufferSize ?? 16)
+    return mailbox.make()
   }
+  return mailbox.make({
+    capacity: options?.bufferSize ?? 16,
+    strategy: options?.strategy ?? "dropping"
+  })
 }
 
 /** @internal */
@@ -620,21 +622,12 @@ export const asyncPush = <A, E = never, R = never>(
   } | undefined
 ): Stream.Stream<A, E, Exclude<R, Scope.Scope>> =>
   Effect.acquireRelease(
-    queueFromBufferOptionsPush<A, E>(options),
-    Queue.shutdown
+    mailboxFromBufferOptionsPush<A, E>(options),
+    (mailbox) => mailbox.shutdown
   ).pipe(
-    Effect.tap((queue) =>
-      FiberRef.getWith(FiberRef.currentScheduler, (scheduler) => register(emit.makePush(queue, scheduler)))
-    ),
-    Effect.map((queue) => {
-      const loop: Channel.Channel<Chunk.Chunk<A>, unknown, E> = core.flatMap(Queue.take(queue), (item) =>
-        Exit.isExit(item)
-          ? Exit.isSuccess(item) ? core.void : core.failCause(item.cause)
-          : channel.zipRight(core.write(Chunk.unsafeFromArray(item)), loop))
-      return loop
-    }),
-    channel.unwrapScoped,
-    fromChannel
+    Effect.tap((mailbox) => register(emit.makePush(mailbox))),
+    Effect.map(mailboxToStream),
+    unwrapScoped
   )
 
 /** @internal */
@@ -3011,6 +3004,51 @@ export const toChannel = <A, E, R>(
   }
 }
 
+/** @internal */
+export const mailboxToStream = <A, E>(self: Mailbox.ReadonlyMailbox<A, E>): Stream.Stream<A, E> =>
+  fromChannel(mailbox.toChannel(self))
+
+/** @internal */
+export const mailboxFromStream: {
+  (options?: {
+    readonly capacity?: number | undefined
+    readonly strategy?: "suspend" | "dropping" | "sliding" | undefined
+  }): <A, E, R>(self: Stream.Stream<A, E, R>) => Effect.Effect<Mailbox.ReadonlyMailbox<A, E>, never, R | Scope.Scope>
+  <A, E, R>(
+    self: Stream.Stream<A, E, R>,
+    options?: {
+      readonly capacity?: number | undefined
+      readonly strategy?: "suspend" | "dropping" | "sliding" | undefined
+    }
+  ): Effect.Effect<Mailbox.ReadonlyMailbox<A, E>, never, R | Scope.Scope>
+} = dual((args) => isStream(args[0]), <A, E, R>(
+  self: Stream.Stream<A, E, R>,
+  options?: {
+    readonly capacity?: number | undefined
+    readonly strategy?: "suspend" | "dropping" | "sliding" | undefined
+  }
+): Effect.Effect<Mailbox.ReadonlyMailbox<A, E>, never, R | Scope.Scope> =>
+  effectCore.tap(
+    fiberRuntime.acquireRelease(
+      mailbox.make<A, E>(options),
+      (mailbox) => mailbox.shutdown
+    ),
+    (mailbox) => {
+      const writer: Channel.Channel<never, Chunk.Chunk<A>, never, E> = core.readWithCause({
+        onInput: (input: Chunk.Chunk<A>) => core.flatMap(mailbox.offerAll(input), () => writer),
+        onFailure: (cause: Cause.Cause<E>) => mailbox.failCause(cause),
+        onDone: () => mailbox.end
+      })
+      return fiberRuntime.scopeWith((scope) =>
+        toChannel(self).pipe(
+          core.pipeTo(writer),
+          channelExecutor.runIn(scope),
+          circular.forkIn(scope)
+        )
+      )
+    }
+  ))
+
 /** @internal */
 export const fromChunk = <A>(chunk: Chunk.Chunk<A>): Stream.Stream<A> =>
   new StreamImpl(Chunk.isEmpty(chunk) ? core.void : core.write(chunk))

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "3.22.0"
+let moduleVersion = "3.22.1"
 
 export const getCurrentVersion = () => moduleVersion