effect 4.0.0-beta.94 → 4.0.0-beta.98

package/src/internal/effect.ts

@@ -4585,17 +4585,20 @@ const forEachSequential = <A, B, E, R>(
     )
   })
 
+type IterateEagerOptions = {
+  readonly concurrency?: number | undefined
+  readonly start?: number | undefined
+  readonly end?: number | undefined
+  readonly orderedStep?: boolean | undefined
+}
+
 const iterateEagerImpl = <S, A, X, E, R, E2>(options: {
   readonly onItem: (state: S, item: A, index: number) => Effect.Effect<X, E, R>
   readonly step: (state: NoInfer<S>, item: A, exit: Exit.Exit<X, E>, index: number) => Exit.Exit<void, E2> | void
 }): (
   initialState: S,
   items: ReadonlyArray<A>,
-  options?: {
-    readonly concurrency?: number | undefined
-    readonly start?: number | undefined
-    readonly end?: number | undefined
-  }
+  options?: IterateEagerOptions
 ) => Effect.Effect<void, E | E2, R> | undefined => {
   const onItem = options.onItem
   const step = options.step
@@ -4603,15 +4606,12 @@ const iterateEagerImpl = <S, A, X, E, R, E2>(options: {
   return (
     state: S,
     items: ReadonlyArray<A>,
-    opts: {
-      readonly concurrency?: number | undefined
-      readonly start?: number | undefined
-      readonly end?: number | undefined
-    } | undefined
+    opts: IterateEagerOptions | undefined
   ): Effect.Effect<void, E | E2, R> | undefined => {
     let index = opts?.start ?? 0
     const end = opts?.end ?? items.length
     const concurrency = opts?.concurrency ?? 1
+    const orderedStep = opts?.orderedStep === true && concurrency > 1
     let done = false
     let parentFiber: Fiber.Fiber<any, any> | undefined
     let fibers: Set<Fiber.Fiber<any, any>> | undefined
@@ -4619,6 +4619,22 @@ const iterateEagerImpl = <S, A, X, E, R, E2>(options: {
     let interrupted = false
     let terminal: Exit.Exit<void, E | E2> | void
     let effect: Effect.Effect<X, E, R> | undefined
+    let nextIndex = index
+    const exits: Array<Exit.Exit<X, E> | undefined> | undefined = orderedStep ? new Array(end) : undefined
+
+    const runStep = (item: A, exit: Exit.Exit<X, E>, currentIndex: number): Exit.Exit<void, E | E2> | void => {
+      if (!orderedStep) return step(state, item, exit, currentIndex)
+      if (terminal) return terminal
+      exits![currentIndex] = exit
+      while (nextIndex < end) {
+        const nextExit = exits![nextIndex]
+        if (nextExit === undefined) return
+        exits![nextIndex] = undefined
+        const index = nextIndex++
+        const result = step(state, items[index], nextExit, index)
+        if (result) return result
+      }
+    }
 
     const go = (): Effect.Effect<void, E | E2, R> | undefined => {
       let paused = false
@@ -4628,13 +4644,13 @@ const iterateEagerImpl = <S, A, X, E, R, E2>(options: {
 
         // fast case (already an exit)
         if (effectIsExit(eff)) {
-          terminal = step(state, item, eff, index)
+          terminal = runStep(item, eff, index)
           if (terminal) break
 
           // Use flatMap for concurrency of 1
         } else if (concurrency === 1) {
           return flatMap(exit(eff), (exit) => {
-            terminal = step(state, item, exit, index)
+            terminal = runStep(item, exit, index)
             index++
             return terminal ?? go() ?? void_
           })
@@ -4661,7 +4677,7 @@ const iterateEagerImpl = <S, A, X, E, R, E2>(options: {
 
           const fiber = forkUnsafe(parentFiber, eff, true, true, "inherit")
           if (fiber._exit) {
-            terminal = step(state, item, fiber._exit, index)
+            terminal = runStep(item, fiber._exit, index)
             if (terminal) break
             continue
           }
@@ -4685,7 +4701,7 @@ const iterateEagerImpl = <S, A, X, E, R, E2>(options: {
                 }
               }
             } else {
-              const result = step(state, item, exit, currentIndex)
+              const result = runStep(item, exit, currentIndex)
               if (result) {
                 terminal = result._tag === "Failure"
                   ? exitFailCause(causeFromReasons(result.cause.reasons.slice()))
@@ -4741,11 +4757,7 @@ export const iterateEager = <S, A>(): <X, E, R, E2>(options: {
 }) => (
   initialState: S,
   items: ReadonlyArray<A>,
-  options?: {
-    readonly concurrency?: number | undefined
-    readonly start?: number | undefined
-    readonly end?: number | undefined
-  }
+  options?: IterateEagerOptions
 ) => Effect.Effect<void, E | E2, R> | undefined => iterateEagerImpl
 
 const forEachConcurrent = iterateEagerImpl({
@@ -5835,11 +5847,16 @@ class ClockImpl implements Clock.Clock {
   }
   readonly currentTimeNanos: Effect.Effect<bigint> = sync(() => this.currentTimeNanosUnsafe())
   sleep(duration: Duration.Duration): Effect.Effect<void> {
-    const millis = Duration.toMillis(duration)
+    return this.sleepMillis(Duration.toMillis(duration))
+  }
+  private sleepMillis(millis: number): Effect.Effect<void> {
     if (millis <= 0) return yieldNow
+    else if (!Number.isFinite(millis)) return never
     return callback((resume) => {
-      if (millis > MAX_TIMER_MILLIS) return
-      const handle = setTimeout(() => resume(void_), millis)
+      const continuation = millis > MAX_TIMER_MILLIS
+        ? this.sleepMillis(millis - MAX_TIMER_MILLIS)
+        : void_
+      const handle = setTimeout(() => resume(continuation), Math.min(millis, MAX_TIMER_MILLIS))
       return sync(() => clearTimeout(handle))
     })
   }

package/src/internal/schema/equivalence.ts

@@ -78,8 +78,7 @@ function recur(ast: SchemaAST.AST, path: ReadonlyArray<PropertyKey>): Equivalenc
           // handle post rest elements
           // ---------------------------------------------
           for (let j = 0; j < tail.length; j++) {
-            i += j
-            if (!tail[j](a[i], b[i])) {
+            if (!tail[j](a[i + j], b[i + j])) {
               return false
             }
           }

package/src/internal/schema/representation.ts

@@ -95,12 +95,12 @@ export function fromASTs(asts: readonly [SchemaAST.AST, ...Array<SchemaAST.AST>]
     return out
   }
 
-  function getEncodedSchema(last: SchemaAST.Declaration): SchemaAST.AST {
+  function getEncodedSchema(last: SchemaAST.Declaration): SchemaAST.Declaration | SchemaAST.Null {
     const getLink = last.annotations?.toCodecJson ?? last.annotations?.toCodec
     if (Predicate.isFunction(getLink)) {
-      const tps = last.typeParameters.map((tp) => InternalSchema.make(SchemaAST.toEncoded(tp)))
-      const link = getLink(tps)
-      return SchemaAST.replaceEncoding(last, [link])
+      return SchemaAST.replaceEncoding(last, [
+        getLink(last.typeParameters.map((tp) => InternalSchema.make(SchemaAST.toEncoded(tp))))
+      ])
     }
     return SchemaAST.null
   }

package/src/internal/schema/schema.ts

@@ -1,10 +1,9 @@
 import * as Cause from "../../Cause.ts"
-import * as Data from "../../Data.ts"
 import * as Effect from "../../Effect.ts"
-import * as Exit from "../../Exit.ts"
 import * as Pipeable from "../../Pipeable.ts"
 import type * as Schema from "../../Schema.ts"
 import * as SchemaAST from "../../SchemaAST.ts"
+import { SchemaError } from "../../SchemaError.ts"
 import type { Issue } from "../../SchemaIssue.ts"
 import * as SchemaParser from "../../SchemaParser.ts"
 
@@ -35,34 +34,16 @@ export function make<S extends Schema.Constraint>(ast: S["ast"], options?: objec
   }
   self.ast = ast
   self.rebuild = (ast: SchemaAST.AST) => make(ast, options)
+  const makeEffect = SchemaParser.makeEffect(self)
   self.makeEffect = (input: S["~type.make.in"], options?: Schema.MakeOptions) =>
-    mapSchemaIssueEffect(SchemaParser.makeEffect(self)(input, options))
+    fromIssueEffect(makeEffect(input, options))
   self.make = SchemaParser.make(self)
   self.makeOption = SchemaParser.makeOption(self)
   return self
 }
 
 /** @internal */
-export const SchemaErrorTypeId = "~effect/Schema/SchemaError"
-
-// purposefully not internal
-export class SchemaError extends Data.TaggedError("SchemaError")<{
-  readonly issue: Issue
-}> {
-  readonly [SchemaErrorTypeId]: typeof SchemaErrorTypeId = SchemaErrorTypeId
-  constructor(issue: Issue) {
-    super({ issue })
-  }
-  override get message() {
-    return this.issue.toString()
-  }
-  override toString() {
-    return `SchemaError(${this.message})`
-  }
-}
-
-/** @internal */
-export function mapSchemaIssueEffect<A, R>(
+export function fromIssueEffect<A, R>(
   self: Effect.Effect<A, Issue, R>
 ): Effect.Effect<A, SchemaError, R> {
   return Effect.catchCause(
@@ -71,20 +52,6 @@ export function mapSchemaIssueEffect<A, R>(
   )
 }
 
-/** @internal */
-export function mapSchemaErrorEffect<A, R>(
-  self: Effect.Effect<A, SchemaError, R>
-): Effect.Effect<A, Issue, R> {
-  return Effect.catchCause(self, (cause) => Effect.failCauseSync(() => Cause.map(cause, (error) => error.issue)))
-}
-
-/** @internal */
-export function mapSchemaIssueExit<A>(exit: Exit.Exit<A, Issue>): Exit.Exit<A, SchemaError> {
-  return Exit.isSuccess(exit)
-    ? Exit.succeed(exit.value)
-    : Exit.failCause(Cause.map(exit.cause, (issue) => new SchemaError(issue)))
-}
-
 /** @internal */
 export const jsonReorder = makeReorder(getJsonPriority)
 

package/src/unstable/cli/CliError.ts

@@ -127,8 +127,9 @@ export type CliError =
  * @category models
  * @since 4.0.0
  */
-export class UnrecognizedOption extends Schema.ErrorClass<UnrecognizedOption>(`${TypeId}/UnrecognizedOption`)({
-  _tag: Schema.tag("UnrecognizedOption"),
+export class UnrecognizedOption extends Schema.TaggedErrorClass<UnrecognizedOption>(
+  `${TypeId}/UnrecognizedOption`
+)("UnrecognizedOption", {
   option: Schema.String,
   command: Schema.optional(Schema.Array(Schema.String)),
   suggestions: Schema.Array(Schema.String)
@@ -178,8 +179,9 @@ export class UnrecognizedOption extends Schema.ErrorClass<UnrecognizedOption>(`$
  * @category models
  * @since 4.0.0
  */
-export class DuplicateOption extends Schema.ErrorClass<DuplicateOption>(`${TypeId}/DuplicateOption`)({
-  _tag: Schema.tag("DuplicateOption"),
+export class DuplicateOption extends Schema.TaggedErrorClass<DuplicateOption>(
+  `${TypeId}/DuplicateOption`
+)("DuplicateOption", {
   option: Schema.String,
   parentCommand: Schema.String,
   childCommand: Schema.String
@@ -232,8 +234,9 @@ export class DuplicateOption extends Schema.ErrorClass<DuplicateOption>(`${TypeI
  * @category models
  * @since 4.0.0
  */
-export class MissingOption extends Schema.ErrorClass<MissingOption>(`${TypeId}/MissingOption`)({
-  _tag: Schema.tag("MissingOption"),
+export class MissingOption extends Schema.TaggedErrorClass<MissingOption>(
+  `${TypeId}/MissingOption`
+)("MissingOption", {
   option: Schema.String
 }) {
   /**
@@ -282,8 +285,9 @@ export class MissingOption extends Schema.ErrorClass<MissingOption>(`${TypeId}/M
  * @category models
  * @since 4.0.0
  */
-export class MissingArgument extends Schema.ErrorClass<MissingArgument>(`${TypeId}/MissingArgument`)({
-  _tag: Schema.tag("MissingArgument"),
+export class MissingArgument extends Schema.TaggedErrorClass<MissingArgument>(
+  `${TypeId}/MissingArgument`
+)("MissingArgument", {
   argument: Schema.String
 }) {
   /**
@@ -337,8 +341,9 @@ export class MissingArgument extends Schema.ErrorClass<MissingArgument>(`${TypeI
  * @category models
  * @since 4.0.0
  */
-export class InvalidValue extends Schema.ErrorClass<InvalidValue>(`${TypeId}/InvalidValue`)({
-  _tag: Schema.tag("InvalidValue"),
+export class InvalidValue extends Schema.TaggedErrorClass<InvalidValue>(
+  `${TypeId}/InvalidValue`
+)("InvalidValue", {
   option: Schema.String,
   value: Schema.String,
   expected: Schema.String,
@@ -400,8 +405,9 @@ export class InvalidValue extends Schema.ErrorClass<InvalidValue>(`${TypeId}/Inv
  * @category models
  * @since 4.0.0
  */
-export class UnknownSubcommand extends Schema.ErrorClass<UnknownSubcommand>(`${TypeId}/UnknownSubcommand`)({
-  _tag: Schema.tag("UnknownSubcommand"),
+export class UnknownSubcommand extends Schema.TaggedErrorClass<UnknownSubcommand>(
+  `${TypeId}/UnknownSubcommand`
+)("UnknownSubcomand", {
   subcommand: Schema.String,
   parent: Schema.optional(Schema.Array(Schema.String)),
   suggestions: Schema.Array(Schema.String)
@@ -464,8 +470,9 @@ export class UnknownSubcommand extends Schema.ErrorClass<UnknownSubcommand>(`${T
  * @category models
  * @since 4.0.0
  */
-export class UserError extends Schema.ErrorClass<UserError>(`${TypeId}/UserError`)({
-  _tag: Schema.tag("UserError"),
+export class UserError extends Schema.TaggedErrorClass<UserError>(
+  `${TypeId}/UserError`
+)("UserError", {
   cause: Schema.Defect()
 }) {
   /**
@@ -533,8 +540,9 @@ export type NonShowHelpErrors = typeof NonShowHelpErrors.Type
  * @category models
  * @since 4.0.0
  */
-export class ShowHelp extends Schema.ErrorClass<ShowHelp>(`${TypeId}/ShowHelp`)({
-  _tag: Schema.tag("ShowHelp"),
+export class ShowHelp extends Schema.TaggedErrorClass<ShowHelp>(
+  `${TypeId}/ShowHelp`
+)("ShowHelp", {
   commandPath: Schema.Array(Schema.String),
   errors: Schema.Array(NonShowHelpErrors)
 }) {

package/src/unstable/cli/Command.ts

@@ -697,7 +697,7 @@ export const make: {
     name: Name,
     config: Config,
     handler: (config: Command.Config.Infer<Config>) => Effect.Effect<void, E, R>
-  ): Command<Name, Command.Config.Infer<Config>, {}, E, Exclude<R, GlobalFlag.BuiltInSettingContext>>
+  ): Command<Name, Command.Config.Infer<Config>, {}, E, Exclude<R, BuiltInSettingContext>>
 } = ((
   name: string,
   config?: Command.Config,
@@ -772,7 +772,7 @@ export const withHandler: {
    */
   <A, R, E>(handler: (value: A) => Effect.Effect<void, E, R>): <Name extends string, XR, XE, ContextInput>(
     self: Command<Name, A, ContextInput, XE, XR>
-  ) => Command<Name, A, ContextInput, E, Exclude<R, GlobalFlag.BuiltInSettingContext>>
+  ) => Command<Name, A, ContextInput, E, Exclude<R, BuiltInSettingContext>>
   /* ========================================================================== */
   /* Combinators                                                                */
   /* ========================================================================== */
@@ -805,11 +805,11 @@ export const withHandler: {
   <Name extends string, A, XR, XE, R, E, ContextInput>(
     self: Command<Name, A, ContextInput, XE, XR>,
     handler: (value: A) => Effect.Effect<void, E, R>
-  ): Command<Name, A, ContextInput, E, Exclude<R, GlobalFlag.BuiltInSettingContext>>
+  ): Command<Name, A, ContextInput, E, Exclude<R, BuiltInSettingContext>>
 } = dual(2, <Name extends string, A, XR, XE, R, E, ContextInput>(
   self: Command<Name, A, ContextInput, XE, XR>,
   handler: (value: A) => Effect.Effect<void, E, R>
-): Command<Name, A, ContextInput, E, Exclude<R, GlobalFlag.BuiltInSettingContext>> =>
+): Command<Name, A, ContextInput, E, Exclude<R, BuiltInSettingContext>> =>
   makeCommand({ ...toImpl(self), handle: handler } as any))
 
 interface SubcommandGroupInternal {
@@ -1272,6 +1272,7 @@ type ExtractGlobalFlagContext<T extends ReadonlyArray<GlobalFlag.GlobalFlag<any>
   ? F extends GlobalFlag.Setting<infer Id, infer _A> ? GlobalFlag.Setting.Identifier<Id>
   : never
   : never
+type BuiltInSettingContext = ExtractGlobalFlagContext<typeof GlobalFlag.BuiltIns>
 type ExtractSubcommand<T> = T extends Command<infer _Name, infer _Input, infer _CI, infer _E, infer _R> ? T
   : T extends Command.SubcommandGroup<infer Commands> ? Commands[number]
   : never
@@ -2352,15 +2353,14 @@ export const runWith = <const Name extends string, Input, E, R, ContextInput>(
 
       // 7. Provide setting values
       let program = commandImpl.handle(parseResult.success, [command.name])
+      const [, logLevel] = yield* GlobalFlag.LogLevel.flag.parse(emptyArgs)
+      program = Effect.provideService(program, GlobalFlag.LogLevel, logLevel)
       for (const flag of activeFlags) {
-        if (flag._tag !== "Setting") continue
+        if (flag._tag !== "Setting" || flag === GlobalFlag.LogLevel) continue
         const [, value] = yield* flag.flag.parse(emptyArgs)
         program = Effect.provideService(program, flag, value)
       }
 
-      const [, logLevel] = yield* GlobalFlag.LogLevel.flag.parse(emptyArgs)
-      program = Effect.provideService(program, GlobalFlag.LogLevel, logLevel)
-
       // 8. Apply built-in setting behavior
       const services = Option.match(logLevel, {
         onNone: () => Context.empty(),

package/src/unstable/cli/GlobalFlag.ts

@@ -156,12 +156,11 @@ export const Help: Action<boolean> = action({
     Flag.withAlias("h"),
     Flag.withDescription("Show help information")
   ),
-  run: (_, { command, commandPath }) =>
-    Effect.gen(function*() {
-      const formatter = yield* CliOutput.Formatter
-      const helpDoc = yield* HelpInternal.getHelpForCommandPath(command, commandPath, BuiltIns)
-      yield* Console.log(formatter.formatHelpDoc(helpDoc))
-    })
+  run: Effect.fnUntraced(function*(_, { command, commandPath }) {
+    const formatter = yield* CliOutput.Formatter
+    const helpDoc = yield* HelpInternal.getHelpForCommandPath(command, commandPath, BuiltIns)
+    yield* Console.log(formatter.formatHelpDoc(helpDoc))
+  })
 })
 
 /**
@@ -179,11 +178,10 @@ export const Version: Action<boolean> = action({
     Flag.withAlias("v"),
     Flag.withDescription("Show version information")
   ),
-  run: (_, { command, version }) =>
-    Effect.gen(function*() {
-      const formatter = yield* CliOutput.Formatter
-      yield* Console.log(formatter.formatVersion(command.name, version))
-    })
+  run: Effect.fnUntraced(function*(_, { command, version }) {
+    const formatter = yield* CliOutput.Formatter
+    yield* Console.log(formatter.formatVersion(command.name, version))
+  })
 })
 
 /**
@@ -206,14 +204,13 @@ export const Completions: Action<Option.Option<"bash" | "zsh" | "fish">> = actio
       Flag.withMetavar("<bash|zsh|fish|sh>"),
       Flag.withDescription("Print shell completion script")
     ),
-  run: (shell, { command }) =>
-    Effect.gen(function*() {
-      if (Option.isNone(shell)) return
-      const descriptor = CommandDescriptor.fromCommand(command)
-      yield* Console.log(
-        Completions_.generate(command.name, shell.value, descriptor)
-      )
-    })
+  run: Effect.fnUntraced(function*(shell, { command }) {
+    if (Option.isNone(shell)) return
+    const descriptor = CommandDescriptor.fromCommand(command)
+    yield* Console.log(
+      Completions_.generate(command.name, shell.value, descriptor)
+    )
+  })
 })
 
 /**
@@ -279,17 +276,9 @@ export const LogLevel: Setting<"log-level", Option.Option<LogLevelType>> = setti
  * @category references
  * @since 4.0.0
  */
-export const BuiltIns: ReadonlyArray<GlobalFlag<any>> = [
-  Help,
-  Version,
-  Completions,
-  LogLevel
-]
-
-/**
- * Built-in setting context identifiers.
- *
- * @category models
- * @since 4.0.0
- */
-export type BuiltInSettingContext = Setting.Identifier<"log-level">
+export const BuiltIns: readonly [
+  Action<boolean>,
+  Action<boolean>,
+  Action<Option.Option<"bash" | "zsh" | "fish">>,
+  Setting<"log-level", Option.Option<LogLevelType>>
+] = [Help, Version, Completions, LogLevel]

package/src/unstable/cluster/ClusterCron.ts

@@ -147,9 +147,10 @@ export const make = <E, R>(options: {
   return Layer.merge(InitialRun, EntityLayer)
 }
 
-const retryPolicy = Schedule.exponential(200, 1.5).pipe(
-  Schedule.either(Schedule.spaced("1 minute"))
-)
+const retryPolicy = Schedule.min([
+  Schedule.exponential(200, 1.5),
+  Schedule.spaced("1 minute")
+])
 
 class CronPayload extends Schema.Class<CronPayload>("effect/cluster/ClusterCron/CronPayload")({
   dateTime: Schema.DateTimeUtc

package/src/unstable/cluster/ClusterWorkflowEngine.ts

@@ -626,9 +626,10 @@ export const make = Effect.gen(function*() {
   return engine
 })
 
-const retryPolicy = Schedule.exponential(200, 1.5).pipe(
-  Schedule.either(Schedule.spaced("1 minute"))
-)
+const retryPolicy = Schedule.min([
+  Schedule.exponential(200, 1.5),
+  Schedule.spaced("1 minute")
+])
 
 const ensureSuccess = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
   effect.pipe(

package/src/unstable/cluster/EntityProxyServer.ts

@@ -34,27 +34,25 @@ import type { Sharding } from "./Sharding.ts"
  */
 export const layerHttpApi = <
   ApiId extends string,
-  Groups extends HttpApiGroup.Any,
-  Name extends HttpApiGroup.Name<Groups>,
+  Groups extends HttpApiGroup.Constraint,
+  Identifier extends HttpApiGroup.Identifier<Groups>,
   Type extends string,
   Rpcs extends Rpc.Any
 >(
   api: HttpApi.HttpApi<ApiId, Groups>,
-  name: Name,
+  identifier: Identifier,
   entity: Entity.Entity<Type, Rpcs>
-): Layer.Layer<HttpApiGroup.ApiGroup<ApiId, Name>, never, Sharding | Rpc.ServicesServer<Rpcs>> =>
+): Layer.Layer<HttpApiGroup.Service<ApiId, Identifier>, never, Sharding | Rpc.ServicesServer<Rpcs>> =>
   HttpApiBuilder.group(
     api,
-    name,
-    Effect.fnUntraced(function*(handlers_) {
+    identifier,
+    Effect.fnUntraced(function*(handlers: any) {
       const client = yield* entity.client
-      let handlers = handlers_
-      for (const parentRpc_ of entity.protocol.requests.values()) {
-        const parentRpc = parentRpc_ as any as Rpc.AnyWithProps
+      for (const parentRpc of entity.protocol.requests.values()) {
         handlers = handlers
           .handle(
-            parentRpc._tag as any,
-            (({ params, payload }: { params: { entityId: string }; payload: any }) =>
+            parentRpc._tag,
+            ({ params, payload }: { params: { entityId: string }; payload: any }) =>
               (client(params.entityId) as any as Record<string, (p: any) => Effect.Effect<any>>)[parentRpc._tag](
                 payload
               ).pipe(
@@ -65,11 +63,11 @@ export const layerHttpApi = <
                   entityId: params.entityId,
                   method: parentRpc._tag
                 })
-              )) as any
+              )
           )
           .handle(
-            `${parentRpc._tag}Discard` as any,
-            (({ params, payload }: { params: { entityId: string }; payload: any }) =>
+            `${parentRpc._tag}Discard`,
+            ({ params, payload }: { params: { entityId: string }; payload: any }) =>
               (client(params.entityId) as any as Record<string, (p: any, o: {}) => Effect.Effect<any>>)[parentRpc._tag](
                 payload,
                 { discard: true }
@@ -81,10 +79,10 @@ export const layerHttpApi = <
                   entityId: params.entityId,
                   method: `${parentRpc._tag}Discard`
                 })
-              )) as any
-          ) as any
+              )
+          )
       }
-      return handlers as HttpApiBuilder.Handlers<never, never>
+      return handlers as HttpApiBuilder.Handlers<never>
     })
   )
 

package/src/unstable/cluster/Sharding.ts

@@ -38,7 +38,7 @@ import * as Semaphore from "../../Semaphore.ts"
 import * as Stream from "../../Stream.ts"
 import type * as Rpc from "../rpc/Rpc.ts"
 import * as RpcClient from "../rpc/RpcClient.ts"
-import { type FromServer, RequestId } from "../rpc/RpcMessage.ts"
+import type { FromServer } from "../rpc/RpcMessage.ts"
 import type { MailboxFull, PersistenceError } from "./ClusterError.ts"
 import { AlreadyProcessingMessage, EntityNotAssignedToRunner } from "./ClusterError.ts"
 import * as ClusterMetrics from "./ClusterMetrics.ts"
@@ -1040,7 +1040,7 @@ const make = Effect.gen(function*() {
         spanPrefix: `${entity.type}.client`,
         disableTracing: !Context.get(entity.protocol.annotations, ClusterSchema.ClientTracingEnabled),
         supportsAck: true,
-        generateRequestId: () => RequestId(snowflakeGen.nextUnsafe()),
+        generateRequestId: () => snowflakeGen.nextUnsafe() as any,
         flatten: true,
         onFromClient(options): Effect.Effect<
           void,
@@ -1199,7 +1199,7 @@ const make = Effect.gen(function*() {
         return write({
           _tag: "Chunk",
           clientId: 0,
-          requestId: RequestId(reply.requestId),
+          requestId: reply.requestId as any,
           values: reply.values
         })
       }
@@ -1208,7 +1208,7 @@ const make = Effect.gen(function*() {
         return write({
           _tag: "Exit",
           clientId: 0,
-          requestId: RequestId(reply.requestId),
+          requestId: reply.requestId as any,
           exit: reply.exit
         })
       }

package/src/unstable/cluster/Snowflake.ts

@@ -53,8 +53,8 @@ export type Snowflake = Brand.Branded<bigint, TypeId>
  * @category constructors
  * @since 4.0.0
  */
-export const Snowflake = (input: string | bigint): Snowflake =>
-  typeof input === "string" ? BigInt(input) as Snowflake : input as Snowflake
+export const Snowflake = (input: string | number | bigint): Snowflake =>
+  typeof input === "bigint" ? input as Snowflake : BigInt(input) as Snowflake
 
 /**
  * Namespace containing support types for snowflake parts and generators.