effect 4.0.0-beta.36 → 4.0.0-beta.38

package/src/Schedule.ts

@@ -4053,14 +4053,26 @@ export const fibonacci = (one: Duration.Input): Schedule<Duration.Duration> => {
  */
 export const fixed = (interval: Duration.Input): Schedule<number> => {
   const window = Duration.toMillis(Duration.fromInputUnsafe(interval))
-  return fromStepWithMetadata(effect.succeed((meta) =>
-    effect.succeed([
-      meta.attempt - 1,
-      window === 0
-        ? Duration.zero
-        : Duration.millis(window - (meta.elapsed % window))
-    ])
-  ))
+  return fromStepWithMetadata(effect.sync(() => {
+    let start = 0
+    let lastRun = 0
+    return (meta) =>
+      effect.sync(() => {
+        if (window === 0) {
+          return [meta.attempt - 1, Duration.zero] as const
+        }
+        if (meta.attempt === 1) {
+          start = meta.now
+          lastRun = meta.now + window
+          return [0, Duration.millis(window)] as const
+        }
+        const runningBehind = meta.now > (lastRun + window)
+        const boundary = window - ((meta.now - start) % window)
+        const delay = runningBehind ? 0 : boundary === 0 ? window : boundary
+        lastRun = runningBehind ? meta.now : meta.now + delay
+        return [meta.attempt - 1, Duration.millis(delay)] as const
+      })
+  }))
 }
 
 /**

package/src/Schema.ts

@@ -172,7 +172,7 @@ export type ConstructorDefault = "no-default" | "with-default"
  * Options for `makeUnsafe` and Class constructors.
  *
  * When to use:
- * - Pass `disableValidation: true` to skip validation when you trust the data.
+ * - Pass `disableChecks: true` to skip validation when you trust the data.
  * - Pass `parseOptions` to control error reporting behavior.
  *
  * @see {@link Bottom.makeUnsafe}
@@ -187,7 +187,7 @@ export interface MakeOptions {
   /**
    * Whether to disable validation for the schema.
    */
-  readonly disableValidation?: boolean | undefined
+  readonly disableChecks?: boolean | undefined
 }
 
 /**
@@ -669,9 +669,7 @@ export declare namespace Codec {
    *
    * @since 4.0.0
    */
-  export type ToAsserts<S extends Top & { readonly DecodingServices: never }> = <I>(
-    input: I
-  ) => asserts input is I & S["Type"]
+  export type ToAsserts<S extends Top> = <I>(input: I) => asserts input is I & S["Type"]
 }
 
 /**
@@ -943,9 +941,7 @@ function makeStandardResult<A>(exit: Exit_.Exit<StandardSchemaV1.Result<A>>): St
  * @category Standard Schema
  * @since 4.0.0
  */
-export function toStandardSchemaV1<
-  S extends Top & { readonly DecodingServices: never }
->(
+export function toStandardSchemaV1<S extends Decoder<unknown>>(
   self: S,
   options?: {
     readonly leafHook?: Issue.LeafHook | undefined
@@ -1157,7 +1153,7 @@ export const decodeEffect: <S extends Top>(
  * @category Decoding
  * @since 4.0.0
  */
-export function decodeUnknownExit<S extends Top & { readonly DecodingServices: never }>(schema: S) {
+export function decodeUnknownExit<S extends Decoder<unknown>>(schema: S) {
   const parser = Parser.decodeUnknownExit(schema)
   return (input: unknown, options?: AST.ParseOptions): Exit_.Exit<S["Type"], SchemaError> => {
     return Exit_.mapError(parser(input, options), (issue) => new SchemaError(issue))
@@ -1174,7 +1170,7 @@ export function decodeUnknownExit<S extends Top & { readonly DecodingServices: n
  * @category Decoding
  * @since 4.0.0
  */
-export const decodeExit: <S extends Top & { readonly DecodingServices: never }>(
+export const decodeExit: <S extends Decoder<unknown>>(
   schema: S
 ) => (input: S["Encoded"], options?: AST.ParseOptions) => Exit_.Exit<S["Type"], SchemaError> = decodeUnknownExit
 
@@ -1327,7 +1323,7 @@ export const encodeEffect: <S extends Top>(
  * @category Encoding
  * @since 4.0.0
  */
-export function encodeUnknownExit<S extends Top & { readonly EncodingServices: never }>(schema: S) {
+export function encodeUnknownExit<S extends Encoder<unknown>>(schema: S) {
   const parser = Parser.encodeUnknownExit(schema)
   return (input: unknown, options?: AST.ParseOptions): Exit_.Exit<S["Encoded"], SchemaError> => {
     return Exit_.mapError(parser(input, options), (issue) => new SchemaError(issue))
@@ -1344,7 +1340,7 @@ export function encodeUnknownExit<S extends Top & { readonly EncodingServices: n
  * @category Encoding
  * @since 4.0.0
  */
-export const encodeExit: <S extends Top & { readonly EncodingServices: never }>(
+export const encodeExit: <S extends Encoder<unknown>>(
   schema: S
 ) => (input: S["Type"], options?: AST.ParseOptions) => Exit_.Exit<S["Encoded"], SchemaError> = encodeUnknownExit
 
@@ -9857,12 +9853,8 @@ function makeClass<
   return class extends Inherited {
     constructor(...[input, options]: ReadonlyArray<any>) {
       const props = input ?? {}
-      if (options?.disableValidation) {
-        super(props, options)
-      } else {
-        const validated = struct.makeUnsafe(props, options)
-        super({ ...props, ...validated }, { ...options, disableValidation: true })
-      }
+      const validated = struct.makeUnsafe(props, options)
+      super({ ...props, ...validated }, { ...options, disableChecks: true })
     }
 
     toString() {
@@ -10005,7 +9997,7 @@ function isStruct(schema: Struct.Fields | Struct<Struct.Fields>): schema is Stru
 /**
  * Creates a schema-backed class whose constructor validates input against a
  * {@link Struct} schema. Construction throws a {@link SchemaError} on invalid
- * input (unless `disableValidation` is set in the options).
+ * input (unless `disableChecks` is set in the options).
  *
  * Pass the desired class type as the first type parameter. The second optional
  * type parameter can be used to add nominal brands.
@@ -10050,7 +10042,7 @@ export const Class: {
   /**
    * Creates a schema-backed class whose constructor validates input against a
    * {@link Struct} schema. Construction throws a {@link SchemaError} on invalid
-   * input (unless `disableValidation` is set in the options).
+   * input (unless `disableChecks` is set in the options).
    *
    * Pass the desired class type as the first type parameter. The second optional
    * type parameter can be used to add nominal brands.
@@ -10095,7 +10087,7 @@ export const Class: {
     /**
      * Creates a schema-backed class whose constructor validates input against a
      * {@link Struct} schema. Construction throws a {@link SchemaError} on invalid
-     * input (unless `disableValidation` is set in the options).
+     * input (unless `disableChecks` is set in the options).
      *
      * Pass the desired class type as the first type parameter. The second optional
      * type parameter can be used to add nominal brands.
@@ -10143,7 +10135,7 @@ export const Class: {
     /**
      * Creates a schema-backed class whose constructor validates input against a
      * {@link Struct} schema. Construction throws a {@link SchemaError} on invalid
-     * input (unless `disableValidation` is set in the options).
+     * input (unless `disableChecks` is set in the options).
      *
      * Pass the desired class type as the first type parameter. The second optional
      * type parameter can be used to add nominal brands.

package/src/SchemaAST.ts

@@ -434,6 +434,12 @@ export interface ParseOptions {
    * default: "none"
    */
   readonly propertyOrder?: "none" | "original" | undefined
+
+  /**
+   * Whether to disable checks while still applying defaults and
+   * transformations.
+   */
+  readonly disableChecks?: boolean | undefined
 }
 
 /** @internal */

package/src/SchemaParser.ts

@@ -49,7 +49,12 @@ export function makeEffect<S extends Schema.Top>(schema: S) {
   const ast = recurDefaults(AST.toType(schema.ast))
   const parser = run<S["Type"], never>(ast)
   return (input: S["~type.make.in"], options?: Schema.MakeOptions): Effect.Effect<S["Type"], Issue.Issue> => {
-    return parser(input, options?.parseOptions)
+    return parser(
+      input,
+      options?.disableChecks
+        ? options?.parseOptions ? { ...options.parseOptions, disableChecks: true } : { disableChecks: true }
+        : options?.parseOptions
+    )
   }
 }
 
@@ -84,10 +89,8 @@ export function makeUnsafe<S extends Schema.Top>(schema: S) {
  * @category Asserting
  * @since 4.0.0
  */
-export function is<S extends Schema.Top & { readonly DecodingServices: never }>(
-  schema: S
-): <I>(input: I) => input is I & S["Type"] {
-  return _is<S["Type"]>(schema.ast)
+export function is<T>(schema: Schema.Schema<T>): <I>(input: I) => input is I & T {
+  return _is<T>(schema.ast)
 }
 
 /** @internal */
@@ -113,11 +116,9 @@ export function _issue<T>(ast: AST.AST) {
  * @category Asserting
  * @since 4.0.0
  */
-export function asserts<S extends Schema.Top & { readonly DecodingServices: never }>(
-  schema: S
-) {
-  const parser = asExit(run<S["Type"], never>(AST.toType(schema.ast)))
-  return <I>(input: I): asserts input is I & S["Type"] => {
+export function asserts<T>(schema: Schema.Schema<T>) {
+  const parser = asExit(run<T, never>(AST.toType(schema.ast)))
+  return <I>(input: I): asserts input is I & T => {
     const exit = parser(input, AST.defaultParseOptions)
     if (Exit.isFailure(exit)) {
       const issue = Cause.findError(exit.cause)
@@ -152,7 +153,7 @@ export const decodeEffect: <S extends Schema.Top>(
  * @category Decoding
  * @since 4.0.0
  */
-export function decodeUnknownPromise<S extends Schema.Top & { readonly DecodingServices: never }>(
+export function decodeUnknownPromise<S extends Schema.Decoder<unknown>>(
   schema: S
 ): (input: unknown, options?: AST.ParseOptions) => Promise<S["Type"]> {
   return asPromise(decodeUnknownEffect(schema))
@@ -162,7 +163,7 @@ export function decodeUnknownPromise<S extends Schema.Top & { readonly DecodingS
  * @category Decoding
  * @since 4.0.0
  */
-export function decodePromise<S extends Schema.Top & { readonly DecodingServices: never }>(
+export function decodePromise<S extends Schema.Decoder<unknown>>(
   schema: S
 ): (input: S["Encoded"], options?: AST.ParseOptions) => Promise<S["Type"]> {
   return asPromise(decodeEffect(schema))
@@ -172,7 +173,7 @@ export function decodePromise<S extends Schema.Top & { readonly DecodingServices
  * @category Decoding
  * @since 4.0.0
  */
-export function decodeUnknownExit<S extends Schema.Top & { readonly DecodingServices: never }>(
+export function decodeUnknownExit<S extends Schema.Decoder<unknown>>(
   schema: S
 ): (input: unknown, options?: AST.ParseOptions) => Exit.Exit<S["Type"], Issue.Issue> {
   return asExit(decodeUnknownEffect(schema))
@@ -182,7 +183,7 @@ export function decodeUnknownExit<S extends Schema.Top & { readonly DecodingServ
  * @category Decoding
  * @since 4.0.0
  */
-export const decodeExit: <S extends Schema.Top & { readonly DecodingServices: never }>(
+export const decodeExit: <S extends Schema.Decoder<unknown>>(
   schema: S
 ) => (input: S["Encoded"], options?: AST.ParseOptions) => Exit.Exit<S["Type"], Issue.Issue> = decodeUnknownExit
 
@@ -190,7 +191,7 @@ export const decodeExit: <S extends Schema.Top & { readonly DecodingServices: ne
  * @category Decoding
  * @since 4.0.0
  */
-export function decodeUnknownOption<S extends Schema.Top & { readonly DecodingServices: never }>(
+export function decodeUnknownOption<S extends Schema.Decoder<unknown>>(
   schema: S
 ): (input: unknown, options?: AST.ParseOptions) => Option.Option<S["Type"]> {
   return asOption(decodeUnknownEffect(schema))
@@ -200,7 +201,7 @@ export function decodeUnknownOption<S extends Schema.Top & { readonly DecodingSe
  * @category Decoding
  * @since 4.0.0
  */
-export const decodeOption: <S extends Schema.Top & { readonly DecodingServices: never }>(
+export const decodeOption: <S extends Schema.Decoder<unknown>>(
   schema: S
 ) => (input: S["Encoded"], options?: AST.ParseOptions) => Option.Option<S["Type"]> = decodeUnknownOption
 
@@ -208,7 +209,7 @@ export const decodeOption: <S extends Schema.Top & { readonly DecodingServices:
  * @category Decoding
  * @since 4.0.0
  */
-export function decodeUnknownResult<S extends Schema.Top & { readonly DecodingServices: never }>(
+export function decodeUnknownResult<S extends Schema.Decoder<unknown>>(
   schema: S
 ): (input: unknown, options?: AST.ParseOptions) => Result.Result<S["Type"], Issue.Issue> {
   return asResult(decodeUnknownEffect(schema))
@@ -218,7 +219,7 @@ export function decodeUnknownResult<S extends Schema.Top & { readonly DecodingSe
  * @category Decoding
  * @since 4.0.0
  */
-export const decodeResult: <S extends Schema.Top & { readonly DecodingServices: never }>(
+export const decodeResult: <S extends Schema.Decoder<unknown>>(
   schema: S
 ) => (input: S["Encoded"], options?: AST.ParseOptions) => Result.Result<S["Type"], Issue.Issue> = decodeUnknownResult
 
@@ -226,7 +227,7 @@ export const decodeResult: <S extends Schema.Top & { readonly DecodingServices:
  * @category Decoding
  * @since 4.0.0
  */
-export function decodeUnknownSync<S extends Schema.Top & { readonly DecodingServices: never }>(
+export function decodeUnknownSync<S extends Schema.Decoder<unknown>>(
   schema: S
 ): (input: unknown, options?: AST.ParseOptions) => S["Type"] {
   return asSync(decodeUnknownEffect(schema))
@@ -236,7 +237,7 @@ export function decodeUnknownSync<S extends Schema.Top & { readonly DecodingServ
  * @category Decoding
  * @since 4.0.0
  */
-export const decodeSync: <S extends Schema.Top & { readonly DecodingServices: never }>(
+export const decodeSync: <S extends Schema.Decoder<unknown>>(
   schema: S
 ) => (input: S["Encoded"], options?: AST.ParseOptions) => S["Type"] = decodeUnknownSync
 
@@ -263,7 +264,7 @@ export const encodeEffect: <S extends Schema.Top>(
  * @category Encoding
  * @since 4.0.0
  */
-export const encodeUnknownPromise = <S extends Schema.Top & { readonly EncodingServices: never }>(
+export const encodeUnknownPromise = <S extends Schema.Encoder<unknown>>(
   schema: S
 ): (input: unknown, options?: AST.ParseOptions) => Promise<S["Encoded"]> => asPromise(encodeUnknownEffect(schema))
 
@@ -271,7 +272,7 @@ export const encodeUnknownPromise = <S extends Schema.Top & { readonly EncodingS
  * @category Encoding
  * @since 4.0.0
  */
-export const encodePromise: <S extends Schema.Top & { readonly EncodingServices: never }>(
+export const encodePromise: <S extends Schema.Encoder<unknown>>(
   schema: S
 ) => (input: S["Type"], options?: AST.ParseOptions) => Promise<S["Encoded"]> = encodeUnknownPromise
 
@@ -279,7 +280,7 @@ export const encodePromise: <S extends Schema.Top & { readonly EncodingServices:
  * @category Encoding
  * @since 4.0.0
  */
-export function encodeUnknownExit<S extends Schema.Top & { readonly EncodingServices: never }>(
+export function encodeUnknownExit<S extends Schema.Encoder<unknown>>(
   schema: S
 ): (input: unknown, options?: AST.ParseOptions) => Exit.Exit<S["Encoded"], Issue.Issue> {
   return asExit(encodeUnknownEffect(schema))
@@ -289,7 +290,7 @@ export function encodeUnknownExit<S extends Schema.Top & { readonly EncodingServ
  * @category Encoding
  * @since 4.0.0
  */
-export const encodeExit: <S extends Schema.Top & { readonly EncodingServices: never }>(
+export const encodeExit: <S extends Schema.Encoder<unknown>>(
   schema: S
 ) => (input: S["Type"], options?: AST.ParseOptions) => Exit.Exit<S["Encoded"], Issue.Issue> = encodeUnknownExit
 
@@ -297,7 +298,7 @@ export const encodeExit: <S extends Schema.Top & { readonly EncodingServices: ne
  * @category Encoding
  * @since 4.0.0
  */
-export function encodeUnknownOption<S extends Schema.Top & { readonly EncodingServices: never }>(
+export function encodeUnknownOption<S extends Schema.Encoder<unknown>>(
   schema: S
 ): (input: unknown, options?: AST.ParseOptions) => Option.Option<S["Encoded"]> {
   return asOption(encodeUnknownEffect(schema))
@@ -307,7 +308,7 @@ export function encodeUnknownOption<S extends Schema.Top & { readonly EncodingSe
  * @category Encoding
  * @since 4.0.0
  */
-export const encodeOption: <S extends Schema.Top & { readonly EncodingServices: never }>(
+export const encodeOption: <S extends Schema.Encoder<unknown>>(
   schema: S
 ) => (input: S["Type"], options?: AST.ParseOptions) => Option.Option<S["Encoded"]> = encodeUnknownOption
 
@@ -315,7 +316,7 @@ export const encodeOption: <S extends Schema.Top & { readonly EncodingServices:
  * @category Encoding
  * @since 4.0.0
  */
-export function encodeUnknownResult<S extends Schema.Top & { readonly EncodingServices: never }>(
+export function encodeUnknownResult<S extends Schema.Encoder<unknown>>(
   schema: S
 ): (input: unknown, options?: AST.ParseOptions) => Result.Result<S["Encoded"], Issue.Issue> {
   return asResult(encodeUnknownEffect(schema))
@@ -325,7 +326,7 @@ export function encodeUnknownResult<S extends Schema.Top & { readonly EncodingSe
  * @category Encoding
  * @since 4.0.0
  */
-export const encodeResult: <S extends Schema.Top & { readonly EncodingServices: never }>(
+export const encodeResult: <S extends Schema.Encoder<unknown>>(
   schema: S
 ) => (input: S["Type"], options?: AST.ParseOptions) => Result.Result<S["Encoded"], Issue.Issue> = encodeUnknownResult
 
@@ -333,7 +334,7 @@ export const encodeResult: <S extends Schema.Top & { readonly EncodingServices:
  * @category Encoding
  * @since 4.0.0
  */
-export function encodeUnknownSync<S extends Schema.Top & { readonly EncodingServices: never }>(
+export function encodeUnknownSync<S extends Schema.Encoder<unknown>>(
   schema: S
 ): (input: unknown, options?: AST.ParseOptions) => S["Encoded"] {
   return asSync(encodeUnknownEffect(schema))
@@ -343,7 +344,7 @@ export function encodeUnknownSync<S extends Schema.Top & { readonly EncodingServ
  * @category Encoding
  * @since 4.0.0
  */
-export const encodeSync: <S extends Schema.Top & { readonly EncodingServices: never }>(
+export const encodeSync: <S extends Schema.Encoder<unknown>>(
   schema: S
 ) => (input: S["Type"], options?: AST.ParseOptions) => S["Encoded"] = encodeUnknownSync
 
@@ -449,7 +450,7 @@ const recur = memoize(
       parser ??= ast.getParser(recur)
       let sroa = srou ? Effect.flatMapEager(srou, (ou) => parser(ou, options)) : parser(ou, options)
 
-      if (ast.checks) {
+      if (ast.checks && !options?.disableChecks) {
         const checks = ast.checks
         if (options?.errors === "all" && isStructural && Option.isSome(ou)) {
           sroa = Effect.catchEager(sroa, (issue) => {

package/src/Sink.ts

@@ -63,6 +63,9 @@ export interface Sink<out A, in In = unknown, out L = never, out E = never, out
     upstream: Pull.Pull<NonEmptyReadonlyArray<In>, never, void>,
     scope: Scope.Scope
   ) => Effect.Effect<End<A, L>, E, R>
+  [Unify.typeSymbol]?: unknown
+  [Unify.unifySymbol]?: SinkUnify<this>
+  [Unify.ignoreSymbol]?: SinkUnifyIgnore
 }
 
 /**
@@ -122,8 +125,8 @@ export interface SinkUnify<A extends { [Unify.typeSymbol]?: any }> extends Effec
  * @category models
  * @since 2.0.0
  */
-export interface SinkUnifyIgnore extends Effect.EffectUnifyIgnore {
-  Sink?: true
+export interface SinkUnifyIgnore {
+  Effect?: true
 }
 
 /**

package/src/Stream.ts

@@ -142,7 +142,7 @@ export interface StreamUnify<A extends { [Unify.typeSymbol]?: any }> extends Eff
  * @category Models
  * @since 2.0.0
  */
-export interface StreamUnifyIgnore extends Effect.EffectUnifyIgnore {
+export interface StreamUnifyIgnore {
   Effect?: true
 }
 

package/src/internal/effect.ts

@@ -5131,7 +5131,7 @@ export const runSyncExitWith = <R>(services: ServiceMap.ServiceMap<R>) => {
     const scheduler = new Scheduler.MixedScheduler("sync")
     const fiber = runFork(effect, { scheduler })
     fiber.currentDispatcher?.flush()
-    return (fiber as FiberImpl<A, E>)._exit ?? exitDie(fiber)
+    return (fiber as FiberImpl<A, E>)._exit ?? exitDie(new AsyncFiberError(fiber))
   }
 }
 
@@ -5708,6 +5708,28 @@ export class ExceededCapacityError extends TaggedError("ExceededCapacityError")
   }
 }
 
+/** @internal */
+export const AsyncFiberErrorTypeId = "~effect/Cause/AsyncFiberError"
+
+/** @internal */
+export const isAsyncFiberError = (
+  u: unknown
+): u is Cause.AsyncFiberError => hasProperty(u, AsyncFiberErrorTypeId)
+
+/** @internal */
+export class AsyncFiberError extends TaggedError("AsyncFiberError")<{
+  fiber: Fiber.Fiber<unknown, unknown>
+  message: string
+}> {
+  readonly [AsyncFiberErrorTypeId] = AsyncFiberErrorTypeId
+  constructor(fiber: Fiber.Fiber<unknown, unknown>) {
+    super({
+      message: "An asynchronous Effect was executed with Effect.runSync",
+      fiber
+    })
+  }
+}
+
 /** @internal */
 export const UnknownErrorTypeId = "~effect/Cause/UnknownError"
 
@@ -5717,7 +5739,10 @@ export const isUnknownError = (
 ): u is Cause.UnknownError => hasProperty(u, UnknownErrorTypeId)
 
 /** @internal */
-export class UnknownError extends TaggedError("UnknownError") {
+export class UnknownError extends TaggedError("UnknownError")<{
+  cause: unknown
+  message?: string | undefined
+}> {
   readonly [UnknownErrorTypeId] = UnknownErrorTypeId
   constructor(cause: unknown, message?: string) {
     super({ message, cause } as any)

package/src/unstable/cli/Prompt.ts

@@ -2193,11 +2193,14 @@ const processSelection = Effect.fnUntraced(function*(state: FileState, options:
 
 const handleFileProcess = (options: FileOptionsReq) => {
   return Effect.fnUntraced(function*(input: Terminal.UserInput, state: FileState) {
-    if (input.key.ctrl && input.key.name === "u") {
-      if (showConfirmation(state.confirm)) {
-        return Action.Beep()
+    if (input.key.ctrl) {
+      if (input.key.name === "u") {
+        if (showConfirmation(state.confirm)) {
+          return Action.Beep()
+        }
+        return yield* processFileClear(state)
       }
-      return yield* processFileClear(state)
+      return Action.Beep()
     }
     switch (input.key.name) {
       case "k":
@@ -3160,8 +3163,11 @@ const handleSelectProcess = <A>(options: SelectOptionsReq<A>) => {
 
 const handleAutoCompleteProcess = <A>(options: AutoCompleteOptionsReq<A>) => {
   return (input: Terminal.UserInput, state: AutoCompleteState) => {
-    if (input.key.ctrl && input.key.name === "u") {
-      return processAutoCompleteClear(state, options)
+    if (input.key.ctrl) {
+      if (input.key.name === "u") {
+        return processAutoCompleteClear(state, options)
+      }
+      return Effect.succeed(Action.Beep())
     }
     switch (input.key.name) {
       case "k":
@@ -3423,6 +3429,9 @@ const handleTextProcess = (options: TextOptionsReq) => {
         case "e": {
           return processTextCursorEnd(state)
         }
+        default: {
+          return Effect.succeed(Action.Beep())
+        }
       }
     }
     switch (input.key.name) {

package/src/unstable/cluster/EntityAddress.ts

@@ -56,4 +56,4 @@ export const make = (options: {
   readonly shardId: ShardId
   readonly entityType: EntityType
   readonly entityId: EntityId
-}): EntityAddress => new EntityAddress(options, { disableValidation: true })
+}): EntityAddress => new EntityAddress(options, { disableChecks: true })

package/src/unstable/cluster/Runner.ts

@@ -93,4 +93,4 @@ export const make = (props: {
   readonly address: RunnerAddress
   readonly groups: ReadonlyArray<string>
   readonly weight: number
-}): Runner => new Runner(props, { disableValidation: true })
+}): Runner => new Runner(props, { disableChecks: true })

package/src/unstable/cluster/RunnerAddress.ts

@@ -63,4 +63,4 @@ export class RunnerAddress extends Schema.Class<RunnerAddress>(TypeId)({
  * @category constructors
  */
 export const make = (host: string, port: number): RunnerAddress =>
-  new RunnerAddress({ host, port }, { disableValidation: true })
+  new RunnerAddress({ host, port }, { disableChecks: true })

package/src/unstable/cluster/ShardId.ts

@@ -8,7 +8,7 @@ import * as S from "../../Schema.ts"
 
 const TypeId = "~effect/cluster/ShardId"
 
-const constDisableValidation = { disableValidation: true }
+const constDisableChecks = { disableChecks: true }
 
 /**
  * @since 4.0.0
@@ -18,7 +18,7 @@ export const make = (group: string, id: number): ShardId => {
   const key = `${group}:${id}`
   let shardId = shardIdCache.get(key)
   if (!shardId) {
-    shardId = new ShardId({ group, id }, constDisableValidation)
+    shardId = new ShardId({ group, id }, constDisableChecks)
     shardIdCache.set(key, shardId)
   }
   return shardId

package/src/unstable/devtools/DevToolsClient.ts

@@ -4,6 +4,7 @@
 import * as Cause from "../../Cause.ts"
 import * as Deferred from "../../Deferred.ts"
 import * as Effect from "../../Effect.ts"
+import * as Fiber from "../../Fiber.ts"
 import * as Layer from "../../Layer.ts"
 import * as Metric from "../../Metric.ts"
 import * as Queue from "../../Queue.ts"
@@ -23,9 +24,14 @@ const ResponseSchema = Schema.toCodecJson(DevToolsSchema.Response)
  * @since 4.0.0
  * @category tags
  */
-export class DevToolsClient extends ServiceMap.Service<DevToolsClient, {
-  readonly sendUnsafe: (_: DevToolsSchema.Span | DevToolsSchema.SpanEvent) => void
-}>()("effect/devtools/DevToolsClient") {}
+export class DevToolsClient extends ServiceMap.Service<
+  DevToolsClient,
+  {
+    readonly sendUnsafe: (
+      _: DevToolsSchema.Span | DevToolsSchema.SpanEvent
+    ) => void
+  }
+>()("effect/devtools/DevToolsClient") {}
 
 const makeEffect = Effect.gen(function*() {
   const socket = yield* Socket.Socket
@@ -37,7 +43,9 @@ const makeEffect = Effect.gen(function*() {
     Queue.offerUnsafe(requests, toMetricsSnapshot(services))
   })
 
-  const handleResponse = (response: DevToolsSchema.Response): Effect.Effect<void> => {
+  const handleResponse = (
+    response: DevToolsSchema.Response
+  ): Effect.Effect<void> => {
     switch (response._tag) {
       case "MetricsRequest": {
         return offerMetricsSnapshot
@@ -48,7 +56,7 @@ const makeEffect = Effect.gen(function*() {
     }
   }
 
-  yield* Stream.fromQueue(requests).pipe(
+  const fiber = yield* Stream.fromQueue(requests).pipe(
     Stream.pipeThroughChannel(
       Ndjson.duplexSchemaString(Socket.toChannelString(socket), {
         inputSchema: RequestSchema,
@@ -57,12 +65,15 @@ const makeEffect = Effect.gen(function*() {
     ),
     Stream.onFirst(() => Deferred.completeWith(connected, Effect.void)),
     Stream.runForEach(handleResponse),
-    Effect.forkScoped
+    Effect.forkDetach
   )
 
   yield* Effect.addFinalizer(() =>
     offerMetricsSnapshot.pipe(
-      Effect.andThen(Effect.flatMap(Effect.fiberId, (id) => Queue.failCause(requests, Cause.interrupt(id))))
+      Effect.andThen(
+        Effect.flatMap(Effect.fiberId, (id) => Queue.failCause(requests, Cause.interrupt(id)))
+      ),
+      Effect.andThen(Fiber.await(fiber))
     )
   )
 
@@ -84,7 +95,9 @@ const makeEffect = Effect.gen(function*() {
   })
 })
 
-const toMetricsSnapshot = (services: ServiceMap.ServiceMap<never>): DevToolsSchema.MetricsSnapshot => ({
+const toMetricsSnapshot = (
+  services: ServiceMap.ServiceMap<never>
+): DevToolsSchema.MetricsSnapshot => ({
   _tag: "MetricsSnapshot",
   metrics: Metric.snapshotUnsafe(services)
 })
@@ -108,11 +121,7 @@ export const make: Effect.Effect<
  * @since 4.0.0
  * @category layers
  */
-export const layer: Layer.Layer<
-  DevToolsClient,
-  never,
-  Socket.Socket
-> = Layer.effect(DevToolsClient, make)
+export const layer: Layer.Layer<DevToolsClient, never, Socket.Socket> = Layer.effect(DevToolsClient, make)
 
 const makeTracerEffect = Effect.gen(function*() {
   const client = yield* DevToolsClient
@@ -162,10 +171,6 @@ export const makeTracer: Effect.Effect<Tracer.Tracer, never, DevToolsClient> = m
  * @since 4.0.0
  * @category layers
  */
-export const layerTracer: Layer.Layer<
-  never,
-  never,
-  Socket.Socket
-> = Layer.effect(Tracer.Tracer, makeTracer).pipe(
+export const layerTracer: Layer.Layer<never, never, Socket.Socket> = Layer.effect(Tracer.Tracer, makeTracer).pipe(
   Layer.provide(layer)
 )