effect 4.0.0-beta.5 → 4.0.0-beta.7

package/src/unstable/cluster/Sharding.ts

@@ -4,7 +4,7 @@
 import * as Arr from "../../Array.ts"
 import * as Cause from "../../Cause.ts"
 import { Clock } from "../../Clock.ts"
-import type { DurationInput } from "../../Duration.ts"
+import type { Input } from "../../Duration.ts"
 import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import * as Equal from "../../Equal.ts"
@@ -13,6 +13,7 @@ import * as Fiber from "../../Fiber.ts"
 import * as FiberMap from "../../FiberMap.ts"
 import { constant, flow } from "../../Function.ts"
 import * as HashRing from "../../HashRing.ts"
+import * as Latch from "../../Latch.ts"
 import * as Layer from "../../Layer.ts"
 import * as MutableHashMap from "../../MutableHashMap.ts"
 import * as MutableHashSet from "../../MutableHashSet.ts"
@@ -23,6 +24,7 @@ import { CurrentLogAnnotations } from "../../References.ts"
 import * as Result from "../../Result.ts"
 import * as Schedule from "../../Schedule.ts"
 import * as Scope from "../../Scope.ts"
+import * as Semaphore from "../../Semaphore.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
 import type * as Rpc from "../rpc/Rpc.ts"
@@ -113,7 +115,7 @@ export class Sharding extends ServiceMap.Service<Sharding, {
     entity: Entity<Type, Rpcs>,
     handlers: Effect.Effect<Handlers, never, RX>,
     options?: {
-      readonly maxIdleTime?: DurationInput | undefined
+      readonly maxIdleTime?: Input | undefined
       readonly concurrency?: number | "unbounded" | undefined
       readonly mailboxCapacity?: number | "unbounded" | undefined
       readonly disableFatalDefects?: boolean | undefined
@@ -221,7 +223,7 @@ const make = Effect.gen(function*() {
 
   // the active shards are the ones that we have acquired the lock for
   const acquiredShards = MutableHashSet.empty<ShardId>()
-  const activeShardsLatch = yield* Effect.makeLatch(false)
+  const activeShardsLatch = yield* Latch.make(false)
 
   const events = yield* PubSub.unbounded<ShardingRegistrationEvent>()
   const getRegistrationEvents: Stream.Stream<ShardingRegistrationEvent> = Stream.fromPubSub(events)
@@ -429,16 +431,16 @@ const make = Effect.gen(function*() {
   // It should also be shutdown after the entity managers, to ensure interrupt
   // & ack envelopes can still be processed.
 
-  const storageReadLatch = yield* Effect.makeLatch(true)
+  const storageReadLatch = yield* Latch.make(true)
   const openStorageReadLatch = constant(Effect.asVoid(storageReadLatch.open))
 
-  const storageReadLock = Effect.makeSemaphoreUnsafe(1)
+  const storageReadLock = Semaphore.makeUnsafe(1)
   const withStorageReadLock = storageReadLock.withPermits(1)
 
   if (storageEnabled && config.runnerAddress) {
     const selfAddress = config.runnerAddress
     const entityRegistrationTimeoutMillis = Duration.toMillis(
-      Duration.fromDurationInputUnsafe(config.entityRegistrationTimeout)
+      Duration.fromInputUnsafe(config.entityRegistrationTimeout)
     )
     const storageStartMillis = clock.currentTimeMillisUnsafe()
 
@@ -1182,7 +1184,7 @@ const make = Effect.gen(function*() {
 
   const singletons = new Map<ShardId, MutableHashMap.MutableHashMap<SingletonAddress, Effect.Effect<void>>>()
   const singletonFibers = yield* FiberMap.make<SingletonAddress>()
-  const withSingletonLock = Effect.makeSemaphoreUnsafe(1).withPermits(1)
+  const withSingletonLock = Semaphore.makeUnsafe(1).withPermits(1)
 
   const registerSingleton: Sharding["Service"]["registerSingleton"] = Effect.fnUntraced(
     function*(name, run, options) {
@@ -1253,7 +1255,7 @@ const make = Effect.gen(function*() {
   // --- Entities ---
 
   const reaper = yield* EntityReaper
-  const entityManagerLatches = new Map<string, Effect.Latch>()
+  const entityManagerLatches = new Map<string, Latch.Latch>()
 
   const registerEntity: Sharding["Service"]["registerEntity"] = Effect.fnUntraced(
     function*(entity, build, options) {
@@ -1310,7 +1312,7 @@ const make = Effect.gen(function*() {
   const waitForEntityManager = (entityType: string) => {
     let latch = entityManagerLatches.get(entityType)
     if (!latch) {
-      latch = Effect.makeLatchUnsafe()
+      latch = Latch.makeUnsafe()
       entityManagerLatches.set(entityType, latch)
     }
     return latch.await

package/src/unstable/cluster/ShardingConfig.ts

@@ -3,7 +3,6 @@
  */
 import * as Config from "../../Config.ts"
 import * as ConfigProvider from "../../ConfigProvider.ts"
-import type { DurationInput } from "../../Duration.ts"
 import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import * as Layer from "../../Layer.ts"
@@ -58,11 +57,11 @@ export class ShardingConfig extends ServiceMap.Service<ShardingConfig, {
   /**
    * Shard lock refresh interval.
    */
-  readonly shardLockRefreshInterval: DurationInput
+  readonly shardLockRefreshInterval: Duration.Input
   /**
    * Shard lock expiration duration.
    */
-  readonly shardLockExpiration: DurationInput
+  readonly shardLockExpiration: Duration.Input
   /**
    * Disable the use of advisory locks for shard locking.
    */
@@ -81,41 +80,41 @@ export class ShardingConfig extends ServiceMap.Service<ShardingConfig, {
    * The maximum duration of inactivity (i.e. without receiving a message)
    * after which an entity will be interrupted.
    */
-  readonly entityMaxIdleTime: DurationInput
+  readonly entityMaxIdleTime: Duration.Input
   /**
    * If an entity does not register itself within this time after a message is
    * sent to it, the message will be marked as failed.
    *
    * Defaults to 1 minute.
    */
-  readonly entityRegistrationTimeout: DurationInput
+  readonly entityRegistrationTimeout: Duration.Input
   /**
    * The maximum duration of time to wait for an entity to terminate.
    *
    * By default this is set to 15 seconds to stay within kubernetes defaults.
    */
-  readonly entityTerminationTimeout: DurationInput
+  readonly entityTerminationTimeout: Duration.Input
   /**
    * The interval at which to poll for unprocessed messages from storage.
    */
-  readonly entityMessagePollInterval: DurationInput
+  readonly entityMessagePollInterval: Duration.Input
   /**
    * The interval at which to poll for client replies from storage.
    */
-  readonly entityReplyPollInterval: DurationInput
+  readonly entityReplyPollInterval: Duration.Input
   /**
    * The interval at which to poll for new runners and refresh shard
    * assignments.
    */
-  readonly refreshAssignmentsInterval: DurationInput
+  readonly refreshAssignmentsInterval: Duration.Input
   /**
    * The interval to retry a send if EntityNotAssignedToRunner is returned.
    */
-  readonly sendRetryInterval: DurationInput
+  readonly sendRetryInterval: Duration.Input
   /**
    * The interval at which to check for unhealthy runners and report them
    */
-  readonly runnerHealthCheckInterval: DurationInput
+  readonly runnerHealthCheckInterval: Duration.Input
   /**
    * Simulate serialization and deserialization to remote runners for local
    * entities.

package/src/unstable/cluster/SqlRunnerStorage.ts

@@ -166,7 +166,7 @@ export const make = Effect.fnUntraced(function*(options: {
 
   const expiresSeconds = sql.literal(
     Math.ceil(Duration.toSeconds(
-      Duration.fromDurationInputUnsafe(config.shardLockExpiration)
+      Duration.fromInputUnsafe(config.shardLockExpiration)
     )).toString()
   )
   const lockExpiresAt = sql.onDialectOrElse({

package/src/unstable/cluster/internal/entityManager.ts

@@ -2,12 +2,13 @@ import * as Arr from "../../../Array.ts"
 import * as Cause from "../../../Cause.ts"
 import { Clock } from "../../../Clock.ts"
 import * as Duration from "../../../Duration.ts"
-import type { DurationInput } from "../../../Duration.ts"
+import type { Input } from "../../../Duration.ts"
 import * as Effect from "../../../Effect.ts"
 import * as Equal from "../../../Equal.ts"
 import * as Exit from "../../../Exit.ts"
 import * as Fiber from "../../../Fiber.ts"
 import { identity } from "../../../Function.ts"
+import * as Latch from "../../../Latch.ts"
 import * as Metric from "../../../Metric.ts"
 import * as Option from "../../../Option.ts"
 import { CurrentLogAnnotations } from "../../../References.ts"
@@ -75,7 +76,7 @@ export type EntityState = {
   }>
   lastActiveCheck: number
   write: RpcServer.RpcServer<any>["write"]
-  readonly keepAliveLatch: Effect.Latch
+  readonly keepAliveLatch: Latch.Latch
   keepAliveEnabled: boolean
 }
 
@@ -92,7 +93,7 @@ export const make = Effect.fnUntraced(function*<
     readonly sharding: Sharding["Service"]
     readonly storage: MessageStorage.MessageStorage["Service"]
     readonly runnerAddress: RunnerAddress
-    readonly maxIdleTime?: DurationInput | undefined
+    readonly maxIdleTime?: Input | undefined
     readonly concurrency?: number | "unbounded" | undefined
     readonly mailboxCapacity?: number | "unbounded" | undefined
     readonly disableFatalDefects?: boolean | undefined
@@ -116,7 +117,7 @@ export const make = Effect.fnUntraced(function*<
   entityRpcs.set(KeepAliveRpc._tag, KeepAliveRpc as any)
 
   const activeServers = new Map<EntityId, EntityState>()
-  const serverCloseLatches = new Map<EntityAddress, Effect.Latch>()
+  const serverCloseLatches = new Map<EntityAddress, Latch.Latch>()
   const processedRequestIds = new Set<Snowflake.Snowflake>()
 
   const entities: ResourceMap<
@@ -129,8 +130,8 @@ export const make = Effect.fnUntraced(function*<
     }
 
     const scope = yield* Effect.scope
-    const endLatch = Effect.makeLatchUnsafe()
-    const keepAliveLatch = Effect.makeLatchUnsafe()
+    const endLatch = Latch.makeUnsafe()
+    const keepAliveLatch = Latch.makeUnsafe()
 
     // on shutdown, reset the storage for the entity
     yield* Scope.addFinalizerExit(
@@ -336,7 +337,7 @@ export const make = Effect.fnUntraced(function*<
       scope,
       Effect.withFiber((fiber) => {
         activeServers.delete(address.entityId)
-        serverCloseLatches.set(address, Effect.makeLatchUnsafe())
+        serverCloseLatches.set(address, Latch.makeUnsafe())
         internalInterruptors.add(fiber.id)
         return state.write(0, { _tag: "Eof" }).pipe(
           Effect.andThen(Effect.interruptible(endLatch.await)),
@@ -351,7 +352,7 @@ export const make = Effect.fnUntraced(function*<
 
   const reaper = yield* EntityReaper
   const maxIdleTime = Duration.toMillis(
-    Duration.fromDurationInputUnsafe(options.maxIdleTime ?? config.entityMaxIdleTime)
+    Duration.fromInputUnsafe(options.maxIdleTime ?? config.entityMaxIdleTime)
   )
   if (Number.isFinite(maxIdleTime)) {
     yield* reaper.register({

package/src/unstable/cluster/internal/entityReaper.ts

@@ -1,5 +1,6 @@
 import { Clock } from "../../../Clock.ts"
 import * as Effect from "../../../Effect.ts"
+import * as Latch from "../../../Latch.ts"
 import * as Layer from "../../../Layer.ts"
 import * as ServiceMap from "../../../ServiceMap.ts"
 import type { EntityNotAssignedToRunner } from "../ClusterError.ts"
@@ -17,7 +18,7 @@ export class EntityReaper extends ServiceMap.Service<EntityReaper>()("effect/clu
       readonly servers: Map<EntityId, EntityState>
       readonly entities: ResourceMap<EntityAddress, EntityState, EntityNotAssignedToRunner>
     }> = []
-    const latch = yield* Effect.makeLatch()
+    const latch = yield* Latch.make()
 
     const register = (options: {
       readonly maxIdleTime: number

package/src/unstable/cluster/internal/resourceRef.ts

@@ -1,5 +1,6 @@
 import * as Effect from "../../../Effect.ts"
 import * as Exit from "../../../Exit.ts"
+import * as Latch from "../../../Latch.ts"
 import * as MutableRef from "../../../MutableRef.ts"
 import * as Option from "../../../Option.ts"
 import * as Scope from "../../../Scope.ts"
@@ -53,7 +54,7 @@ export class ResourceRef<A, E = never> {
     this.acquire = acquire
   }
 
-  latch = Effect.makeLatchUnsafe(true)
+  latch = Latch.makeUnsafe(true)
 
   getUnsafe(): Option.Option<A> {
     if (this.state.current._tag === "Acquired") {

package/src/unstable/encoding/Sse.ts

@@ -326,11 +326,9 @@ export const encode = <IE, Done>(): Channel.Channel<
  * @category Encoding
  */
 export const encodeSchema = <
-  S extends Schema.Codec<
-    any,
+  S extends Schema.Encoder<
     { readonly id?: string | undefined; readonly event: string; readonly data: string },
-    any,
-    any
+    unknown
   >,
   IE,
   Done

package/src/unstable/eventlog/EventLog.ts

@@ -14,6 +14,7 @@ import type * as Record from "../../Record.ts"
 import * as Redacted from "../../Redacted.ts"
 import * as Schema from "../../Schema.ts"
 import type * as Scope from "../../Scope.ts"
+import * as Semaphore from "../../Semaphore.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
 import type { Covariant } from "../../Types.ts"
 import { Reactivity } from "../reactivity/Reactivity.ts"
@@ -481,7 +482,7 @@ const make = Effect.gen(function*() {
       readonly write: (entry: Entry) => Effect.Effect<void>
     }) => Effect.Effect<void>
   }>()
-  const journalSemaphore = yield* Effect.makeSemaphore(1)
+  const journalSemaphore = yield* Semaphore.make(1)
 
   const reactivity = yield* Reactivity
   const reactivityKeys: Record<string, ReadonlyArray<string>> = {}

package/src/unstable/http/Cookies.ts

@@ -86,7 +86,7 @@ export interface Cookie extends Inspectable.Inspectable {
   readonly options?: {
     readonly domain?: string | undefined
     readonly expires?: Date | undefined
-    readonly maxAge?: Duration.DurationInput | undefined
+    readonly maxAge?: Duration.Input | undefined
     readonly path?: string | undefined
     readonly priority?: "low" | "medium" | "high" | undefined
     readonly httpOnly?: boolean | undefined
@@ -418,7 +418,7 @@ export function makeCookie(
       return Result.fail(CookiesError.fromReason("InvalidCookiePath"))
     }
 
-    if (options.maxAge !== undefined && !Duration.isFinite(Duration.fromDurationInputUnsafe(options.maxAge))) {
+    if (options.maxAge !== undefined && !Duration.isFinite(Duration.fromInputUnsafe(options.maxAge))) {
       return Result.fail(CookiesError.fromReason("CookieInfinityMaxAge"))
     }
   }
@@ -763,7 +763,7 @@ export function serializeCookie(self: Cookie): string {
   const options = self.options
 
   if (options.maxAge !== undefined) {
-    const maxAge = Duration.toSeconds(Duration.fromDurationInputUnsafe(options.maxAge))
+    const maxAge = Duration.toSeconds(Duration.fromInputUnsafe(options.maxAge))
     str += "; Max-Age=" + Math.trunc(maxAge)
   }
 

package/src/unstable/http/HttpClient.ts

@@ -61,11 +61,11 @@ export declare namespace HttpClient {
 
     readonly get: (
       url: string | URL,
-      options?: HttpClientRequest.Options.NoBody
+      options?: HttpClientRequest.Options.NoUrl
     ) => Effect.Effect<HttpClientResponse.HttpClientResponse, E, R>
     readonly head: (
       url: string | URL,
-      options?: HttpClientRequest.Options.NoBody
+      options?: HttpClientRequest.Options.NoUrl
     ) => Effect.Effect<HttpClientResponse.HttpClientResponse, E, R>
     readonly post: (
       url: string | URL,
@@ -132,7 +132,7 @@ export const execute: (
  * @since 4.0.0
  * @category accessors
  */
-export const get: (url: string | URL, options?: HttpClientRequest.Options.NoBody | undefined) => Effect.Effect<
+export const get: (url: string | URL, options?: HttpClientRequest.Options.NoUrl | undefined) => Effect.Effect<
   HttpClientResponse.HttpClientResponse,
   Error.HttpClientError,
   HttpClient
@@ -142,7 +142,7 @@ export const get: (url: string | URL, options?: HttpClientRequest.Options.NoBody
  * @since 4.0.0
  * @category accessors
  */
-export const head: (url: string | URL, options?: HttpClientRequest.Options.NoBody | undefined) => Effect.Effect<
+export const head: (url: string | URL, options?: HttpClientRequest.Options.NoUrl | undefined) => Effect.Effect<
   HttpClientResponse.HttpClientResponse,
   Error.HttpClientError,
   HttpClient

package/src/unstable/http/HttpClientRequest.ts

@@ -61,12 +61,6 @@ export interface Options {
  * @since 4.0.0
  */
 export declare namespace Options {
-  /**
-   * @since 4.0.0
-   * @category models
-   */
-  export interface NoBody extends Omit<Options, "method" | "url" | "body"> {}
-
   /**
    * @since 4.0.0
    * @category models
@@ -133,7 +127,7 @@ export const make = <M extends HttpMethod>(
 ) =>
 (
   url: string | URL,
-  options?: (M extends "GET" | "HEAD" ? Options.NoBody : Options.NoUrl) | undefined
+  options?: Options.NoUrl | undefined
 ): HttpClientRequest =>
   modify(empty, {
     method,
@@ -145,7 +139,7 @@ export const make = <M extends HttpMethod>(
  * @since 4.0.0
  * @category constructors
  */
-export const get: (url: string | URL, options?: Options.NoBody) => HttpClientRequest = make("GET")
+export const get: (url: string | URL, options?: Options.NoUrl) => HttpClientRequest = make("GET")
 
 /**
  * @since 4.0.0
@@ -165,23 +159,33 @@ export const patch: (url: string | URL, options?: Options.NoUrl) => HttpClientRe
  */
 export const put: (url: string | URL, options?: Options.NoUrl) => HttpClientRequest = make("PUT")
 
+const del: (url: string | URL, options?: Options.NoUrl) => HttpClientRequest = make("DELETE")
+
+export {
+  /**
+   * @since 4.0.0
+   * @category constructors
+   */
+  del as delete
+}
+
 /**
  * @since 4.0.0
  * @category constructors
  */
-export const del: (url: string | URL, options?: Options.NoUrl) => HttpClientRequest = make("DELETE")
+export const head: (url: string | URL, options?: Options.NoUrl) => HttpClientRequest = make("HEAD")
 
 /**
  * @since 4.0.0
  * @category constructors
  */
-export const head: (url: string | URL, options?: Options.NoBody) => HttpClientRequest = make("HEAD")
+export const options: (url: string | URL, options?: Options.NoUrl) => HttpClientRequest = make("OPTIONS")
 
 /**
  * @since 4.0.0
  * @category constructors
  */
-export const options: (url: string | URL, options?: Options.NoUrl) => HttpClientRequest = make("OPTIONS")
+export const trace: (url: string | URL, options?: Options.NoUrl) => HttpClientRequest = make("TRACE")
 
 /**
  * @since 4.0.0

package/src/unstable/http/HttpEffect.ts

@@ -6,7 +6,6 @@ import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
 import * as Fiber from "../../Fiber.ts"
 import { dual } from "../../Function.ts"
-import { effectIsExit } from "../../internal/effect.ts"
 import * as Layer from "../../Layer.ts"
 import * as Scope from "../../Scope.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
@@ -32,30 +31,6 @@ export const toHandled = <E, R, EH, RH>(
   ) => Effect.Effect<unknown, EH, RH>,
   middleware?: HttpMiddleware | undefined
 ): Effect.Effect<void, never, Exclude<R | RH | HttpServerRequest, Scope.Scope>> => {
-  const responded = Effect.flatMap(self, (response) => {
-    const fiber = Fiber.getCurrent()!
-    const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest)
-    const handler = fiber.getRef(PreResponseHandlers)
-    if (handler === undefined) {
-      ;(request as any)[handledSymbol] = true
-      const eff = handleResponse(request, response)
-      if (effectIsExit(eff)) {
-        return eff._tag === "Success" ? Effect.succeed(response) : handleCause(eff.cause)
-      }
-      return Effect.matchCauseEffect(eff, {
-        onFailure: handleCause,
-        onSuccess: () => Effect.succeed(response)
-      })
-    }
-    return Effect.flatMapEager(handler(request, response), (sentResponse) => {
-      ;(request as any)[handledSymbol] = true
-      return Effect.matchCauseEffectEager(handleResponse(request, sentResponse), {
-        onSuccess: () => Effect.succeed(response),
-        onFailure: handleCause
-      })
-    })
-  })
-
   const handleCause = (cause: Cause<E | EH | HttpServerError>) =>
     Effect.flatMapEager(causeResponse(cause), ([response, cause]) => {
       const fiber = Fiber.getCurrent()!
@@ -79,6 +54,23 @@ export const toHandled = <E, R, EH, RH>(
       )
     })
 
+  const responded = Effect.matchCauseEffect(self, {
+    onSuccess: (response) => {
+      const fiber = Fiber.getCurrent()!
+      const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest)
+      const handler = fiber.getRef(PreResponseHandlers)
+      if (handler === undefined) {
+        ;(request as any)[handledSymbol] = true
+        return Effect.mapEager(handleResponse(request, response), () => response)
+      }
+      return Effect.flatMapEager(handler(request, response), (sentResponse) => {
+        ;(request as any)[handledSymbol] = true
+        return Effect.mapEager(handleResponse(request, sentResponse), () => response)
+      })
+    },
+    onFailure: handleCause
+  })
+
   const withMiddleware: Effect.Effect<
     unknown,
     E | EH | HttpServerError,

package/src/unstable/http/HttpMethod.ts

@@ -14,6 +14,7 @@ export type HttpMethod =
   | "PATCH"
   | "HEAD"
   | "OPTIONS"
+  | "TRACE"
 
 /**
  * @since 4.0.0
@@ -24,7 +25,7 @@ export declare namespace HttpMethod {
    * @since 4.0.0
    * @category models
    */
-  export type NoBody = "GET" | "HEAD" | "OPTIONS"
+  export type NoBody = "GET" | "HEAD" | "OPTIONS" | "TRACE"
 
   /**
    * @since 4.0.0
@@ -36,12 +37,22 @@ export declare namespace HttpMethod {
 /**
  * @since 4.0.0
  */
-export const hasBody = (method: HttpMethod): boolean => method !== "GET" && method !== "HEAD" && method !== "OPTIONS"
+export const hasBody = (method: HttpMethod): method is HttpMethod.WithBody =>
+  method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE"
 
 /**
  * @since 4.0.0
  */
-export const all: ReadonlySet<HttpMethod> = new Set(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"])
+export const all: ReadonlySet<HttpMethod> = new Set([
+  "GET",
+  "POST",
+  "PUT",
+  "DELETE",
+  "PATCH",
+  "HEAD",
+  "OPTIONS",
+  "TRACE"
+])
 
 /**
  * @since 4.0.0
@@ -53,7 +64,8 @@ export const allShort = [
   ["DELETE", "del"],
   ["PATCH", "patch"],
   ["HEAD", "head"],
-  ["OPTIONS", "options"]
+  ["OPTIONS", "options"],
+  ["TRACE", "trace"]
 ] as const
 
 /**

package/src/unstable/http/Multipart.ts

@@ -203,13 +203,13 @@ export const PersistedFileSchema: PersistedFileSchema = Schema.declare(
  * @since 4.0.0
  * @category Schemas
  */
-export const FilesSchema: Schema.Array$<PersistedFileSchema> = Schema.Array(PersistedFileSchema)
+export const FilesSchema: Schema.$Array<PersistedFileSchema> = Schema.Array(PersistedFileSchema)
 
 /**
  * @since 4.0.0
  * @category Schemas
  */
-export const SingleFileSchema: Schema.decodeTo<PersistedFileSchema, Schema.Array$<PersistedFileSchema>> = FilesSchema
+export const SingleFileSchema: Schema.decodeTo<PersistedFileSchema, Schema.$Array<PersistedFileSchema>> = FilesSchema
   .check(
     Schema.isLengthBetween(1, 1)
   ).pipe(

package/src/unstable/http/UrlParams.ts

@@ -539,7 +539,7 @@ export const schemaJsonField = (field: string): schemaJsonField =>
  */
 export interface schemaRecord extends
   Schema.decodeTo<
-    Schema.Record$<Schema.String, Schema.Union<readonly [Schema.String, Schema.NonEmptyArray<Schema.String>]>>,
+    Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.NonEmptyArray<Schema.String>]>>,
     UrlParamsSchema,
     never,
     never

package/src/unstable/httpapi/HttpApiBuilder.ts

@@ -2,7 +2,7 @@
  * @since 4.0.0
  */
 import * as Effect from "../../Effect.ts"
-import * as Base64 from "../../encoding/Base64.ts"
+import * as Encoding from "../../Encoding.ts"
 import * as Fiber from "../../Fiber.ts"
 import type { FileSystem } from "../../FileSystem.ts"
 import { identity } from "../../Function.ts"
@@ -328,7 +328,7 @@ export const securityDecode = <Security extends HttpApiSecurity.HttpApiSecurity>
       } as any
       return HttpServerRequest.asEffect().pipe(
         Effect.flatMap((request) =>
-          Base64.decodeString((request.headers.authorization ?? "").slice(basicLen)).asEffect()
+          Encoding.decodeBase64String((request.headers.authorization ?? "").slice(basicLen)).asEffect()
         ),
         Effect.match({
           onFailure: () => empty,

package/src/unstable/httpapi/HttpApiScalar.ts

@@ -98,6 +98,12 @@ export type ScalarConfig = {
    * Default: `false`
    */
   defaultOpenAllTags?: boolean
+  /**
+   * Whether to display the operation ID in the operation reference.
+   *
+   * Default: `false`
+   */
+  showOperationId?: boolean
 }
 
 type ScalarSource =

package/src/unstable/observability/Otlp.ts

@@ -28,13 +28,13 @@ export const layer = (options: {
   readonly headers?: Headers.Input | undefined
   readonly maxBatchSize?: number | undefined
   readonly tracerContext?: (<X>(primitive: Tracer.EffectPrimitive<X>, span: Tracer.AnySpan) => X) | undefined
-  readonly loggerExportInterval?: Duration.DurationInput | undefined
+  readonly loggerExportInterval?: Duration.Input | undefined
   readonly loggerExcludeLogSpans?: boolean | undefined
   readonly loggerMergeWithExisting?: boolean | undefined
-  readonly metricsExportInterval?: Duration.DurationInput | undefined
+  readonly metricsExportInterval?: Duration.Input | undefined
   readonly metricsTemporality?: AggregationTemporality | undefined
-  readonly tracerExportInterval?: Duration.DurationInput | undefined
-  readonly shutdownTimeout?: Duration.DurationInput | undefined
+  readonly tracerExportInterval?: Duration.Input | undefined
+  readonly shutdownTimeout?: Duration.Input | undefined
 }): Layer.Layer<never, never, HttpClient.HttpClient | OtlpSerialization.OtlpSerialization> => {
   const base = HttpClientRequest.get(options.baseUrl)
   const url = (path: string) => HttpClientRequest.appendUrl(base, path).url
@@ -83,13 +83,13 @@ export const layerJson: (options: {
   readonly headers?: Headers.Input | undefined
   readonly maxBatchSize?: number | undefined
   readonly tracerContext?: (<X>(primitive: Tracer.EffectPrimitive<X>, span: Tracer.AnySpan) => X) | undefined
-  readonly loggerExportInterval?: Duration.DurationInput | undefined
+  readonly loggerExportInterval?: Duration.Input | undefined
   readonly loggerExcludeLogSpans?: boolean | undefined
   readonly loggerMergeWithExisting?: boolean | undefined
-  readonly metricsExportInterval?: Duration.DurationInput | undefined
+  readonly metricsExportInterval?: Duration.Input | undefined
   readonly metricsTemporality?: AggregationTemporality | undefined
-  readonly tracerExportInterval?: Duration.DurationInput | undefined
-  readonly shutdownTimeout?: Duration.DurationInput | undefined
+  readonly tracerExportInterval?: Duration.Input | undefined
+  readonly shutdownTimeout?: Duration.Input | undefined
 }) => Layer.Layer<never, never, HttpClient.HttpClient> = flow(layer, Layer.provide(OtlpSerialization.layerJson))
 
 /**
@@ -106,11 +106,11 @@ export const layerProtobuf: (options: {
   readonly headers?: Headers.Input | undefined
   readonly maxBatchSize?: number | undefined
   readonly tracerContext?: (<X>(primitive: Tracer.EffectPrimitive<X>, span: Tracer.AnySpan) => X) | undefined
-  readonly loggerExportInterval?: Duration.DurationInput | undefined
+  readonly loggerExportInterval?: Duration.Input | undefined
   readonly loggerExcludeLogSpans?: boolean | undefined
   readonly loggerMergeWithExisting?: boolean | undefined
-  readonly metricsExportInterval?: Duration.DurationInput | undefined
+  readonly metricsExportInterval?: Duration.Input | undefined
   readonly metricsTemporality?: AggregationTemporality | undefined
-  readonly tracerExportInterval?: Duration.DurationInput | undefined
-  readonly shutdownTimeout?: Duration.DurationInput | undefined
+  readonly tracerExportInterval?: Duration.Input | undefined
+  readonly shutdownTimeout?: Duration.Input | undefined
 }) => Layer.Layer<never, never, HttpClient.HttpClient> = flow(layer, Layer.provide(OtlpSerialization.layerProtobuf))