effect 3.2.9 → 3.3.1

package/dist/esm/internal/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect",
-  "version": "3.2.9",
+  "version": "3.3.1",
   "description": "The missing standard library for TypeScript, for writing production-grade software.",
   "license": "MIT",
   "repository": {
@@ -482,6 +482,11 @@
       "import": "./dist/esm/RedBlackTree.js",
       "default": "./dist/cjs/RedBlackTree.js"
     },
+    "./Redacted": {
+      "types": "./dist/dts/Redacted.d.ts",
+      "import": "./dist/esm/Redacted.js",
+      "default": "./dist/cjs/Redacted.js"
+    },
     "./Ref": {
       "types": "./dist/dts/Ref.d.ts",
       "import": "./dist/esm/Ref.js",
@@ -1081,6 +1086,9 @@
       "RedBlackTree": [
         "./dist/dts/RedBlackTree.d.ts"
       ],
+      "Redacted": [
+        "./dist/dts/Redacted.d.ts"
+      ],
       "Ref": [
         "./dist/dts/Ref.d.ts"
       ],

package/src/Chunk.ts

@@ -316,11 +316,7 @@ export const toReadonlyArray = <A>(self: Chunk<A>): ReadonlyArray<A> => {
   }
 }
 
-/**
- * @since 2.0.0
- * @category elements
- */
-export const reverse = <A>(self: Chunk<A>): Chunk<A> => {
+const reverseChunk = <A>(self: Chunk<A>): Chunk<A> => {
   switch (self.backing._tag) {
     case "IEmpty":
     case "ISingleton":
@@ -336,6 +332,22 @@ export const reverse = <A>(self: Chunk<A>): Chunk<A> => {
   }
 }
 
+/**
+ * Reverses the order of elements in a `Chunk`.
+ * Importantly, if the input chunk is a `NonEmptyChunk`, the reversed chunk will also be a `NonEmptyChunk`.
+ *
+ * @example
+ * import { Chunk } from "effect"
+ *
+ * const numbers = Chunk.make(1, 2, 3)
+ * const reversedNumbers = Chunk.reverse(numbers)
+ * assert.deepStrictEqual(reversedNumbers, Chunk.make(3, 2, 1))
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+export const reverse: <S extends Chunk<any>>(self: S) => Chunk.With<S, Chunk.Infer<S>> = reverseChunk as any
+
 /**
  * This function provides a safe way to read a value at a particular index from a `Chunk`.
  *

package/src/Config.ts

@@ -13,6 +13,7 @@ import * as internal from "./internal/config.js"
 import type * as LogLevel from "./LogLevel.js"
 import type * as Option from "./Option.js"
 import type { Predicate, Refinement } from "./Predicate.js"
+import type * as Redacted from "./Redacted.js"
 import type * as Secret from "./Secret.js"
 import type * as Types from "./Types.js"
 
@@ -109,7 +110,7 @@ export const all: <const Arg extends Iterable<Config<any>> | Record<string, Conf
  * @since 2.0.0
  * @category constructors
  */
-export const array: <A>(config: Config<A>, name?: string) => Config<ReadonlyArray<A>> = internal.array
+export const array: <A>(config: Config<A>, name?: string) => Config<Array<A>> = internal.array
 
 /**
  * Constructs a config for a boolean value.
@@ -330,9 +331,18 @@ export const repeat: <A>(self: Config<A>) => Config<Array<A>> = internal.repeat
  *
  * @since 2.0.0
  * @category constructors
+ * @deprecated
  */
 export const secret: (name?: string) => Config<Secret.Secret> = internal.secret
 
+/**
+ * Constructs a config for a redacted value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const redacted: (name?: string) => Config<Redacted.Redacted> = internal.redacted
+
 /**
  * Constructs a config for a sequence of values.
  *

package/src/Either.ts

@@ -290,10 +290,9 @@ export const getEquivalence = <R, L>({ left, right }: {
   left: Equivalence.Equivalence<L>
 }): Equivalence.Equivalence<Either<R, L>> =>
   Equivalence.make((x, y) =>
-    x === y ||
-    (isLeft(x) ?
+    isLeft(x) ?
       isLeft(y) && left(x.left, y.left) :
-      isRight(y) && right(x.right, y.right))
+      isRight(y) && right(x.right, y.right)
   )
 
 /**
@@ -700,7 +699,10 @@ const adapter = Gen.adapter<EitherTypeLambda>()
  * @category generators
  * @since 2.0.0
  */
-export const gen: Gen.Gen<EitherTypeLambda, Gen.Adapter<EitherTypeLambda>> = (f) => {
+export const gen: Gen.Gen<EitherTypeLambda, Gen.Adapter<EitherTypeLambda>> = (...args) => {
+  const f = (args.length === 1)
+    ? args[0]
+    : args[1].bind(args[0])
   const iterator = f(adapter)
   let state: IteratorYieldResult<any> | IteratorReturnResult<any> = iterator.next()
   if (state.done) {

package/src/Iterable.ts

@@ -265,6 +265,19 @@ export const head = <A>(self: Iterable<A>): Option<A> => {
   return result.done ? O.none() : O.some(result.value)
 }
 
+/**
+ * Get the first element of a `Iterable`, or throw an error if the `Iterable` is empty.
+ *
+ * @category getters
+ * @since 3.3.0
+ */
+export const unsafeHead = <A>(self: Iterable<A>): A => {
+  const iterator = self[Symbol.iterator]()
+  const result = iterator.next()
+  if (result.done) throw new Error("unsafeHead: empty iterable")
+  return result.value
+}
+
 /**
  * Keep only a max number of elements from the start of an `Iterable`, creating a new `Iterable`.
  *

package/src/Layer.ts

@@ -139,6 +139,28 @@ export const isLayer: (u: unknown) => u is Layer<unknown, unknown, unknown> = in
  */
 export const isFresh: <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => boolean = internal.isFresh
 
+/**
+ * @since 3.3.0
+ * @category tracing
+ */
+export const annotateLogs: {
+  (key: string, value: unknown): <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, R>
+  (values: Record<string, unknown>): <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, R>
+  <A, E, R>(self: Layer<A, E, R>, key: string, value: unknown): Layer<A, E, R>
+  <A, E, R>(self: Layer<A, E, R>, values: Record<string, unknown>): Layer<A, E, R>
+} = internal.annotateLogs
+
+/**
+ * @since 3.3.0
+ * @category tracing
+ */
+export const annotateSpans: {
+  (key: string, value: unknown): <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, R>
+  (values: Record<string, unknown>): <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, R>
+  <A, E, R>(self: Layer<A, E, R>, key: string, value: unknown): Layer<A, E, R>
+  <A, E, R>(self: Layer<A, E, R>, values: Record<string, unknown>): Layer<A, E, R>
+} = internal.annotateSpans
+
 /**
  * Builds a layer into a scoped value.
  *

package/src/Option.ts

@@ -1057,7 +1057,7 @@ export const filter: {
  * @since 2.0.0
  */
 export const getEquivalence = <A>(isEquivalent: Equivalence.Equivalence<A>): Equivalence.Equivalence<Option<A>> =>
-  Equivalence.make((x, y) => x === y || (isNone(x) ? isNone(y) : isNone(y) ? false : isEquivalent(x.value, y.value)))
+  Equivalence.make((x, y) => isNone(x) ? isNone(y) : isNone(y) ? false : isEquivalent(x.value, y.value))
 
 /**
  * The `Order` instance allows `Option` values to be compared with
@@ -1345,7 +1345,13 @@ const adapter = Gen.adapter<OptionTypeLambda>()
  * @category generators
  * @since 2.0.0
  */
-export const gen: Gen.Gen<OptionTypeLambda, Gen.Adapter<OptionTypeLambda>> = (f) => {
+export const gen: Gen.Gen<OptionTypeLambda, Gen.Adapter<OptionTypeLambda>> = (...args) => {
+  let f: any
+  if (args.length === 1) {
+    f = args[0]
+  } else {
+    f = args[1].bind(args[0])
+  }
   const iterator = f(adapter)
   let state: IteratorYieldResult<any> | IteratorReturnResult<any> = iterator.next()
   if (state.done) {

package/src/Pool.ts

@@ -74,6 +74,16 @@ export const isPool: (u: unknown) => u is Pool<unknown, unknown> = internal.isPo
  * because the `Scope` is closed, the individual items allocated by the pool
  * will be released in some unspecified order.
  *
+ * By setting the `concurrency` parameter, you can control the level of concurrent
+ * access per pool item. By default, the number of permits is set to `1`.
+ *
+ * `targetUtilization` determines when to create new pool items. It is a value
+ * between 0 and 1, where 1 means only create new pool items when all the existing
+ * items are fully utilized.
+ *
+ * A `targetUtilization` of 0.5 will create new pool items when the existing items are
+ * 50% utilized.
+ *
  * @since 2.0.0
  * @category constructors
  */
@@ -81,6 +91,8 @@ export const make: <A, E, R>(
   options: {
     readonly acquire: Effect.Effect<A, E, R>
     readonly size: number
+    readonly concurrency?: number | undefined
+    readonly targetUtilization?: number | undefined
   }
 ) => Effect.Effect<Pool<A, E>, never, Scope.Scope | R> = internal.make
 
@@ -92,6 +104,22 @@ export const make: <A, E, R>(
  * used, the individual items allocated by the pool will be released in some
  * unspecified order.
  *
+ * By setting the `concurrency` parameter, you can control the level of concurrent
+ * access per pool item. By default, the number of permits is set to `1`.
+ *
+ * `targetUtilization` determines when to create new pool items. It is a value
+ * between 0 and 1, where 1 means only create new pool items when all the existing
+ * items are fully utilized.
+ *
+ * A `targetUtilization` of 0.5 will create new pool items when the existing items are
+ * 50% utilized.
+ *
+ * The `timeToLiveStrategy` determines how items are invalidated. If set to
+ * "creation", then items are invalidated based on their creation time. If set
+ * to "usage", then items are invalidated based on pool usage.
+ *
+ * By default, the `timeToLiveStrategy` is set to "usage".
+ *
  * ```ts
  * import { createConnection } from "mysql2";
  * import { Duration, Effect, Pool } from "effect"
@@ -115,12 +143,17 @@ export const make: <A, E, R>(
  * @since 2.0.0
  * @category constructors
  */
-export const makeWithTTL: <A, E, R>(options: {
-  readonly acquire: Effect.Effect<A, E, R>
-  readonly min: number
-  readonly max: number
-  readonly timeToLive: Duration.DurationInput
-}) => Effect.Effect<Pool<A, E>, never, Scope.Scope | R> = internal.makeWithTTL
+export const makeWithTTL: <A, E, R>(
+  options: {
+    readonly acquire: Effect.Effect<A, E, R>
+    readonly min: number
+    readonly max: number
+    readonly concurrency?: number | undefined
+    readonly targetUtilization?: number | undefined
+    readonly timeToLive: Duration.DurationInput
+    readonly timeToLiveStrategy?: "creation" | "usage" | undefined
+  }
+) => Effect.Effect<Pool<A, E>, never, Scope.Scope | R> = internal.makeWithTTL
 
 /**
  * Retrieves an item from the pool in a scoped effect. Note that if

package/src/Predicate.ts

@@ -3,6 +3,7 @@
  */
 import { dual, isFunction as isFunction_ } from "./Function.js"
 import type { TypeLambda } from "./HKT.js"
+import type { TupleOf, TupleOfAtLeast } from "./Types.js"
 
 /**
  * @category models
@@ -52,6 +53,64 @@ export const mapInput: {
   <A, B>(self: Predicate<A>, f: (b: B) => A): Predicate<B>
 } = dual(2, <A, B>(self: Predicate<A>, f: (b: B) => A): Predicate<B> => (b) => self(f(b)))
 
+/**
+ * Determine if an `Array` is a tuple with exactly `N` elements, narrowing down the type to `TupleOf`.
+ *
+ * An `Array` is considered to be a `TupleOf` if its length is exactly `N`.
+ *
+ * @param self - The `Array` to check.
+ * @param n - The exact number of elements that the `Array` should have to be considered a `TupleOf`.
+ *
+ * @example
+ * import { isTupleOf } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isTupleOf([1, 2, 3], 3), true);
+ * assert.deepStrictEqual(isTupleOf([1, 2, 3], 2), false);
+ * assert.deepStrictEqual(isTupleOf([1, 2, 3], 4), false);
+ *
+ * const arr: number[] = [1, 2, 3];
+ * if (isTupleOf(arr, 3)) {
+ *   console.log(arr);
+ *   // ^? [number, number, number]
+ * }
+ *
+ * @category guards
+ * @since 3.3.0
+ */
+export const isTupleOf: {
+  <N extends number>(n: N): <T>(self: ReadonlyArray<T>) => self is TupleOf<N, T>
+  <T, N extends number>(self: ReadonlyArray<T>, n: N): self is TupleOf<N, T>
+} = dual(2, <T, N extends number>(self: ReadonlyArray<T>, n: N): self is TupleOf<N, T> => self.length === n)
+
+/**
+ * Determine if an `Array` is a tuple with at least `N` elements, narrowing down the type to `TupleOfAtLeast`.
+ *
+ * An `Array` is considered to be a `TupleOfAtLeast` if its length is at least `N`.
+ *
+ * @param self - The `Array` to check.
+ * @param n - The minimum number of elements that the `Array` should have to be considered a `TupleOfAtLeast`.
+ *
+ * @example
+ * import { isTupleOfAtLeast } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isTupleOfAtLeast([1, 2, 3], 3), true);
+ * assert.deepStrictEqual(isTupleOfAtLeast([1, 2, 3], 2), true);
+ * assert.deepStrictEqual(isTupleOfAtLeast([1, 2, 3], 4), false);
+ *
+ * const arr: number[] = [1, 2, 3, 4];
+ * if (isTupleOfAtLeast(arr, 3)) {
+ *   console.log(arr);
+ *   // ^? [number, number, number, ...number[]]
+ * }
+ *
+ * @category guards
+ * @since 3.3.0
+ */
+export const isTupleOfAtLeast: {
+  <N extends number>(n: N): <T>(self: ReadonlyArray<T>) => self is TupleOfAtLeast<N, T>
+  <T, N extends number>(self: ReadonlyArray<T>, n: N): self is TupleOfAtLeast<N, T>
+} = dual(2, <T, N extends number>(self: ReadonlyArray<T>, n: N): self is TupleOfAtLeast<N, T> => self.length >= n)
+
 /**
  * Tests if a value is `truthy`.
  *
@@ -740,15 +799,55 @@ export const eqv: {
 } = dual(2, <A>(self: Predicate<A>, that: Predicate<A>): Predicate<A> => (a) => self(a) === that(a))
 
 /**
+ * Represents the logical implication combinator for predicates. In formal
+ * logic, the implication operator `->` denotes that if the first proposition
+ * (antecedent) is true, then the second proposition (consequent) must also be
+ * true. In simpler terms, `p implies q` can be interpreted as "if p then q". If
+ * the first predicate holds, then the second predicate must hold
+ * for the given context.
+ *
+ * In practical terms within TypeScript, `p implies q` is equivalent to `!p || (p && q)`.
+ *
+ * Note that if the antecedent is `false`, the result is `true` by default
+ * because the outcome of the consequent cannot be determined.
+ *
+ * This function is useful in situations where you need to enforce rules or
+ * constraints that are contingent on certain conditions.
+ * It proves especially helpful in defining property tests.
+ *
+ * The example below illustrates the transitive property of order using the
+ * `implies` function. In simple terms, if `a <= b` and `b <= c`, then `a <= c`
+ * must be true.
+ *
+ * @example
+ * import { Predicate } from "effect"
+ *
+ * type Triple = {
+ *   readonly a: number
+ *   readonly b: number
+ *   readonly c: number
+ * }
+ *
+ * const transitivity = Predicate.implies(
+ *   // antecedent
+ *   (input: Triple) => input.a <= input.b && input.b <= input.c,
+ *   // consequent
+ *   (input: Triple) => input.a <= input.c
+ * )
+ *
+ * assert.equal(transitivity({ a: 1, b: 2, c: 3 }), true)
+ * // antecedent is `false`, so the result is `true`
+ * assert.equal(transitivity({ a: 1, b: 0, c: 0 }), true)
+ *
  * @category combinators
  * @since 2.0.0
  */
 export const implies: {
-  <A>(that: Predicate<A>): (self: Predicate<A>) => Predicate<A>
-  <A>(self: Predicate<A>, that: Predicate<A>): Predicate<A>
+  <A>(consequent: Predicate<A>): (antecedent: Predicate<A>) => Predicate<A>
+  <A>(antecedent: Predicate<A>, consequent: Predicate<A>): Predicate<A>
 } = dual(
   2,
-  <A>(self: Predicate<A>, that: Predicate<A>): Predicate<A> => (a) => self(a) ? that(a) : true
+  <A>(antecedent: Predicate<A>, consequent: Predicate<A>): Predicate<A> => (a) => antecedent(a) ? consequent(a) : true
 )
 
 /**

package/src/Redacted.ts

@@ -0,0 +1,133 @@
+/**
+ * The Redacted module provides functionality for handling sensitive information
+ * securely within your application. By using the `Redacted` data type, you can
+ * ensure that sensitive values are not accidentally exposed in logs or error
+ * messages.
+ *
+ * @since 3.3.0
+ */
+import type * as Equal from "./Equal.js"
+import * as Equivalence from "./Equivalence.js"
+import * as redacted_ from "./internal/redacted.js"
+import type { Pipeable } from "./Pipeable.js"
+import type { Covariant } from "./Types.js"
+
+/**
+ * @since 3.3.0
+ * @category symbols
+ */
+export const RedactedTypeId: unique symbol = redacted_.RedactedTypeId
+
+/**
+ * @since 3.3.0
+ * @category symbols
+ */
+export type RedactedTypeId = typeof RedactedTypeId
+
+/**
+ * @since 3.3.0
+ * @category models
+ */
+export interface Redacted<out A = string> extends Redacted.Variance<A>, Equal.Equal, Pipeable {
+}
+
+/**
+ * @since 3.3.0
+ */
+export declare namespace Redacted {
+  /**
+   * @since 3.3.0
+   * @category models
+   */
+  export interface Variance<out A> {
+    readonly [RedactedTypeId]: {
+      readonly _A: Covariant<A>
+    }
+  }
+
+  /**
+   * @since 3.3.0
+   * @category type-level
+   */
+  export type Value<T extends Redacted<any>> = [T] extends [Redacted<infer _A>] ? _A : never
+}
+
+/**
+ * @since 3.3.0
+ * @category refinements
+ */
+export const isRedacted: (u: unknown) => u is Redacted<unknown> = redacted_.isRedacted
+
+/**
+ * This function creates a `Redacted<A>` instance from a given value `A`,
+ * securely hiding its content.
+ *
+ * @example
+ * import { Redacted } from "effect"
+ *
+ * const API_KEY = Redacted.make("1234567890")
+ *
+ * @since 3.3.0
+ * @category constructors
+ */
+export const make: <A>(value: A) => Redacted<A> = redacted_.make
+
+/**
+ * Retrieves the original value from a `Redacted` instance. Use this function
+ * with caution, as it exposes the sensitive data.
+ *
+ * @example
+ * import { Redacted } from "effect"
+ *
+ * const API_KEY = Redacted.make("1234567890")
+ *
+ * assert.equal(Redacted.value(API_KEY), "1234567890")
+ *
+ * @since 3.3.0
+ * @category getters
+ */
+export const value: <A>(self: Redacted<A>) => A = redacted_.value
+
+/**
+ * Erases the underlying value of a `Redacted` instance, rendering it unusable.
+ * This function is intended to ensure that sensitive data does not remain in
+ * memory longer than necessary.
+ *
+ * @example
+ * import { Redacted } from "effect"
+ *
+ * const API_KEY = Redacted.make("1234567890")
+ *
+ * assert.equal(Redacted.value(API_KEY), "1234567890")
+ *
+ * Redacted.unsafeWipe(API_KEY)
+ *
+ * assert.throws(() => Redacted.value(API_KEY), new Error("Unable to get redacted value"))
+ *
+ * @since 3.3.0
+ * @category unsafe
+ */
+export const unsafeWipe: <A>(self: Redacted<A>) => boolean = redacted_.unsafeWipe
+
+/**
+ * Generates an equivalence relation for `Redacted<A>` values based on an
+ * equivalence relation for the underlying values `A`. This function is useful
+ * for comparing `Redacted` instances without exposing their contents.
+ *
+ * @example
+ * import { Redacted, Equivalence } from "effect"
+ *
+ * const API_KEY1 = Redacted.make("1234567890")
+ * const API_KEY2 = Redacted.make("1-34567890")
+ * const API_KEY3 = Redacted.make("1234567890")
+ *
+ * const equivalence = Redacted.getEquivalence(Equivalence.string)
+ *
+ * assert.equal(equivalence(API_KEY1, API_KEY2), false)
+ * assert.equal(equivalence(API_KEY1, API_KEY3), true)
+ *
+ * @category equivalence
+ * @since 3.3.0
+ */
+export const getEquivalence = <A>(isEquivalent: Equivalence.Equivalence<A>): Equivalence.Equivalence<Redacted<A>> =>
+  Equivalence.make((x, y) => isEquivalent(value(x), value(y)))

package/src/STM.ts

@@ -1065,8 +1065,13 @@ export interface Adapter {
  * @since 2.0.0
  * @category constructors
  */
-export const gen: <Eff extends YieldWrap<STM<any, any, any>>, AEff>(
-  f: (resume: Adapter) => Generator<Eff, AEff, never>
+export const gen: <Self, Eff extends YieldWrap<STM<any, any, any>>, AEff>(
+  ...args:
+    | [
+      self: Self,
+      body: (this: Self, resume: Adapter) => Generator<Eff, AEff, never>
+    ]
+    | [body: (resume: Adapter) => Generator<Eff, AEff, never>]
 ) => STM<
   AEff,
   [Eff] extends [never] ? never : [Eff] extends [YieldWrap<STM<infer _A, infer E, infer _R>>] ? E : never,

package/src/Secret.ts

@@ -1,37 +1,44 @@
 /**
  * @since 2.0.0
+ * @deprecated
  */
 import type * as Equal from "./Equal.js"
 import * as InternalSecret from "./internal/secret.js"
+import type * as Redacted from "./Redacted.js"
 
 /**
  * @since 2.0.0
  * @category symbols
+ * @deprecated
  */
 export const SecretTypeId: unique symbol = InternalSecret.SecretTypeId
 
 /**
  * @since 2.0.0
  * @category symbols
+ * @deprecated
  */
 export type SecretTypeId = typeof SecretTypeId
 
 /**
  * @since 2.0.0
  * @category models
+ * @deprecated
  */
-export interface Secret extends Secret.Proto, Equal.Equal {
+export interface Secret extends Redacted.Redacted, Secret.Proto, Equal.Equal {
   /** @internal */
   readonly raw: Array<number>
 }
 
 /**
  * @since 2.0.0
+ * @deprecated
  */
 export declare namespace Secret {
   /**
    * @since 2.0.0
    * @category models
+   * @deprecated
    */
   export interface Proto {
     readonly [SecretTypeId]: SecretTypeId
@@ -41,35 +48,41 @@ export declare namespace Secret {
 /**
  * @since 2.0.0
  * @category refinements
+ * @deprecated
  */
 export const isSecret: (u: unknown) => u is Secret = InternalSecret.isSecret
 
 /**
  * @since 2.0.0
  * @category constructors
+ * @deprecated
  */
 export const make: (bytes: Array<number>) => Secret = InternalSecret.make
 
 /**
  * @since 2.0.0
  * @category constructors
+ * @deprecated
  */
 export const fromIterable: (iterable: Iterable<string>) => Secret = InternalSecret.fromIterable
 
 /**
  * @since 2.0.0
  * @category constructors
+ * @deprecated
  */
 export const fromString: (text: string) => Secret = InternalSecret.fromString
 
 /**
  * @since 2.0.0
  * @category getters
+ * @deprecated
  */
 export const value: (self: Secret) => string = InternalSecret.value
 
 /**
  * @since 2.0.0
  * @category unsafe
+ * @deprecated
  */
 export const unsafeWipe: (self: Secret) => void = InternalSecret.unsafeWipe