effect 4.0.0-beta.3 → 4.0.0-beta.30

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.
@@ -171,11 +170,11 @@ export const layerDefaults: Layer.Layer<ShardingConfig> = layer()
 export const config: Config.Config<ShardingConfig["Service"]> = Config.all({
   runnerAddress: Config.all({
     host: Config.string("host").pipe(
-      Config.withDefault(() => defaultRunnerAddress.host)
+      Config.withDefault(defaultRunnerAddress.host)
       // Config.withDescription("The hostname or IP address of the runner.")
     ),
     port: Config.int("port").pipe(
-      Config.withDefault(() => defaultRunnerAddress.port)
+      Config.withDefault(defaultRunnerAddress.port)
       // Config.withDescription("The port used for inter-runner communication.")
     )
   }).pipe(Config.map((options) => RunnerAddress.makeUnsafe(options)), Config.option, Config.map(Option.getOrUndefined)),
@@ -183,79 +182,79 @@ export const config: Config.Config<ShardingConfig["Service"]> = Config.all({
     host: Config.string("listenHost"),
     // Config.withDescription("The host to listen on.")
     port: Config.int("listenPort").pipe(
-      Config.withDefault(() => defaultRunnerAddress.port)
+      Config.withDefault(defaultRunnerAddress.port)
       // Config.withDescription("The port to listen on.")
     )
   }).pipe(Config.map((options) => RunnerAddress.makeUnsafe(options)), Config.option, Config.map(Option.getOrUndefined)),
   runnerShardWeight: Config.int("runnerShardWeight").pipe(
-    Config.withDefault(() => defaults.runnerShardWeight)
+    Config.withDefault(defaults.runnerShardWeight)
     // Config.withDescription("A number that determines how many shards this runner will be assigned relative to other runners.")
   ),
   shardGroups: Config.schema(Schema.Array(Schema.String), "shardGroups").pipe(
-    Config.withDefault(() => ["default"])
+    Config.withDefault(["default"])
     // Config.withDescription("The shard groups that are assigned to this runner.")
   ),
   shardsPerGroup: Config.int("shardsPerGroup").pipe(
-    Config.withDefault(() => defaults.shardsPerGroup)
+    Config.withDefault(defaults.shardsPerGroup)
     // Config.withDescription("The number of shards to allocate per shard group.")
   ),
   shardLockRefreshInterval: Config.duration("shardLockRefreshInterval").pipe(
-    Config.withDefault(() => defaults.shardLockRefreshInterval)
+    Config.withDefault(defaults.shardLockRefreshInterval)
     // Config.withDescription("Shard lock refresh interval.")
   ),
   shardLockExpiration: Config.duration("shardLockExpiration").pipe(
-    Config.withDefault(() => defaults.shardLockExpiration)
+    Config.withDefault(defaults.shardLockExpiration)
     // Config.withDescription("Shard lock expiration duration.")
   ),
   shardLockDisableAdvisory: Config.boolean("shardLockDisableAdvisory").pipe(
-    Config.withDefault(() => defaults.shardLockDisableAdvisory)
+    Config.withDefault(defaults.shardLockDisableAdvisory)
     // Config.withDescription("Disable the use of advisory locks for shard locking.")
   ),
   preemptiveShutdown: Config.boolean("preemptiveShutdown").pipe(
-    Config.withDefault(() => defaults.preemptiveShutdown)
+    Config.withDefault(defaults.preemptiveShutdown)
     // Config.withDescription("Start shutting down as soon as an Entity has started shutting down.")
   ),
   entityMailboxCapacity: Config.int("entityMailboxCapacity").pipe(
-    Config.withDefault(() => defaults.entityMailboxCapacity)
+    Config.withDefault(defaults.entityMailboxCapacity)
     // Config.withDescription("The default capacity of the mailbox for entities.")
   ),
   entityMaxIdleTime: Config.duration("entityMaxIdleTime").pipe(
-    Config.withDefault(() => defaults.entityMaxIdleTime)
+    Config.withDefault(defaults.entityMaxIdleTime)
     // Config.withDescription(
     //   "The maximum duration of inactivity (i.e. without receiving a message) after which an entity will be interrupted."
     // )
   ),
   entityRegistrationTimeout: Config.duration("entityRegistrationTimeout").pipe(
-    Config.withDefault(() => defaults.entityRegistrationTimeout)
+    Config.withDefault(defaults.entityRegistrationTimeout)
     // Config.withDescription("If an entity does not register itself within this time after a message is sent to it, the message will be marked as failed.")
   ),
   entityTerminationTimeout: Config.duration("entityTerminationTimeout").pipe(
-    Config.withDefault(() => defaults.entityTerminationTimeout)
+    Config.withDefault(defaults.entityTerminationTimeout)
     // Config.withDescription("The maximum duration of time to wait for an entity to terminate.")
   ),
   entityMessagePollInterval: Config.duration("entityMessagePollInterval").pipe(
-    Config.withDefault(() => defaults.entityMessagePollInterval)
+    Config.withDefault(defaults.entityMessagePollInterval)
     // Config.withDescription("The interval at which to poll for unprocessed messages from storage.")
   ),
   entityReplyPollInterval: Config.duration("entityReplyPollInterval").pipe(
-    Config.withDefault(() => defaults.entityReplyPollInterval)
+    Config.withDefault(defaults.entityReplyPollInterval)
     // Config.withDescription("The interval at which to poll for client replies from storage.")
   ),
   sendRetryInterval: Config.duration("sendRetryInterval").pipe(
-    Config.withDefault(() => defaults.sendRetryInterval)
+    Config.withDefault(defaults.sendRetryInterval)
     // Config.withDescription("The interval to retry a send if EntityNotManagedByRunner is returned.")
   ),
   refreshAssignmentsInterval: Config.duration("refreshAssignmentsInterval").pipe(
-    Config.withDefault(() => defaults.refreshAssignmentsInterval)
+    Config.withDefault(defaults.refreshAssignmentsInterval)
     // Config.withDescription("The interval at which to refresh shard assignments.")
   ),
   runnerHealthCheckInterval: Config.duration("runnerHealthCheckInterval").pipe(
-    Config.withDefault(() => defaults.runnerHealthCheckInterval)
+    Config.withDefault(defaults.runnerHealthCheckInterval)
     // Config.withDescription("The interval at which to check for unhealthy runners and report them.")
   ),
   // unhealthyRunnerReportInterval: Config.duration("unhealthyRunnerReportInterval").pipe(
   simulateRemoteSerialization: Config.boolean("simulateRemoteSerialization").pipe(
-    Config.withDefault(() => defaults.simulateRemoteSerialization)
+    Config.withDefault(defaults.simulateRemoteSerialization)
     // Config.withDescription("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

@@ -311,7 +311,7 @@ export const encode = <IE, Done>(): Channel.Channel<
       let done = false
       const pull = upstream.pipe(
         Effect.map(Arr.map(encoder.write)),
-        Effect.catchIf(Retry.filter as any, (retry: any) => {
+        Effect.catchFilter(Retry.filter as any, (retry: any) => {
           done = true
           return Effect.succeed(Arr.of(encoder.write(retry)))
         }),
@@ -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"))
     }
   }
@@ -668,6 +668,90 @@ export const setUnsafe: {
     ))
 )
 
+/**
+ * Add an expired cookie to a Cookies object
+ *
+ * @since 4.0.0
+ * @category combinators
+ */
+export const expireCookie: {
+  /**
+   * Add an expired cookie to a Cookies object
+   *
+   * @since 4.0.0
+   * @category combinators
+   */
+  (
+    name: string,
+    options?: Omit<NonNullable<Cookie["options"]>, "expires" | "maxAge">
+  ): (self: Cookies) => Result.Result<Cookies, CookiesError>
+  /**
+   * Add an expired cookie to a Cookies object
+   *
+   * @since 4.0.0
+   * @category combinators
+   */
+  (
+    self: Cookies,
+    name: string,
+    options?: Omit<NonNullable<Cookie["options"]>, "expires" | "maxAge">
+  ): Result.Result<Cookies, CookiesError>
+} = dual(
+  (args) => isCookies(args[0]),
+  (
+    self: Cookies,
+    name: string,
+    options?: Omit<NonNullable<Cookie["options"]>, "expires" | "maxAge">
+  ) =>
+    set(self, name, "", {
+      ...options,
+      maxAge: 0,
+      expires: new Date(0)
+    })
+)
+
+/**
+ * Add an expired cookie to a Cookies object, throwing an error if invalid
+ *
+ * @since 4.0.0
+ * @category combinators
+ */
+export const expireCookieUnsafe: {
+  /**
+   * Add an expired cookie to a Cookies object, throwing an error if invalid
+   *
+   * @since 4.0.0
+   * @category combinators
+   */
+  (
+    name: string,
+    options?: Omit<NonNullable<Cookie["options"]>, "expires" | "maxAge">
+  ): (self: Cookies) => Cookies
+  /**
+   * Add an expired cookie to a Cookies object, throwing an error if invalid
+   *
+   * @since 4.0.0
+   * @category combinators
+   */
+  (
+    self: Cookies,
+    name: string,
+    options?: Omit<NonNullable<Cookie["options"]>, "expires" | "maxAge">
+  ): Cookies
+} = dual(
+  (args) => isCookies(args[0]),
+  (
+    self: Cookies,
+    name: string,
+    options?: Omit<NonNullable<Cookie["options"]>, "expires" | "maxAge">
+  ): Cookies =>
+    setUnsafe(self, name, "", {
+      ...options,
+      maxAge: 0,
+      expires: new Date(0)
+    })
+)
+
 /**
  * Add multiple cookies to a Cookies object
  *
@@ -763,7 +847,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/Headers.ts

@@ -44,22 +44,37 @@ export interface Headers extends Redactable.Redactable {
   readonly [key: string]: string
 }
 
-const Proto = Object.assign(Object.create(null), Inspectable.BaseProto, {
-  [TypeId]: TypeId,
-  [Redactable.symbolRedactable](
-    this: Headers,
-    context: ServiceMap.ServiceMap<never>
-  ): Record<string, string | Redacted.Redacted<string>> {
-    return redact(this, ServiceMap.get(context, CurrentRedactedNames))
+const Proto = Object.create(null)
+
+Object.defineProperties(Proto, {
+  [TypeId]: {
+    value: TypeId
   },
-  toJSON() {
-    return Redactable.redact(this)
+  [Redactable.symbolRedactable]: {
+    value(this: Headers, context: ServiceMap.ServiceMap<never>): Record<string, string | Redacted.Redacted<string>> {
+      return redact(this, ServiceMap.get(context, CurrentRedactedNames))
+    }
   },
-  [Equal.symbol](this: Headers, that: Headers): boolean {
-    return Equivalence(this, that)
+  toJSON: {
+    value(this: Headers) {
+      return Redactable.redact(this)
+    }
+  },
+  [Equal.symbol]: {
+    value(this: Headers, that: Headers): boolean {
+      return Equivalence(this, that)
+    }
   },
-  [Hash.symbol](this: Headers): number {
-    return Hash.structure(this)
+  [Hash.symbol]: {
+    value(this: Headers): number {
+      return Hash.structure(this)
+    }
+  },
+  toString: {
+    value: Inspectable.BaseProto.toString
+  },
+  [Inspectable.NodeInspectSymbol]: {
+    value: Inspectable.BaseProto[Inspectable.NodeInspectSymbol]
   }
 })
 
@@ -337,6 +352,40 @@ export const remove: {
   return out
 })
 
+/**
+ * @since 4.0.0
+ * @category combinators
+ */
+export const removeMany: {
+  /**
+   * @since 4.0.0
+   * @category combinators
+   */
+  (keys: Iterable<string>): (self: Headers) => Headers
+  /**
+   * @since 4.0.0
+   * @category combinators
+   */
+  (self: Headers, keys: Iterable<string>): Headers
+} = dual<
+  /**
+   * @since 4.0.0
+   * @category combinators
+   */
+  (keys: Iterable<string>) => (self: Headers) => Headers,
+  /**
+   * @since 4.0.0
+   * @category combinators
+   */
+  (self: Headers, keys: Iterable<string>) => Headers
+>(2, (self, keys) => {
+  const out = make(self)
+  for (const key of keys) {
+    delete out[key.toLowerCase()]
+  }
+  return out
+})
+
 /**
  * @since 4.0.0
  * @category combinators

package/src/unstable/http/HttpBody.ts

@@ -279,7 +279,7 @@ export class FormData extends Proto {
  * @since 4.0.0
  * @category constructors
  */
-export const makeFormData = (body: globalThis.FormData): FormData => new FormData(body)
+export const formData = (body: globalThis.FormData): FormData => new FormData(body)
 
 /**
  * @since 4.0.0
@@ -308,18 +308,18 @@ const appendFormDataValue = (formData: globalThis.FormData, key: string, value:
  * @since 4.0.0
  * @category constructors
  */
-export const makeFormDataRecord = (entries: FormDataInput): FormData => {
-  const formData = new globalThis.FormData()
+export const formDataRecord = (entries: FormDataInput): FormData => {
+  const data = new globalThis.FormData()
   for (const [key, value] of Object.entries(entries)) {
     if (Array.isArray(value)) {
       for (const item of value) {
-        appendFormDataValue(formData, key, item)
+        appendFormDataValue(data, key, item)
       }
     } else {
-      appendFormDataValue(formData, key, value as FormDataCoercible)
+      appendFormDataValue(data, key, value as FormDataCoercible)
     }
   }
-  return makeFormData(formData)
+  return formData(data)
 }
 
 /**