effect 4.0.1 → 4.0.3

package/src/socket/Socket.ts

@@ -799,13 +799,18 @@ export interface WebSocketLike {
 }
 
 /**
- * Common options understood by a WebSocket client implementation.
+ * Client options for Node and Bun WebSocket implementations, allowing
+ * handshake headers and subprotocols to be supplied together.
  *
  * @stability unstable
  * @category models
  * @since 4.0.0
  */
 export interface WebSocketClientOptions {
+  /**
+   * Subprotocols to offer in the opening handshake.
+   */
+  readonly protocols?: string | Array<string> | undefined
   /**
    * Headers to include in the opening handshake.
    *
@@ -857,6 +862,7 @@ export class WebSocketConstructor extends Context.Service<
 
 /**
  * Layer that provides `WebSocketConstructor` using `globalThis.WebSocket`.
+ * Rejects client options objects, including those with handshake headers.
  *
  * @stability unstable
  * @category layers
@@ -874,6 +880,8 @@ export const layerWebSocketConstructorGlobal: Layer.Layer<WebSocketConstructor>
 /**
  * Creates a `Socket` backed by a `WebSocketConstructor`, dialing the
  * WebSocket for each reader acquisition.
+ * Optional handshake headers require a Node or Bun constructor; without
+ * headers, protocols are passed directly for browser compatibility.
  *
  * @stability unstable
  * @category constructors
@@ -882,13 +890,21 @@ export const layerWebSocketConstructorGlobal: Layer.Layer<WebSocketConstructor>
 export const makeWebSocket = (url: string | Effect.Effect<string>, options?: {
   readonly openTimeout?: Duration.Input | undefined
   readonly protocols?: string | Array<string> | undefined
+  readonly headers?: Readonly<Record<string, string>> | undefined
   readonly highWaterMark?: number | undefined
 }): Effect.Effect<Socket, never, WebSocketConstructor> =>
   WebSocketConstructor.use((makeWs) =>
     fromWebSocket(
       Effect.acquireRelease(
         (typeof url === "string" ? Effect.succeed(url) : url).pipe(
-          Effect.map((url) => makeWs(url, options?.protocols))
+          Effect.map((url) =>
+            makeWs(
+              url,
+              options?.headers === undefined
+                ? options?.protocols
+                : { protocols: options.protocols, headers: options.headers }
+            )
+          )
         ),
         (ws) => Effect.sync(() => ws.close(1000))
       ),
@@ -1165,6 +1181,7 @@ const defaultHighWaterMark = 64 * 1024
 /**
  * Creates a binary `Channel` backed by a WebSocket URL, requiring a
  * `WebSocketConstructor` service.
+ * Supports subprotocols and, with a Node or Bun constructor, handshake headers.
  *
  * @stability unstable
  * @category constructors
@@ -1175,6 +1192,7 @@ export const makeWebSocketChannel = <IE = never>(
   options?: {
     readonly openTimeout?: Duration.Input | undefined
     readonly protocols?: string | Array<string> | undefined
+    readonly headers?: Readonly<Record<string, string>> | undefined
     readonly highWaterMark?: number | undefined
   }
 ): Channel.Channel<
@@ -1193,6 +1211,7 @@ export const makeWebSocketChannel = <IE = never>(
 /**
  * Layer that provides a `Socket` service backed by a WebSocket URL or URL
  * effect.
+ * Supports subprotocols and, with a Node or Bun constructor, handshake headers.
  *
  * @stability unstable
  * @category layers
@@ -1203,6 +1222,7 @@ export const layerWebSocket: (
   options?: {
     readonly openTimeout?: Duration.Input | undefined
     readonly protocols?: string | Array<string> | undefined
+    readonly headers?: Readonly<Record<string, string>> | undefined
     readonly highWaterMark?: number | undefined
   } | undefined
 ) => Layer.Layer<Socket, never, WebSocketConstructor> = flow(makeWebSocket, Layer.effect(Socket))

package/src/socket/index.ts

@@ -5,6 +5,12 @@
 
 // @barrel: Auto-generated exports. Do not edit manually.
 
+/**
+ * @stability experimental
+ * @since 4.0.0
+ */
+export * as DatagramSocket from "./DatagramSocket.ts"
+
 /**
  * @stability unstable
  * @since 4.0.0

package/src/sql/Migrator.ts

@@ -140,14 +140,21 @@ export const make = <RD = never>({
   PRIMARY KEY (migration_id)
 )`,
       pg: () =>
-        Effect.catch(
-          sql`select ${table}::regclass`,
-          () =>
-            sql`CREATE TABLE ${sql(table)} (
+        Effect.flatMap(
+          migrationsTableExists(sql, table),
+          (exists) =>
+            exists ? Effect.void : Effect.asVoid(sql`CREATE TABLE ${sql(table)} (
   migration_id integer primary key,
   created_at timestamp with time zone not null default now(),
   name text not null
-)`
+)`).pipe(
+              Effect.catch((error) =>
+                Effect.flatMap(
+                  migrationsTableExists(sql, table),
+                  (exists) => exists ? Effect.void : Effect.fail(error)
+                )
+              )
+            )
         ),
       orElse: () =>
         sql`CREATE TABLE IF NOT EXISTS ${sql(table)} (
@@ -328,6 +335,15 @@ export const make = <RD = never>({
     return completed
   })
 
+const migrationsTableExists = (sql: Client.SqlClient, table: string): Effect.Effect<boolean, SqlError> => {
+  // Match query quoting: to_regclass folds unquoted names to lowercase.
+  const quotedTable = sql`${sql(table)}`.compile(true)[0]
+  return Effect.map(
+    sql`SELECT 1 AS found WHERE to_regclass(${quotedTable}) IS NOT NULL`.withoutTransform,
+    (rows) => rows.length > 0
+  )
+}
+
 const migrationOrder = Order.make<ResolvedMigration>(([a], [b]) => Order.Number(a, b))
 
 const isConstraintConflict = (error: SqlError): boolean =>

package/src/sql/SqlClient.ts

@@ -9,7 +9,7 @@
  * @stability unstable
  * @since 4.0.0
  */
-import type * as Cause from "../Cause.ts"
+import * as Cause from "../Cause.ts"
 import { Clock } from "../Clock.ts"
 import * as Context from "../Context.ts"
 import * as Effect from "../Effect.ts"
@@ -280,6 +280,12 @@ export const make = Effect.fnUntraced(function*(options: SqlClient.MakeOptions)
  *
  * **Details**
  *
+ * Both acquirers lease the connection into the current scope and hold the
+ * semaphore until that scope closes, so a statement or stream keeps the
+ * connection until it finishes and another fiber cannot begin a transaction
+ * underneath it. Effects that use the connection directly, such as an export,
+ * have to run inside `Effect.scoped`.
+ *
  * SQLite can keep a transaction open after COMMIT fails, for example on a
  * deferred foreign key violation. `onCommitFailure` rolls it back before the
  * connection is reused. If that ROLLBACK fails, the connection is rejected, and
@@ -300,7 +306,7 @@ export const makeSqliteAcquirers = <C extends Connection.Connection>(options: {
   readonly semaphore: Semaphore.Semaphore
   readonly isTransaction?: ((conn: C) => boolean) | undefined
 }): {
-  readonly acquirer: Effect.Effect<C, SqlError>
+  readonly acquirer: Effect.Effect<C, SqlError, Scope.Scope>
   readonly transactionAcquirer: Effect.Effect<C, SqlError, Scope.Scope>
   readonly onCommitFailure: (conn: Connection.Connection) => Effect.Effect<void, SqlError>
 } => {
@@ -336,15 +342,17 @@ export const makeSqliteAcquirers = <C extends Connection.Connection>(options: {
     })
   })
 
+  const lease = Effect.uninterruptibleMask((restore) =>
+    Effect.flatMap(Effect.scope, (scope) =>
+      restore(semaphore.take(1)).pipe(
+        Effect.andThen(Scope.addFinalizer(scope, semaphore.release(1))),
+        Effect.andThen(available)
+      ))
+  )
+
   return {
-    acquirer: semaphore.withPermits(1)(available),
-    transactionAcquirer: Effect.uninterruptibleMask((restore) =>
-      Effect.flatMap(Effect.scope, (scope) =>
-        restore(semaphore.take(1)).pipe(
-          Effect.andThen(Scope.addFinalizer(scope, semaphore.release(1))),
-          Effect.andThen(available)
-        ))
-    ),
+    acquirer: lease,
+    transactionAcquirer: lease,
     onCommitFailure: (conn) => Effect.tapCause(rollback(conn as C), (cause) => Effect.sync(() => poison(cause)))
   }
 }
@@ -359,6 +367,18 @@ const isNoTransactionError = (error: SqlError): boolean => {
   return /no transaction is active/i.test(message);
 }
 
+/**
+ * A failed COMMIT cleanup leaves the connection in an unsafe state, so both the
+ * COMMIT error and the cleanup error are promoted to defects: typed recovery
+ * must not be able to hide them.
+ */
+const failuresToDefects = <E>(cause: Cause.Cause<E>): Cause.Cause<never> =>
+  Cause.fromReasons(cause.reasons.map((reason) =>
+    Cause.isFailReason(reason)
+      ? Cause.makeDieReason(reason.error).annotate(Cause.reasonAnnotations(reason))
+      : reason
+  ))
+
 /**
  * Builds a transaction wrapper that begins top-level transactions, uses
  * savepoints for nested transactions, commits on success, and rolls back on
@@ -394,7 +414,7 @@ export const makeWithTransaction = <I, S>(options: {
     Effect.uninterruptibleMask((restore) =>
       Effect.useSpan(
         "sql.transaction",
-        { kind: "client" },
+        { kind: "internal" },
         (span) =>
           Effect.withFiber<A, E | SqlError, R>((fiber) => {
             for (const [key, value] of options.spanAttributes) {
@@ -424,21 +444,25 @@ export const makeWithTransaction = <I, S>(options: {
                         )
                       ),
                       (exit) => {
-                        let effect: Effect.Effect<void>
+                        let effect: Effect.Effect<void, SqlError>
                         if (Exit.isSuccess(exit)) {
                           if (id === 0) {
-                            span.event("db.transaction.commit", clock.currentTimeNanosUnsafe())
+                            span.event("effect.sql.transaction.commit", clock.currentTimeNanosUnsafe())
                             const onCommitFailure = options.onCommitFailure
-                            effect = Effect.orDie(options.commit(conn))
-                            if (onCommitFailure) {
-                              effect = Effect.onError(effect, () => Effect.orDie(onCommitFailure(conn)))
-                            }
+                            effect = onCommitFailure
+                              ? Effect.catchCause(options.commit(conn), (commitCause) =>
+                                Effect.matchCauseEffect(onCommitFailure(conn), {
+                                  onFailure: (cleanupCause) =>
+                                    Effect.failCause(failuresToDefects(Cause.combine(commitCause, cleanupCause))),
+                                  onSuccess: () => Effect.failCause(commitCause)
+                                }))
+                              : options.commit(conn)
                           } else {
-                            span.event("db.transaction.savepoint", clock.currentTimeNanosUnsafe())
+                            span.event("effect.sql.transaction.savepoint", clock.currentTimeNanosUnsafe())
                             effect = Effect.void
                           }
                         } else {
-                          span.event("db.transaction.rollback", clock.currentTimeNanosUnsafe())
+                          span.event("effect.sql.transaction.rollback", clock.currentTimeNanosUnsafe())
                           effect = Effect.orDie(
                             id > 0
                               ? options.rollbackSavepoint(conn, id)

package/src/sql/Statement.ts

@@ -114,7 +114,7 @@ export const CurrentTransformer = Context.Reference<Transformer | undefined>("ef
 })
 
 /**
- * Parents driver spans under `sql.execute` for every client in the current scope,
+ * Parents driver spans under the statement span for every client in the current scope,
  * including acquisition and stream pulls. Defaults to `false`; ignored when tracing is disabled.
  *
  * @stability unstable
@@ -1285,10 +1285,62 @@ export const defaultTransforms = (
   } as const
 }
 
+/**
+ * Returns the OpenTelemetry database span target for a client with the given
+ * span attributes: `db.namespace`, then `server.address[:server.port]`, or
+ * `undefined` when neither is set.
+ *
+ * @stability unstable
+ * @category tracing
+ * @since 4.0.1
+ */
+export const spanTarget = (spanAttributes: ReadonlyArray<readonly [string, unknown]>): string | undefined => {
+  const namespace = spanAttribute(spanAttributes, "db.namespace")
+  if (isNonEmptyString(namespace)) {
+    return namespace
+  }
+  const address = spanAttribute(spanAttributes, "server.address")
+  if (isNonEmptyString(address)) {
+    const port = spanAttribute(spanAttributes, "server.port")
+    return port === undefined ? address : `${address}:${port}`
+  }
+  return undefined
+}
+
+/**
+ * Returns the span name for statements run by a client with the given span
+ * attributes, following the OpenTelemetry database span conventions: the
+ * {@link spanTarget}, then `db.system.name`, falling back to `sql.execute`.
+ *
+ * @stability unstable
+ * @category tracing
+ * @since 4.0.1
+ */
+export const spanName = (spanAttributes: ReadonlyArray<readonly [string, unknown]>): string => {
+  const target = spanTarget(spanAttributes)
+  if (target !== undefined) {
+    return target
+  }
+  const system = spanAttribute(spanAttributes, "db.system.name")
+  return isNonEmptyString(system) ? system : "sql.execute"
+}
+
 // internal
 
-const ATTR_DB_OPERATION_NAME = "db.operation.name"
 const ATTR_DB_QUERY_TEXT = "db.query.text"
+const ATTR_SQL_METHOD = "effect.sql.method"
+
+// the last value wins, matching the order the attributes are applied to spans
+const spanAttribute = (spanAttributes: ReadonlyArray<readonly [string, unknown]>, key: string): unknown => {
+  for (let i = spanAttributes.length - 1; i >= 0; i--) {
+    if (spanAttributes[i][0] === key) {
+      return spanAttributes[i][1]
+    }
+  }
+  return undefined
+}
+
+const isNonEmptyString = (u: unknown): u is string => typeof u === "string" && u.length > 0
 
 interface StatementImpl<A> extends Statement<A> {
   readonly segments: ReadonlyArray<Segment>
@@ -1354,7 +1406,7 @@ const StatementProto: Omit<
     withoutTransform = false
   ): Effect.Effect<XA, E | SqlError> {
     return Effect.useSpan(
-      "sql.execute",
+      spanName(this.spanAttributes),
       { kind: "client" },
       (span) =>
         this.withConnectionSpan(
@@ -1381,7 +1433,7 @@ const StatementProto: Omit<
       for (const [key, value] of this.spanAttributes) {
         span.attribute(key, value)
       }
-      span.attribute(ATTR_DB_OPERATION_NAME, operation)
+      span.attribute(ATTR_SQL_METHOD, operation)
       span.attribute(ATTR_DB_QUERY_TEXT, sql)
       const execute = this.borrower === undefined
         ? Effect.scoped(Effect.flatMap(this.acquirer, (_) => f(_, sql, params)))
@@ -1411,14 +1463,14 @@ const StatementProto: Omit<
   get stream(): Stream.Stream<any, SqlError> {
     const self = this as StatementImpl<any>
     return Stream.unwrap(Effect.flatMap(
-      Effect.makeSpanScoped("sql.execute", { kind: "client" }),
+      Effect.makeSpanScoped(spanName(self.spanAttributes), { kind: "client" }),
       (span) =>
         withStatement(self, span, (statement, fiber) => {
           const [sql, params] = statement.compile()
           for (const [key, value] of self.spanAttributes) {
             span.attribute(key, value)
           }
-          span.attribute(ATTR_DB_OPERATION_NAME, "executeStream")
+          span.attribute(ATTR_SQL_METHOD, "executeStream")
           span.attribute(ATTR_DB_QUERY_TEXT, sql)
           const acquire = Effect.map(self.acquirer, (_) => _.executeStream(sql, params, self.transformRows))
           return fiber.cache.tracerEnabled && fiber.getRef(SpanPropagationEnabled)
@@ -1456,7 +1508,7 @@ const StatementProto: Omit<
   ...Effectable.Prototype<StatementImpl<any>>({
     label: "Statement",
     evaluate(fiber) {
-      const span = internalEffect.makeSpanUnsafe(fiber, "sql.execute", { kind: "client" })
+      const span = internalEffect.makeSpanUnsafe(fiber, spanName(this.spanAttributes), { kind: "client" })
       const clock = fiber.getRef(Clock)
       const timingEnabled = fiber.getRef(TracerTimingEnabled)
       return Effect.onExit(

package/src/testing/TestClock.ts

@@ -8,6 +8,7 @@
  * live clock, and warning when a test appears to be waiting on time without
  * advancing it.
  *
+ * @stability stable
  * @since 2.0.0
  */
 import * as Arr from "../Array.ts"
@@ -88,6 +89,7 @@ import * as Semaphore from "../Semaphore.ts"
  * await Effect.runPromise(Effect.provide(program, TestClock.layer()))
  * ```
  *
+ * @stability stable
  * @category models
  * @since 2.0.0
  */
@@ -133,6 +135,7 @@ export interface TestClock extends Clock.Clock {
  * await Effect.runPromise(Effect.scoped(program))
  * ```
  *
+ * @stability stable
  * @since 2.0.0
  */
 export declare namespace TestClock {
@@ -238,6 +241,7 @@ const millisToNanos = (millis: number): bigint => {
  * await Effect.runPromise(Effect.scoped(program))
  * ```
  *
+ * @stability stable
  * @category constructors
  * @since 4.0.0
  */
@@ -430,6 +434,7 @@ export const make = Effect.fnUntraced(function*(
  * await Effect.runPromise(Effect.provide(program, customTestClockLayer)) // => 3_600_000
  * ```
  *
+ * @stability stable
  * @category layers
  * @since 4.0.0
  */
@@ -463,6 +468,7 @@ export const layer: (options?: TestClock.Options) => Layer.Layer<TestClock> = fl
  * await Effect.runPromise(Effect.provide(program, TestClock.layer()))
  * ```
  *
+ * @stability stable
  * @category testing
  * @since 2.0.0
  */
@@ -501,6 +507,7 @@ export const testClockWith = <A, E, R>(
  * await Effect.runPromise(Effect.provide(program, TestClock.layer()))
  * ```
  *
+ * @stability stable
  * @category testing
  * @since 2.0.0
  */
@@ -538,6 +545,7 @@ export const adjust = (duration: Duration.Input): Effect.Effect<void> =>
  * await Effect.runPromise(Effect.provide(program, TestClock.layer()))
  * ```
  *
+ * @stability stable
  * @category testing
  * @since 2.0.0
  */
@@ -574,6 +582,7 @@ export const setTime = (timestamp: number): Effect.Effect<void> =>
  * await Effect.runPromise(Effect.provide(program, TestClock.layer()))
  * ```
  *
+ * @stability stable
  * @category testing
  * @since 4.0.0
  */

package/src/testing/TestConsole.ts

@@ -7,6 +7,7 @@
  * console layer, helpers for reading captured `Console.log` and `Console.error`
  * arguments, and access to the provided test console service.
  *
+ * @stability unstable
  * @since 4.0.0
  */
 import * as Array from "../Array.ts"
@@ -53,6 +54,7 @@ import * as Layer from "../Layer.ts"
  * @see {@link logLines} for reading captured `Console.log` calls
  * @see {@link errorLines} for reading captured `Console.error` calls
  *
+ * @stability unstable
  * @category models
  * @since 4.0.0
  */
@@ -87,6 +89,7 @@ export interface TestConsole extends Console.Console {
  *
  * Use when referring to types nested under the `TestConsole` namespace.
  *
+ * @stability unstable
  * @since 4.0.0
  */
 export declare namespace TestConsole {
@@ -173,6 +176,7 @@ export declare namespace TestConsole {
  *
  * @see {@link layer} for providing a `TestConsole` as a `Layer`
  *
+ * @stability unstable
  * @category constructors
  * @since 4.0.0
  */
@@ -250,6 +254,7 @@ export const make = Effect.gen(function*() {
  * @see {@link logLines} for reading captured `Console.log` calls directly
  * @see {@link errorLines} for reading captured `Console.error` calls directly
  *
+ * @stability unstable
  * @category testing
  * @since 4.0.0
  */
@@ -288,6 +293,7 @@ export const testConsoleWith = <A, E, R>(f: (console: TestConsole) => Effect.Eff
  * @see {@link make} for constructing the service value directly
  * @see {@link testConsoleWith} for accessing the provided test console service
  *
+ * @stability unstable
  * @category layers
  * @since 4.0.0
  */
@@ -324,6 +330,7 @@ export const layer: Layer.Layer<TestConsole> = Layer.effect(Console.Console)(mak
  * @see {@link errorLines} for reading captured `Console.error` output
  * @see {@link layer} for capturing console calls during a test
  *
+ * @stability unstable
  * @category testing
  * @since 4.0.0
  */
@@ -362,6 +369,7 @@ export const logLines: Effect.Effect<ReadonlyArray<unknown>, never, never> = tes
  * @see {@link logLines} for reading captured `Console.log` output
  * @see {@link layer} for capturing console calls during a test
  *
+ * @stability unstable
  * @category testing
  * @since 4.0.0
  */

package/src/testing/TestCrypto.ts

@@ -0,0 +1,94 @@
+/**
+ * Provides a deterministic implementation of the Effect `Crypto` service for
+ * tests.
+ *
+ * Random bytes, numbers, shuffles, UUIDs, and ULIDs are derived from a seeded
+ * pseudo-random generator. Digest operations are delegated to an underlying
+ * platform `Crypto` service.
+ *
+ * @stability unstable
+ * @since 4.0.0
+ */
+import * as Crypto from "../Crypto.ts"
+import * as Effect from "../Effect.ts"
+import * as Layer from "../Layer.ts"
+import * as Random from "../Random.ts"
+
+/**
+ * Creates a deterministic `Crypto` service using a seeded pseudo-random
+ * generator.
+ *
+ * **When to use**
+ *
+ * Use to construct a `Crypto` service whose random operations are reproducible
+ * in tests while preserving the digest implementation of a platform `Crypto`
+ * service.
+ *
+ * **Details**
+ *
+ * The effect requires an existing `Crypto` service and delegates digest
+ * operations to it. Each evaluation starts a new random sequence from `seed`;
+ * every other random operation is derived from that sequence.
+ *
+ * **Gotchas**
+ *
+ * The generated values are deterministic and must not be used for
+ * security-sensitive purposes. The sequence depends on the order in which
+ * random operations are evaluated. UUIDv7 and ULID values also include the
+ * current `Clock` time, which must be controlled separately when their complete
+ * output needs to be reproducible.
+ *
+ * @see {@link layer} for providing the service as a layer
+ *
+ * @stability unstable
+ * @category constructors
+ * @since 4.0.0
+ */
+export const make: (
+  seed: string | number
+) => Effect.Effect<Crypto.Crypto, never, Crypto.Crypto> = Effect.fnUntraced(
+  function*(_seed: string | number) {
+    const crypto = yield* Crypto.Crypto
+    const seededRandom = yield* Random.Random
+    return Crypto.make({
+      randomBytes: (size) => {
+        const bytes = new Uint8Array(size)
+        for (let i = 0; i < size; i++) {
+          bytes[i] = Math.floor(seededRandom.nextDoubleUnsafe() * 256)
+        }
+        return bytes
+      },
+      digest: crypto.digest
+    })
+  },
+  (effect, seed) => Random.withSeed(effect, seed)
+)
+
+/**
+ * Creates a layer that provides deterministic `Crypto` random operations from
+ * a seed.
+ *
+ * **When to use**
+ *
+ * Use to provide reproducible random bytes, numbers, shuffles, UUIDs, and ULIDs
+ * to an Effect program under test.
+ *
+ * **Details**
+ *
+ * The layer requires an existing platform `Crypto` service whose digest
+ * implementation is retained. Each layer build starts the random sequence from
+ * `seed`.
+ *
+ * **Gotchas**
+ *
+ * UUIDv7 and ULID values also depend on the current `Clock`. Provide a test
+ * clock when their complete output needs to be reproducible.
+ *
+ * @see {@link make} for constructing the service directly
+ *
+ * @stability unstable
+ * @category layers
+ * @since 4.0.0
+ */
+export const layer = (seed: string | number): Layer.Layer<Crypto.Crypto, never, Crypto.Crypto> =>
+  Layer.effect(Crypto.Crypto, make(seed))

package/src/testing/index.ts

@@ -1,19 +1,28 @@
 /**
+ * @stability unstable
  * @since 4.0.0
  */
 
 // @barrel: Auto-generated exports. Do not edit manually.
 
 /**
+ * @stability stable
  * @since 2.0.0
  */
 export * as TestClock from "./TestClock.ts"
 
 /**
+ * @stability unstable
  * @since 4.0.0
  */
 export * as TestConsole from "./TestConsole.ts"
 
+/**
+ * @stability unstable
+ * @since 4.0.0
+ */
+export * as TestCrypto from "./TestCrypto.ts"
+
 /**
  * @stability unstable
  * @since 4.0.0