effect 4.0.0-beta.1 → 4.0.0-beta.10

package/src/unstable/reactivity/AtomHttpApi.ts

@@ -51,8 +51,8 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
       infer _Name,
       infer _Method,
       infer _Path,
-      infer _PathSchema,
-      infer _UrlParams,
+      infer _Params,
+      infer _Query,
       infer _Payload,
       infer _Headers,
       infer _Success,
@@ -62,7 +62,7 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
     >
   ] ? Atom.AtomResultFn<
       Simplify<
-        HttpApiEndpoint.ClientRequest<_PathSchema, _UrlParams, _Payload, _Headers, false> & {
+        HttpApiEndpoint.ClientRequest<_Params, _Query, _Payload, _Headers, false> & {
           readonly reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
         }
       >,
@@ -88,8 +88,8 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
         infer _Name,
         infer _Method,
         infer _Path,
-        infer _PathSchema,
-        infer _UrlParams,
+        infer _Params,
+        infer _Query,
         infer _Payload,
         infer _Headers,
         infer _Success,
@@ -98,12 +98,12 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
         infer _RE
       >
     ] ? Simplify<
-        HttpApiEndpoint.ClientRequest<_PathSchema, _UrlParams, _Payload, _Headers, WithResponse> & {
+        HttpApiEndpoint.ClientRequest<_Params, _Query, _Payload, _Headers, WithResponse> & {
           readonly reactivityKeys?:
             | ReadonlyArray<unknown>
             | ReadonlyRecord<string, ReadonlyArray<unknown>>
             | undefined
-          readonly timeToLive?: Duration.DurationInput | undefined
+          readonly timeToLive?: Duration.Input | undefined
         }
       >
       : never
@@ -112,7 +112,8 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
       infer _Name,
       infer _Method,
       infer _Path,
-      infer _UrlParams,
+      infer _Params,
+      infer _Query,
       infer _Payload,
       infer _Headers,
       infer _Success,
@@ -170,8 +171,8 @@ export const Service = <Self>() =>
 
   const mutationFamily = Atom.family(({ endpoint, group, withResponse }: MutationKey) =>
     self.runtime.fn<{
-      path: any
-      urlParams: any
+      params: any
+      query: any
       headers: any
       payload: any
       reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
@@ -217,26 +218,26 @@ export const Service = <Self>() =>
     group: string,
     endpoint: string,
     request: {
-      readonly path?: any
-      readonly urlParams?: any
+      readonly params?: any
+      readonly query?: any
       readonly payload?: any
       readonly headers?: any
       readonly withResponse?: boolean
       readonly reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
-      readonly timeToLive?: Duration.DurationInput | undefined
+      readonly timeToLive?: Duration.Input | undefined
     }
   ) =>
     queryFamily({
       group,
       endpoint,
-      path: request.path,
-      urlParams: request.urlParams,
+      params: request.params,
+      query: request.query,
       payload: request.payload,
       headers: request.headers,
       withResponse: request.withResponse ?? false,
       reactivityKeys: request.reactivityKeys,
       timeToLive: request.timeToLive
-        ? Duration.fromDurationInputUnsafe(request.timeToLive)
+        ? Duration.fromInputUnsafe(request.timeToLive)
         : undefined
     })) as any
 
@@ -252,8 +253,8 @@ interface MutationKey {
 interface QueryKey {
   group: string
   endpoint: string
-  path: any
-  urlParams: any
+  params: any
+  query: any
   headers: any
   payload: any
   withResponse: boolean

package/src/unstable/reactivity/AtomRpc.ts

@@ -71,7 +71,7 @@ export interface AtomRpcClient<Self, Id extends string, Rpcs extends Rpc.Any, E>
         | ReadonlyArray<unknown>
         | ReadonlyRecord<string, ReadonlyArray<unknown>>
         | undefined
-      readonly timeToLive?: Duration.DurationInput | undefined
+      readonly timeToLive?: Duration.Input | undefined
     }
   ) => Rpc.ExtractTag<Rpcs, Tag> extends Rpc.Rpc<
     infer _Tag,
@@ -208,7 +208,7 @@ export const Service = <Self>() =>
         | ReadonlyArray<unknown>
         | ReadonlyRecord<string, ReadonlyArray<unknown>>
         | undefined
-      readonly timeToLive?: Duration.DurationInput | undefined
+      readonly timeToLive?: Duration.Input | undefined
     }
   ) =>
     queryFamily({
@@ -219,7 +219,7 @@ export const Service = <Self>() =>
         : undefined,
       reactivityKeys: options?.reactivityKeys,
       timeToLive: options?.timeToLive
-        ? Duration.fromDurationInputUnsafe(options.timeToLive)
+        ? Duration.fromInputUnsafe(options.timeToLive)
         : undefined
     }) as any
 

package/src/unstable/reactivity/Hydration.ts

@@ -0,0 +1,112 @@
+/**
+ * @since 4.0.0
+ */
+import * as AsyncResult from "./AsyncResult.ts"
+import * as Atom from "./Atom.ts"
+import type * as AtomRegistry from "./AtomRegistry.ts"
+
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export interface DehydratedAtom {
+  readonly "~effect/reactivity/DehydratedAtom": true
+}
+
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export interface DehydratedAtomValue extends DehydratedAtom {
+  readonly key: string
+  readonly value: unknown
+  readonly dehydratedAt: number
+  readonly resultPromise?: Promise<unknown> | undefined
+}
+
+/**
+ * @since 4.0.0
+ * @category dehydration
+ */
+export const dehydrate = (
+  registry: AtomRegistry.AtomRegistry,
+  options?: {
+    /**
+     * How to encode `AsyncResult.Initial` values. Default is "ignore".
+     */
+    readonly encodeInitialAs?: "ignore" | "promise" | "value-only" | undefined
+  }
+): Array<DehydratedAtom> => {
+  const encodeInitialResultMode = options?.encodeInitialAs ?? "ignore"
+  const arr: Array<DehydratedAtomValue> = []
+  const now = Date.now()
+  registry.getNodes().forEach((node, key) => {
+    if (!Atom.isSerializable(node.atom)) return
+    const atom = node.atom
+    const value = node.value()
+    const isInitial = AsyncResult.isAsyncResult(value) && AsyncResult.isInitial(value)
+    if (encodeInitialResultMode === "ignore" && isInitial) return
+    const encodedValue = atom[Atom.SerializableTypeId].encode(value)
+
+    // Create a promise that resolves when the atom moves out of Initial state
+    let resultPromise: Promise<unknown> | undefined
+    if (encodeInitialResultMode === "promise" && isInitial) {
+      resultPromise = new Promise((resolve) => {
+        const unsubscribe = registry.subscribe(atom, (newValue) => {
+          if (AsyncResult.isAsyncResult(newValue) && !AsyncResult.isInitial(newValue)) {
+            resolve(atom[Atom.SerializableTypeId].encode(newValue))
+            unsubscribe()
+          }
+        })
+      })
+    }
+
+    arr.push({
+      "~effect/reactivity/DehydratedAtom": true,
+      key: key as string,
+      value: encodedValue,
+      dehydratedAt: now,
+      resultPromise
+    })
+  })
+  return arr as any
+}
+
+/**
+ * @since 4.0.0
+ * @category dehydration
+ */
+export const toValues = (state: ReadonlyArray<DehydratedAtom>): Array<DehydratedAtomValue> => state as any
+
+/**
+ * @since 4.0.0
+ * @category hydration
+ */
+export const hydrate = (
+  registry: AtomRegistry.AtomRegistry,
+  dehydratedState: Iterable<DehydratedAtom>
+): void => {
+  for (const datom of (dehydratedState as Iterable<DehydratedAtomValue>)) {
+    registry.setSerializable(datom.key, datom.value)
+
+    // If there's a resultPromise, it means this was in Initial state when dehydrated
+    // and we should wait for it to resolve to a non-Initial state, then update the registry
+    if (!datom.resultPromise) continue
+    datom.resultPromise.then((resolvedValue) => {
+      // Try to update the existing node directly instead of using setSerializable
+      const nodes = registry.getNodes()
+      const node = nodes.get(datom.key)
+      if (node) {
+        // Decode the resolved value using the node's atom serializable decoder
+        const atom = node.atom as any
+        if (atom[Atom.SerializableTypeId]) {
+          const decoded = atom[Atom.SerializableTypeId].decode(resolvedValue)
+          ;(node as any).setValue(decoded)
+        }
+      } else {
+        // Fallback to setSerializable if node doesn't exist yet
+        registry.setSerializable(datom.key, resolvedValue)
+      }
+    })
+  }
+}

package/src/unstable/reactivity/index.ts

@@ -34,6 +34,11 @@ export * as AtomRegistry from "./AtomRegistry.ts"
  */
 export * as AtomRpc from "./AtomRpc.ts"
 
+/**
+ * @since 4.0.0
+ */
+export * as Hydration from "./Hydration.ts"
+
 /**
  * @since 4.0.0
  */

package/src/unstable/rpc/Rpc.ts

@@ -61,7 +61,7 @@ export interface Rpc<
   readonly payloadSchema: Payload
   readonly successSchema: Success
   readonly errorSchema: Error
-  readonly defectSchema: DefectSchema
+  readonly defectSchema: Schema.Top
   readonly annotations: ServiceMap.ServiceMap<never>
   readonly middlewares: ReadonlySet<Middleware>
   readonly "~requires": Requires
@@ -183,7 +183,7 @@ export interface AnyWithProps extends Pipeable {
   readonly payloadSchema: Schema.Top
   readonly successSchema: Schema.Top
   readonly errorSchema: Schema.Top
-  readonly defectSchema: DefectSchema
+  readonly defectSchema: Schema.Top
   readonly annotations: ServiceMap.ServiceMap<never>
   readonly middlewares: ReadonlySet<RpcMiddleware.AnyServiceWithProps>
   readonly "~requires": any
@@ -696,7 +696,7 @@ const makeProto = <
   readonly payloadSchema: Payload
   readonly successSchema: Success
   readonly errorSchema: Error
-  readonly defectSchema: DefectSchema
+  readonly defectSchema: Schema.Top
   readonly annotations: ServiceMap.ServiceMap<never>
   readonly middlewares: ReadonlySet<Middleware>
 }): Rpc<Tag, Payload, Success, Error, Middleware, Requires> => {

package/src/unstable/rpc/RpcClient.ts

@@ -8,6 +8,7 @@ import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
 import * as Fiber from "../../Fiber.ts"
 import { constVoid, dual, flow, identity } from "../../Function.ts"
+import * as Latch from "../../Latch.ts"
 import * as Layer from "../../Layer.ts"
 import * as Option from "../../Option.ts"
 import * as Pool from "../../Pool.ts"
@@ -20,7 +21,6 @@ import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
 import type * as Struct from "../../Struct.ts"
 import type { Span } from "../../Tracer.ts"
-import type { Mutable } from "../../Types.ts"
 import * as Headers from "../http/Headers.ts"
 import * as HttpBody from "../http/HttpBody.ts"
 import * as HttpClient from "../http/HttpClient.ts"
@@ -45,16 +45,7 @@ import { withRun } from "./Utils.ts"
  * @since 4.0.0
  * @category client
  */
-export type RpcClient<Rpcs extends Rpc.Any, E = never> = Struct.Simplify<
-  & RpcClient.From<RpcClient.NonPrefixed<Rpcs>, E, "">
-  & {
-    readonly [CurrentPrefix in RpcClient.Prefixes<Rpcs>]: RpcClient.From<
-      RpcClient.Prefixed<Rpcs, CurrentPrefix>,
-      E,
-      CurrentPrefix
-    >
-  }
->
+export type RpcClient<Rpcs extends Rpc.Any, E = never> = Struct.Simplify<RpcClient.From<Rpcs, E>>
 
 /**
  * @since 4.0.0
@@ -65,34 +56,8 @@ export declare namespace RpcClient {
    * @since 4.0.0
    * @category client
    */
-  export type Prefixes<Rpcs extends Rpc.Any> = Rpcs["_tag"] extends infer Tag
-    ? Tag extends `${infer Prefix}.${string}` ? Prefix : never
-    : never
-
-  /**
-   * @since 4.0.0
-   * @category client
-   */
-  export type NonPrefixed<Rpcs extends Rpc.Any> = Exclude<Rpcs, { readonly _tag: `${string}.${string}` }>
-
-  /**
-   * @since 4.0.0
-   * @category client
-   */
-  export type Prefixed<Rpcs extends Rpc.Any, Prefix extends string> = Extract<
-    Rpcs,
-    { readonly _tag: `${Prefix}.${string}` }
-  >
-
-  /**
-   * @since 4.0.0
-   * @category client
-   */
-  export type From<Rpcs extends Rpc.Any, E = never, Prefix extends string = ""> = {
-    readonly [
-      Current in Rpcs as Current["_tag"] extends `${Prefix}.${infer Method}` ? Method
-        : Current["_tag"]
-    ]: <
+  export type From<Rpcs extends Rpc.Any, E = never> = {
+    readonly [Current in Rpcs as Current["_tag"]]: <
       const AsQueue extends boolean = false,
       const Discard = false
     >(
@@ -614,16 +579,9 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
     }
   } else {
     client = {}
-    for (const rpc of group.requests.values()) {
-      const dot = rpc._tag.indexOf(".")
-      const prefix = dot === -1 ? undefined : rpc._tag.slice(0, dot)
-      if (prefix !== undefined && !(prefix in client)) {
-        ;(client as any)[prefix] = {} as Mutable<RpcClient.Prefixed<Rpcs, typeof prefix>>
-      }
-      const target = prefix !== undefined ? (client as any)[prefix] : client
-      const tag = prefix !== undefined ? rpc._tag.slice(dot + 1) : rpc._tag
-      target[tag] = onRequest(rpc as any)
-    }
+    group.requests.forEach((rpc) => {
+      client[rpc._tag] = onRequest(rpc as any)
+    })
   }
 
   return { client, write } as const
@@ -1070,7 +1028,7 @@ const defaultRetryPolicy = Schedule.exponential(500, 1.5).pipe(
 
 const makePinger = Effect.fnUntraced(function*<A, E, R>(writePing: Effect.Effect<A, E, R>) {
   let recievedPong = true
-  const latch = Effect.makeLatchUnsafe()
+  const latch = Latch.makeUnsafe()
   const reset = () => {
     recievedPong = true
     latch.closeUnsafe()
@@ -1118,7 +1076,7 @@ export const makeProtocolWorker = (
     readonly maxSize: number
     readonly concurrency?: number | undefined
     readonly targetUtilization?: number | undefined
-    readonly timeToLive: Duration.DurationInput
+    readonly timeToLive: Duration.Input
   }
 ): Effect.Effect<
   Protocol["Service"],
@@ -1133,7 +1091,7 @@ export const makeProtocolWorker = (
 
     const entries = new Map<string, {
       readonly worker: Worker.Worker<FromServerEncoded, FromClientEncoded | RpcWorker.InitialMessage.Encoded>
-      readonly latch: Effect.Latch
+      readonly latch: Latch.Latch
     }>()
 
     const acquire = Effect.gen(function*() {
@@ -1219,7 +1177,7 @@ export const makeProtocolWorker = (
         case "Request": {
           return Pool.get(pool).pipe(
             Effect.flatMap((worker) => {
-              const latch = Effect.makeLatchUnsafe(false)
+              const latch = Latch.makeUnsafe(false)
               entries.set(request.id, { worker, latch })
               return Effect.flatMap(worker.send(request, transferables), () => latch.await)
             }),
@@ -1266,7 +1224,7 @@ export const layerProtocolWorker: (
     readonly maxSize: number
     readonly concurrency?: number | undefined
     readonly targetUtilization?: number | undefined
-    readonly timeToLive: Duration.DurationInput
+    readonly timeToLive: Duration.Input
   }
 ) => Layer.Layer<
   Protocol,

package/src/unstable/rpc/RpcServer.ts

@@ -8,6 +8,7 @@ import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
 import * as Fiber from "../../Fiber.ts"
 import { constant, constTrue, constVoid, identity } from "../../Function.ts"
+import * as Latch from "../../Latch.ts"
 import * as Layer from "../../Layer.ts"
 import type * as Option from "../../Option.ts"
 import * as Predicate from "../../Predicate.ts"
@@ -17,6 +18,7 @@ import * as Result from "../../Result.ts"
 import * as Schedule from "../../Schedule.ts"
 import * as Schema from "../../Schema.ts"
 import * as Scope from "../../Scope.ts"
+import * as Semaphore from "../../Semaphore.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
 import { Stdio } from "../../Stdio.ts"
 import * as Stream from "../../Stream.ts"
@@ -101,18 +103,18 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
   const trackFiber = Fiber.runIn(Scope.forkUnsafe(scope, "parallel"))
   const concurrencySemaphore = concurrency === "unbounded"
     ? undefined
-    : yield* Effect.makeSemaphore(concurrency)
+    : yield* Semaphore.make(concurrency)
 
   type Client = {
     readonly id: number
-    readonly latches: Map<RequestId, Effect.Latch>
+    readonly latches: Map<RequestId, Latch.Latch>
     readonly fibers: Map<RequestId, Fiber.Fiber<unknown, any>>
     ended: boolean
   }
 
   const clients = new Map<number, Client>()
   let isShutdown = false
-  const shutdownLatch = Effect.makeLatchUnsafe(false)
+  const shutdownLatch = Latch.makeUnsafe(false)
   yield* Scope.addFinalizer(
     scope,
     Effect.withFiber((parent) => {
@@ -342,7 +344,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
   ) => {
     let latch = client.latches.get(request.id)
     if (supportsAck && !latch) {
-      latch = Effect.makeLatchUnsafe(false)
+      latch = Latch.makeUnsafe(false)
       client.latches.set(request.id, latch)
     }
     if (Effect.isEffect(stream)) {

package/src/unstable/rpc/Utils.ts

@@ -2,6 +2,7 @@
  * @since 4.0.0
  */
 import * as Effect from "../../Effect.ts"
+import * as Semaphore from "../../Semaphore.ts"
 import type * as ServiceMap from "../../ServiceMap.ts"
 
 /**
@@ -14,7 +15,7 @@ export const withRun = <
 >() =>
 <EX, RX>(f: (write: Parameters<A["run"]>[0]) => Effect.Effect<Omit<A, "run">, EX, RX>): Effect.Effect<A, EX, RX> =>
   Effect.suspend(() => {
-    const semaphore = Effect.makeSemaphoreUnsafe(1)
+    const semaphore = Semaphore.makeUnsafe(1)
     let buffer: Array<[Array<any>, ServiceMap.ServiceMap<never>]> = []
     let write = (...args: Array<any>): Effect.Effect<void> =>
       Effect.servicesWith((context) => {

package/src/unstable/schema/VariantSchema.ts

@@ -3,11 +3,14 @@
  */
 import type { Brand } from "../../Brand.ts"
 import * as Effect from "../../Effect.ts"
-import { constant, dual } from "../../Function.ts"
+import { dual } from "../../Function.ts"
+import * as Option from "../../Option.ts"
 import { type Pipeable, pipeArguments } from "../../Pipeable.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Schema from "../../Schema.ts"
 import type * as AST from "../../SchemaAST.ts"
+import * as Getter from "../../SchemaGetter.ts"
+import * as Transformation from "../../SchemaTransformation.ts"
 import * as Struct_ from "../../Struct.ts"
 
 /**
@@ -465,8 +468,24 @@ export const Override = <A>(value: A): A & Brand<"Override"> => value as any
  * @since 4.0.0
  * @category overrideable
  */
-export interface Overrideable<S extends Schema.Top & Schema.WithoutConstructorDefault>
-  extends Schema.brand<Schema.withConstructorDefault<S>, "Override">
+export interface Overrideable<S extends Schema.Top & Schema.WithoutConstructorDefault> extends
+  Schema.Bottom<
+    (S["Type"] & Brand<"Override">) | undefined,
+    S["Encoded"],
+    S["DecodingServices"],
+    S["EncodingServices"],
+    S["ast"],
+    Overrideable<S>,
+    S["~type.make.in"],
+    (S["Type"] & Brand<"Override">) | undefined,
+    S["~type.parameters"],
+    (S["Type"] & Brand<"Override">) | undefined,
+    S["~type.mutability"],
+    "optional",
+    "with-default",
+    S["~encoded.mutability"],
+    S["~encoded.optionality"]
+  >
 {}
 
 /**
@@ -478,11 +497,21 @@ export const Overrideable = <S extends Schema.Top & Schema.WithoutConstructorDef
   options: {
     readonly defaultValue: Effect.Effect<S["~type.make.in"]>
   }
-) =>
+): Overrideable<S> =>
   schema.pipe(
-    Schema.withConstructorDefault(constant(Effect.asSome(options.defaultValue))),
-    Schema.brand("Override")
-  )
+    Schema.decodeTo(
+      Schema.optional(Schema.brand("Override")(Schema.toType(schema))),
+      Transformation.make({
+        decode: Getter.passthrough(),
+        encode: new Getter.Getter((o) => {
+          if (Option.isSome(o) && o.value !== undefined) {
+            return Effect.succeed(o)
+          }
+          return Effect.asSome(options.defaultValue)
+        })
+      })
+    )
+  ) as any
 
 const StructProto = {
   pipe() {

package/src/unstable/socket/Socket.ts

@@ -5,11 +5,12 @@ import type { NonEmptyReadonlyArray } from "../../Array.ts"
 import type * as Cause from "../../Cause.ts"
 import * as Channel from "../../Channel.ts"
 import * as Deferred from "../../Deferred.ts"
-import type { DurationInput } from "../../Duration.ts"
+import type * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
 import * as FiberSet from "../../FiberSet.ts"
 import { constVoid, dual, flow } from "../../Function.ts"
+import * as Latch from "../../Latch.ts"
 import * as Layer from "../../Layer.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Pull from "../../Pull.ts"
@@ -422,7 +423,7 @@ export const layerWebSocketConstructorGlobal: Layer.Layer<WebSocketConstructor>
  */
 export const makeWebSocket = (url: string | Effect.Effect<string>, options?: {
   readonly closeCodeIsError?: ((code: number) => boolean) | undefined
-  readonly openTimeout?: DurationInput | undefined
+  readonly openTimeout?: Duration.Input | undefined
   readonly protocols?: string | Array<string> | undefined
 }): Effect.Effect<Socket, never, WebSocketConstructor> =>
   fromWebSocket(
@@ -443,12 +444,12 @@ export const fromWebSocket = <RO>(
   acquire: Effect.Effect<globalThis.WebSocket, SocketError, RO>,
   options?: {
     readonly closeCodeIsError?: ((code: number) => boolean) | undefined
-    readonly openTimeout?: DurationInput | undefined
+    readonly openTimeout?: Duration.Input | undefined
   } | undefined
 ): Effect.Effect<Socket, never, Exclude<RO, Scope.Scope>> =>
   Effect.withFiber((fiber) => {
     let currentWS: globalThis.WebSocket | undefined
-    const latch = Effect.makeLatchUnsafe(false)
+    const latch = Latch.makeUnsafe(false)
     const acquireContext = fiber.services as ServiceMap.ServiceMap<RO>
     const closeCodeIsError = options?.closeCodeIsError ?? defaultCloseCodeIsError
 
@@ -618,7 +619,7 @@ export const layerWebSocket: (
   url: string | Effect.Effect<string>,
   options?: {
     readonly closeCodeIsError?: ((code: number) => boolean) | undefined
-    readonly openTimeout?: DurationInput | undefined
+    readonly openTimeout?: Duration.Input | undefined
     readonly protocols?: string | Array<string> | undefined
   } | undefined
 ) => Layer.Layer<Socket, never, WebSocketConstructor> = flow(makeWebSocket, Layer.effect(Socket))
@@ -648,7 +649,7 @@ export const fromTransformStream = <R>(acquire: Effect.Effect<InputTransformStre
   readonly closeCodeIsError?: (code: number) => boolean
 }): Effect.Effect<Socket, never, Exclude<R, Scope.Scope>> =>
   Effect.withFiber((fiber) => {
-    const latch = Effect.makeLatchUnsafe(false)
+    const latch = Latch.makeUnsafe(false)
     let currentStream: {
       readonly stream: InputTransformStream
       readonly fiberSet: FiberSet.FiberSet<any, any>

package/src/unstable/sql/SqlModel.ts

@@ -3,7 +3,7 @@
  * @category models
  */
 import type * as Cause from "../../Cause.ts"
-import type { DurationInput } from "../../Duration.ts"
+import type { Input } from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import { identity } from "../../Function.ts"
 import * as RequestResolver from "../../RequestResolver.ts"
@@ -210,7 +210,7 @@ export const makeDataLoaders = <
     readonly tableName: string
     readonly spanPrefix: string
     readonly idColumn: Id
-    readonly window: DurationInput
+    readonly window: Input
     readonly maxBatchSize?: number | undefined
   }
 ): Effect.Effect<