effect-app 4.0.0-beta.26 → 4.0.0-beta.261

package/src/toast.ts

@@ -0,0 +1,54 @@
+import * as Context from "./Context.js"
+import { accessEffectFn } from "./Context.js"
+import * as Effect from "./Effect.js"
+import * as Option from "./Option.js"
+
+export type ToastId = string | number
+export type ToastOpts = { id?: ToastId; timeout?: number; groupId?: string; requestId?: string }
+export type ToastOptsInternal = { id?: ToastId | null; timeout?: number; groupId?: string; requestId?: string }
+
+export type UseToast = () => {
+  error: (this: void, message: string, options?: ToastOpts) => ToastId
+  warning: (this: void, message: string, options?: ToastOpts) => ToastId
+  success: (this: void, message: string, options?: ToastOpts) => ToastId
+  info: (this: void, message: string, options?: ToastOpts) => ToastId
+  dismiss: (this: void, id: ToastId) => void
+}
+
+export class CurrentToastId extends Context.Opaque<CurrentToastId, { toastId: ToastId }>()("CurrentToastId") {}
+
+/** fallback to CurrentToastId when available unless id is explicitly set to a value or null */
+export const wrap = (toast: ReturnType<UseToast>) => {
+  const wrap = (toastHandler: (message: string, options?: ToastOpts) => ToastId) => {
+    return (message: string, options?: ToastOptsInternal) =>
+      Effect.serviceOption(CurrentToastId).pipe(
+        Effect.flatMap((currentToast) =>
+          Effect.sync(() => {
+            const { id: _id, ...rest } = options ?? {}
+            const id = _id !== undefined
+              ? _id ?? undefined
+              : Option.getOrUndefined(Option.map(currentToast, (_) => _.toastId))
+            // when id is undefined, we may end up with no toast at all..
+            return toastHandler(message, id !== undefined ? { ...rest, id } : rest)
+          })
+        )
+      )
+  }
+  return {
+    error: wrap(toast.error),
+    info: wrap(toast.info),
+    success: wrap(toast.success),
+    warning: wrap(toast.warning),
+    dismiss: (toastId: ToastId) => Effect.sync(() => toast.dismiss(toastId))
+  }
+}
+
+type ToastShape = ReturnType<typeof wrap>
+
+export class Toast extends Context.Opaque<Toast, ToastShape>()("Toast") {
+  static readonly error = accessEffectFn(this, "error")
+  static readonly info = accessEffectFn(this, "info")
+  static readonly success = accessEffectFn(this, "success")
+  static readonly warning = accessEffectFn(this, "warning")
+  static readonly dismiss = accessEffectFn(this, "dismiss")
+}

package/src/transform.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Option } from "effect"
 import type { NonEmptyReadonlyArray } from "effect/Array"
+import * as Option from "effect/Option"
 import type { Misc, Union } from "ts-toolbelt"
 import type * as SET from "./Set.js"
 
@@ -51,8 +51,8 @@ const encodeOptsAsNullable_ = (value: any, cacheMap: Map<any, any>): any => {
 
   if (
     value instanceof Date
-    || value instanceof Function
-    || value instanceof Promise
+    || typeof value === "function"
+    || (typeof value === "object" && value !== null && "then" in value && typeof value.then === "function")
   ) {
     return value
   }

package/src/utils/effectify.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 
-import { Effect } from "effect"
+import * as Effect from "effect/Effect"
 
 interface Callback<E, A> {
   (err: E, a?: A): void

package/src/utils/gen.ts

@@ -1,24 +1,24 @@
-import { type Effect, type Yieldable } from "effect/Effect"
+import { type Effect } from "effect/Effect"
 
 export namespace EffectGenUtils {
   export type Success<EG> = EG extends Effect<infer A, infer _E, infer _R> ? A
     // there could be a case where the generator function does not yield anything, so we need to handle that
     : EG extends (..._: infer _3) => Generator<never, infer A, infer _2> ? A
-    // v4: generators can yield Yieldable (Effect, Service, etc.), all have asEffect()
-    : EG extends (..._: infer _3) => Generator<Yieldable<any, infer _, infer _E, infer _R>, infer A, infer _2> ? A
+    // generators yield Effect values
+    : EG extends (..._: infer _3) => Generator<Effect<any, infer _E, infer _R>, infer A, infer _2> ? A
     : never
 
   export type Error<EG> = EG extends Effect<infer _A, infer E, infer _R> ? E
     // there could be a case where the generator function does not yield anything, so we need to handle that
     : EG extends (..._: infer _3) => Generator<never, infer _A, infer _2> ? never
-    // v4: generators can yield Yieldable (Effect, Service, etc.), all have asEffect()
-    : EG extends (..._: infer _3) => Generator<Yieldable<any, infer _, infer E, infer _R>, infer _A, infer _2> ? E
+    // generators yield Effect values
+    : EG extends (..._: infer _3) => Generator<Effect<any, infer E, infer _R>, infer _A, infer _2> ? E
     : never
 
-  export type ServiceMap<EG> = EG extends Effect<infer _A, infer _E, infer R> ? R
+  export type Context<EG> = EG extends Effect<infer _A, infer _E, infer R> ? R
     // there could be a case where the generator function does not yield anything, so we need to handle that
     : EG extends (..._: infer _3) => Generator<never, infer _A, infer _2> ? never
-    // v4: generators can yield Yieldable (Effect, Service, etc.), all have asEffect()
-    : EG extends (..._: infer _3) => Generator<Yieldable<any, infer _, infer _E, infer R>, infer _A, infer _2> ? R
+    // generators yield Effect values
+    : EG extends (..._: infer _3) => Generator<Effect<any, infer _E, infer R>, infer _A, infer _2> ? R
     : never
 }

package/src/utils/logLevel.ts

@@ -1,4 +1,4 @@
-import { type LogLevel } from "effect"
+import type * as LogLevel from "effect/LogLevel"
 
 export const LogLevelToSentry = (level: LogLevel.LogLevel) => {
   switch (level) {

package/src/utils/logger.ts

@@ -1,12 +1,13 @@
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { Effect, type LogLevel } from "effect"
-import * as ServiceMap from "../ServiceMap.js"
+import * as Effect from "effect/Effect"
+import type * as LogLevel from "effect/LogLevel"
+import * as Context from "../Context.js"
 
 type Levels = "info" | "debug" | "warn" | "error"
 
-export class LogLevels extends ServiceMap.Reference("LogLevels", {
+export class LogLevels extends Context.Reference("LogLevels", {
   defaultValue: () => new Map<string, Levels>()
 }) {}
 

package/src/utils.ts

@@ -1,20 +1,24 @@
 /* eslint-disable @typescript-eslint/no-unsafe-function-type */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-redundant-type-constituents */
-import { Cause, Effect, Exit, Fiber, Option, Record } from "effect"
+import * as Cause from "effect/Cause"
+import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
+import * as Fiber from "effect/Fiber"
 import { dual } from "effect/Function"
-import { isFunction, isObject } from "effect/Predicate"
+import * as Option from "effect/Option"
+import { isFunction } from "effect/Predicate"
+import * as Record from "effect/Record"
 import * as Result from "effect/Result"
-import type { GetFieldType, NumericDictionary, PropertyPath } from "lodash"
 import { identity, pipe } from "./Function.js"
 import type { DeepMutable, Equals, Mutable } from "./Types.js"
 
 // codegen:start {preset: barrel, include: ./utils/*.ts, nodir: false }
-export * from "./utils/effectify.js"
-export * from "./utils/extend.js"
-export * from "./utils/gen.js"
-export * from "./utils/logger.js"
-export * from "./utils/logLevel.js"
+export * from "./utils/effectify.ts"
+export * from "./utils/extend.ts"
+export * from "./utils/gen.ts"
+export * from "./utils/logger.ts"
+export * from "./utils/logLevel.ts"
 // codegen:end
 
 export * from "effect/Utils"
@@ -24,121 +28,6 @@ export interface Clone {
   [cloneTrait](this: this, that: any): this
 }
 
-function get<TObject extends object, TKey extends keyof TObject>(object: TObject, path: TKey | [TKey]): TObject[TKey]
-function get<TObject extends object, TKey extends keyof TObject>(
-  object: TObject | null | undefined,
-  path: TKey | [TKey]
-): TObject[TKey] | undefined
-function get<TObject extends object, TKey extends keyof TObject, TDefault>(
-  object: TObject | null | undefined,
-  path: TKey | [TKey],
-  defaultValue: TDefault
-): Exclude<TObject[TKey], undefined> | TDefault
-function get<TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(
-  object: TObject,
-  path: [TKey1, TKey2]
-): TObject[TKey1][TKey2]
-function get<TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(
-  object: TObject | null | undefined,
-  path: [TKey1, TKey2]
-): TObject[TKey1][TKey2] | undefined
-function get<TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TDefault>(
-  object: TObject | null | undefined,
-  path: [TKey1, TKey2],
-  defaultValue: TDefault
-): Exclude<TObject[TKey1][TKey2], undefined> | TDefault
-function get<
-  TObject extends object,
-  TKey1 extends keyof TObject,
-  TKey2 extends keyof TObject[TKey1],
-  TKey3 extends keyof TObject[TKey1][TKey2]
->(object: TObject, path: [TKey1, TKey2, TKey3]): TObject[TKey1][TKey2][TKey3]
-function get<
-  TObject extends object,
-  TKey1 extends keyof TObject,
-  TKey2 extends keyof TObject[TKey1],
-  TKey3 extends keyof TObject[TKey1][TKey2]
->(object: TObject | null | undefined, path: [TKey1, TKey2, TKey3]): TObject[TKey1][TKey2][TKey3] | undefined
-function get<
-  TObject extends object,
-  TKey1 extends keyof TObject,
-  TKey2 extends keyof TObject[TKey1],
-  TKey3 extends keyof TObject[TKey1][TKey2],
-  TDefault
->(
-  object: TObject | null | undefined,
-  path: [TKey1, TKey2, TKey3],
-  defaultValue: TDefault
-): Exclude<TObject[TKey1][TKey2][TKey3], undefined> | TDefault
-function get<
-  TObject extends object,
-  TKey1 extends keyof TObject,
-  TKey2 extends keyof TObject[TKey1],
-  TKey3 extends keyof TObject[TKey1][TKey2],
-  TKey4 extends keyof TObject[TKey1][TKey2][TKey3]
->(object: TObject, path: [TKey1, TKey2, TKey3, TKey4]): TObject[TKey1][TKey2][TKey3][TKey4]
-function get<
-  TObject extends object,
-  TKey1 extends keyof TObject,
-  TKey2 extends keyof TObject[TKey1],
-  TKey3 extends keyof TObject[TKey1][TKey2],
-  TKey4 extends keyof TObject[TKey1][TKey2][TKey3]
->(
-  object: TObject | null | undefined,
-  path: [TKey1, TKey2, TKey3, TKey4]
-): TObject[TKey1][TKey2][TKey3][TKey4] | undefined
-function get<
-  TObject extends object,
-  TKey1 extends keyof TObject,
-  TKey2 extends keyof TObject[TKey1],
-  TKey3 extends keyof TObject[TKey1][TKey2],
-  TKey4 extends keyof TObject[TKey1][TKey2][TKey3],
-  TDefault
->(
-  object: TObject | null | undefined,
-  path: [TKey1, TKey2, TKey3, TKey4],
-  defaultValue: TDefault
-): Exclude<TObject[TKey1][TKey2][TKey3][TKey4], undefined> | TDefault
-function get<T>(object: NumericDictionary<T>, path: number): T
-function get<T>(object: NumericDictionary<T> | null | undefined, path: number): T | undefined
-function get<T, TDefault>(
-  object: NumericDictionary<T> | null | undefined,
-  path: number,
-  defaultValue: TDefault
-): T | TDefault
-function get<TDefault>(object: null | undefined, path: PropertyPath, defaultValue: TDefault): TDefault
-function get(object: null | undefined, path: PropertyPath): undefined
-function get<TObject, TPath extends string>(
-  data: TObject,
-  path: TPath
-): string extends TPath ? any : GetFieldType<TObject, TPath>
-function get<TObject, TPath extends string, TDefault = GetFieldType<TObject, TPath>>(
-  data: TObject,
-  path: TPath,
-  defaultValue: TDefault
-): Exclude<GetFieldType<TObject, TPath>, null | undefined> | TDefault
-function get(object: any, path: PropertyPath, defaultValue?: any): any
-function get(obj: any, path: any, defaultValue = undefined) {
-  // https://github.com/you-dont-need/You-Dont-Need-Lodash-Underscore?tab=readme-ov-file#_get
-  const travel = (regexp: any) =>
-    String
-      .prototype
-      .split
-      .call(path, regexp)
-      .filter(Boolean)
-      .reduce((res, key) => (res !== null && res !== undefined ? res[key] : res), obj)
-  const result = travel(/[,[\]]+?/) || travel(/[,[\].]+?/)
-  return result === undefined || result === obj ? defaultValue : result
-}
-
-// codegen:start {preset: barrel, include: ./utils/*.ts }
-export * from "./utils/effectify.js"
-export * from "./utils/extend.js"
-export * from "./utils/gen.js"
-export * from "./utils/logger.js"
-export * from "./utils/logLevel.js"
-// codegen:end
-
 export const unsafeRight = <E, A>(ei: Result.Result<A, E>) => {
   if (Result.isFailure(ei)) {
     console.error(ei.failure)
@@ -269,7 +158,7 @@ export type EnforceNonEmptyRecord<R> = keyof R extends never ? never : R
 export function intersect<AS extends unknown[] & { 0: unknown }>(
   ...as: AS
 ): UnionToIntersection<{ [k in keyof AS]: AS[k] }[number]> {
-  return as.reduce((a: any, b: any) => ({ ...a, ...b })) as any
+  return as.reduce((a: any, b: any) => Object.assign(a, b), {}) as any
 }
 
 export type IsEqualTo<X, Y> = (<T>() => T extends X ? 1 : 2) extends <
@@ -280,8 +169,7 @@ export type IsEqualTo<X, Y> = (<T>() => T extends X ? 1 : 2) extends <
 export const unifyIndex = Symbol()
 export type unifyIndex = typeof unifyIndex
 
-// @ts-expect-error abc
-export interface UnifiableIndexed<X> {}
+export interface UnifiableIndexed<_X> {}
 export type UnifiableIndexedURI = keyof UnifiableIndexed<any>
 
 export interface Unifiable<X> {
@@ -313,9 +201,7 @@ function decorateNew(
   if (out.descriptor) {
     out.descriptor = Object.assign({}, out.descriptor)
   }
-  const actualDesc: PropertyDescriptor = <any> (
-    out.descriptor || /* istanbul ignore next */ out
-  )
+  const actualDesc: PropertyDescriptor = out.descriptor || /* istanbul ignore next */ out
 
   const originalMethod = validateAndExtractMethodFromDescriptor(actualDesc)
   const isStatic = inp.placement === "static"
@@ -684,7 +570,7 @@ export type OptPromise<T extends () => any> = (
 ) => Promise<ReturnType<T>> | ReturnType<T>
 
 export function access<T extends string, T2>(t: Record<T, T2>) {
-  return (key: T) => t[key] as T2
+  return (key: T) => t[key]
 }
 
 export function todayAtUTCNoon() {
@@ -736,25 +622,64 @@ export const copy = dual<
   }
 >(2, <A>(self: A, f: Partial<A> | ((a: A) => Partial<A>)) => clone(self, { ...self, ...(isFunction(f) ? f(self) : f) }))
 
-type CopyOriginU<U, Ctor extends new(...args: any[]) => any> =
+export type CopyOriginU<U, Ctor extends new(...args: any[]) => any> =
   & {
     [K in keyof U & keyof InstanceType<Ctor>]?: U[K]
   }
   & {}
 
-type CopyOriginRet<A, U> =
+export type CopyOriginRet<A, U> =
   & {
     [K in keyof A | keyof U]: K extends keyof U ? U[K] : A[K & keyof A]
   }
   & {}
 
-type CopyOriginSelf<A, U> = Equals<{}, U> extends true
+export type CopyOriginSelf<A, U> = Equals<{}, U> extends true
   ? Equals<keyof {}, keyof U> extends true ? `updates argument is empty or contains only extra properties`
   : A
   : A
 
+export interface StructuralCopyOrigin<Self extends object> {
+  <A extends Self, U extends Partial<Self>>(
+    f: (a: A) =>
+      & {
+        [K in keyof U & keyof Self]?: U[K]
+      }
+      & {}
+  ): (self: CopyOriginSelf<A, U>) => CopyOriginRet<A, U>
+  <A extends Self, U extends Partial<Self>>(
+    updates:
+      & {
+        [K in keyof U & keyof Self]?: U[K]
+      }
+      & {}
+  ): (self: CopyOriginSelf<A, U>) => CopyOriginRet<A, U>
+  <A extends Self, U extends Partial<Self>>(
+    self: CopyOriginSelf<A, U>,
+    f: (a: A) =>
+      & {
+        [K in keyof U & keyof Self]?: U[K]
+      }
+      & {}
+  ): CopyOriginRet<A, U>
+  <A extends Self, U extends Partial<Self>>(
+    self: CopyOriginSelf<A, U>,
+    updates:
+      & {
+        [K in keyof U & keyof Self]?: U[K]
+      }
+      & {}
+  ): CopyOriginRet<A, U>
+}
+
 // just one input param: the convention is that the ctor takes an object
-// containing the properties of the class (I can't put object there as type because of contravariance)
+// containing the properties of the value (I can't put object there as type because of contravariance)
+/**
+ * By design this does not return `Self` directly.
+ *
+ * The return type is computed from `Self` and the update payload so callers can
+ * expose an explicit structural return type that remains assignable to `Self`.
+ */
 export const copyOrigin = <Ctor extends new(_: any) => any>(ctor: Ctor) =>
   dual<
     {
@@ -883,8 +808,6 @@ export function setMoveElDropUndefined<T>(el: T, newIndex: number) {
     pipe([...arrInput], arMoveElDropUndefined(el, newIndex), Option.map((ar) => new Set(ar)))
 }
 
-export { get }
-
 type RemoveNonArray<T> = T extends readonly any[] ? T : never
 export function isNativeTuple<A>(a: A): a is RemoveNonArray<A> {
   return Array.isArray(a)
@@ -956,7 +879,7 @@ const genConstructor = (function*() {}).constructor
 /**
  * @example
  * ```ts
- * import { Utils } from "effect"
+ * import * as Utils from "effect/Utils"
  *
  * function* generatorFn() {
  *   yield 1
@@ -970,5 +893,5 @@ const genConstructor = (function*() {}).constructor
  * @category predicates
  * @since 3.11.0
  */
-export const isGeneratorFunction = (u: unknown): u is (...args: Array<any>) => Generator<any, any, any> =>
-  isObject(u) && u.constructor === genConstructor
+export const isGeneratorFunction = (u: unknown): u is (...args: Array<any>) => Generator<any> =>
+  isFunction(u) && u.constructor === genConstructor

package/src/withToast.ts

@@ -0,0 +1,133 @@
+import * as Cause from "effect/Cause"
+import * as Fiber from "effect/Fiber"
+import * as Context from "./Context.js"
+import * as Effect from "./Effect.js"
+import * as Layer from "./Layer.js"
+import type * as Option from "./Option.js"
+import * as S from "./Schema.js"
+import { CurrentToastId, Toast, type ToastId } from "./toast.js"
+import { wrapEffect } from "./utils.js"
+
+export interface ToastOptions<A, E, Args extends ReadonlyArray<unknown>, WaiR, SucR, ErrR> {
+  stableToastId?: undefined | string | ((...args: Args) => string | undefined)
+  timeout?: number
+  showSpanInfo?: false
+  groupId?: string
+  onWaiting:
+    | string
+    | ((...args: Args) => string | null)
+    | null
+    | ((
+      ...args: Args
+    ) => Effect.Effect<string | null, never, WaiR>)
+  onSuccess:
+    | string
+    | ((a: A, ...args: Args) => string | null)
+    | null
+    | ((
+      a: A,
+      ...args: Args
+    ) => Effect.Effect<string | null, never, SucR>)
+  onFailure:
+    | string
+    | ((
+      error: Option.Option<E>,
+      ...args: Args
+    ) => string | { level: "warn" | "error"; message: string })
+    | ((
+      error: Option.Option<E>,
+      ...args: Args
+    ) => Effect.Effect<string | { level: "warn" | "error"; message: string }, never, ErrR>)
+}
+
+// @effect-diagnostics-next-line missingEffectServiceDependency:off
+export class WithToast extends Context.Service<WithToast>()("WithToast", {
+  make: Effect.gen(function*() {
+    const toast = yield* Toast
+    return <A, E, Args extends readonly unknown[], R, WaiR = never, SucR = never, ErrR = never>(
+      options: ToastOptions<A, E, Args, WaiR, SucR, ErrR>
+    ) =>
+      Effect.fnUntraced(function*(self: Effect.Effect<A, E, R>, ...args: Args) {
+        const baseTimeout = options.timeout ?? 3_000
+
+        const stableToastId = typeof options.stableToastId === "function"
+          ? options.stableToastId(...args)
+          : options.stableToastId
+
+        const requestId: string = yield* Effect.currentSpan.pipe(
+          Effect.map((span) => span.traceId),
+          Effect.orElseSucceed(() => S.StringId.make())
+        )
+        const groupId = options.groupId
+        const meta = { ...(groupId !== undefined ? { groupId } : {}), requestId }
+
+        const t = yield* wrapEffect(options.onWaiting)(...args)
+        const toastId: ToastId | undefined = t === null
+          ? stableToastId
+          : stableToastId ?? `wait-${Math.random().toString(36).slice(2)}`
+
+        const waitingFiber = t === null ? undefined : yield* Effect.forkChild(
+          Effect.sleep("1 seconds").pipe(
+            Effect.andThen(toast.info(t, { id: toastId!, timeout: Infinity, ...meta }))
+          )
+        )
+        const interruptWaiting = waitingFiber ? Fiber.interrupt(waitingFiber) : Effect.void
+
+        return yield* self.pipe(
+          Effect.tap(Effect.fnUntraced(function*(a) {
+            yield* interruptWaiting
+            const t = yield* wrapEffect(options.onSuccess)(a, ...args)
+            if (t === null) {
+              return
+            }
+            yield* toast.success(
+              t,
+              toastId !== undefined
+                ? { id: toastId, timeout: baseTimeout, ...meta }
+                : { timeout: baseTimeout, ...meta }
+            )
+          })),
+          Effect.tapCause(Effect.fnUntraced(function*(cause) {
+            yield* interruptWaiting
+            yield* Effect.logDebug(
+              "WithToast - caught error cause: " + Cause.squash(cause),
+              Cause.hasInterruptsOnly(cause),
+              cause
+            )
+
+            if (Cause.hasInterruptsOnly(cause)) {
+              if (toastId) yield* toast.dismiss(toastId)
+              return
+            }
+
+            const spanInfo = options.showSpanInfo !== false
+              ? yield* Effect.currentSpan.pipe(
+                Effect.map((span) => `\nTrace: ${span.traceId}\nSpan: ${span.spanId}`),
+                Effect.orElseSucceed(() => "")
+              )
+              : ""
+
+            const t = yield* wrapEffect(options.onFailure)(Cause.findErrorOption(cause), ...args)
+            const opts = { timeout: baseTimeout * 2, ...meta }
+
+            if (typeof t === "object") {
+              const message = t.message + spanInfo
+              return t.level === "warn"
+                ? yield* toast.warning(message, toastId !== undefined ? { ...opts, id: toastId } : opts)
+                : yield* toast.error(message, toastId !== undefined ? { ...opts, id: toastId } : opts)
+            }
+            yield* toast.error(t + spanInfo, toastId !== undefined ? { ...opts, id: toastId } : opts)
+          }, Effect.uninterruptible)),
+          toastId !== undefined ? Effect.provideService(CurrentToastId, CurrentToastId.of({ toastId })) : (_) => _
+        )
+      })
+  })
+}) {
+  static readonly DefaultWithoutDependencies = Layer.effect(this, this.make)
+  static readonly Default = this.DefaultWithoutDependencies
+
+  static readonly handle = <A, E, Args extends Array<unknown>, R, WaiR = never, SucR = never, ErrR = never>(
+    options: ToastOptions<A, E, Args, WaiR, SucR, ErrR>
+  ): (self: Effect.Effect<A, E, R>, ...args: Args) => Effect.Effect<A, E, R | WaiR | SucR | ErrR | WithToast> =>
+  (self, ...args) => this.use((_) => _<A, E, Args, R, WaiR, SucR, ErrR>(options)(self, ...args))
+}

package/test/dist/rpc-dynamic-middleware.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc-dynamic-middleware.test.d.ts","sourceRoot":"","sources":["../rpc-dynamic-middleware.test.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAGrC,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AACtE,OAAO,KAAK,OAAO,MAAM,mBAAmB,CAAA;AAC5C,OAAO,KAAK,IAAI,MAAM,eAAe,CAAA;AACrC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAC7C,OAAO,KAAK,CAAC,MAAM,kBAAkB,CAAA;;;;;;;;AASrC,cAAM,WAAY,SAAQ,gBAKzB;CAAG;;;;;;;AAeJ,cAAM,cAAe,SAAQ,mBAE3B;CAAG;;;;;;;;AAGL,cAAM,eAAgB,SAAQ,oBAG5B;CAAG;;;;;;;;;AASL,cAAM,aAAc,SAAQ,kBAIC;CAC3B;AAkDF,eAAO,MAAM,OAAO,+MAWlB,CAAA;AA4CF,eAAO,MAAM,SAAS,yNAAwC,CAAA;AA0G9D,eAAO,MAAM,gBAAgB,sRAA+C,CAAA"}

package/test/dist/rpc.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rpc.test.d.ts","sourceRoot":"","sources":["../rpc.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AACrF,OAAO,EAAE,CAAC,EAAE,MAAM,iBAAiB,CAAA;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;;;;;;;;;;;;;;;;;;;;;;;;AAE7C,qBAAa,iBAAkB,SAAQ,sBAIrC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIL,qBAAa,KAAM,SAAQ,UAQzB;CAAG"}
+{"version":3,"file":"rpc.test.d.ts","sourceRoot":"","sources":["../rpc.test.ts"],"names":[],"mappings":"AAGA,OAAO,EAAiB,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAErF,OAAO,EAAE,CAAC,EAAE,MAAM,iBAAiB,CAAA;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;;;;;;;;;;;;;;;;;;;;;;;;AAE7C,qBAAa,iBAAkB,SAAQ,sBAIrC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAI0B,KAAK;;;;AAKpC,qBAAa,KAAM,SAAQ,UAQzB;CAAG"}

package/test/dist/secretURL.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secretURL.test.d.ts","sourceRoot":"","sources":["../secretURL.test.ts"],"names":[],"mappings":""}

package/test/dist/special.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"special.test.d.ts","sourceRoot":"","sources":["../special.test.ts"],"names":[],"mappings":""}

package/test/dist/stream-error.types.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RyZWFtLWVycm9yLnR5cGVzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zdHJlYW0tZXJyb3IudHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/test/dist/stream-error.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-error.types.d.ts","sourceRoot":"","sources":["../stream-error.types.ts"],"names":[],"mappings":""}

package/test/dist/stream-error.types.js

@@ -0,0 +1,27 @@
+import { S } from "effect-app";
+import { makeRpcClient } from "effect-app/client";
+class GeneralError extends S.TaggedError("GeneralError")("GeneralError", {
+    message: S.String
+}) {
+}
+class CustomError extends S.TaggedError("CustomError")("CustomError", {
+    reason: S.String
+}) {
+}
+const { TaggedRequestFor } = makeRpcClient({ config: {} }, GeneralError);
+const Req = TaggedRequestFor("Test");
+class StreamWithError extends Req.Stream()("StreamWithError", {}, {
+    success: S.Number,
+    error: CustomError
+}) {
+}
+const _check = true;
+const _check2 = true;
+class StreamNoError extends Req.Stream()("StreamNoError", {}, {
+    success: S.Number
+}) {
+}
+const _check3 = true;
+const _check4 = true;
+console.log("ok");
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RyZWFtLWVycm9yLnR5cGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3RyZWFtLWVycm9yLnR5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxDQUFDLEVBQUUsTUFBTSxZQUFZLENBQUE7QUFDOUIsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLG1CQUFtQixDQUFBO0FBRWpELE1BQU0sWUFBYSxTQUFRLENBQUMsQ0FBQyxXQUFXLENBQWUsY0FBYyxDQUFDLENBQUMsY0FBYyxFQUFFO0lBQ3JGLE9BQU8sRUFBRSxDQUFDLENBQUMsTUFBTTtDQUNsQixDQUFDO0NBQUc7QUFFTCxNQUFNLFdBQVksU0FBUSxDQUFDLENBQUMsV0FBVyxDQUFjLGFBQWEsQ0FBQyxDQUFDLGFBQWEsRUFBRTtJQUNqRixNQUFNLEVBQUUsQ0FBQyxDQUFDLE1BQU07Q0FDakIsQ0FBQztDQUFHO0FBRUwsTUFBTSxFQUFFLGdCQUFnQixFQUFFLEdBQUcsYUFBYSxDQUFDLEVBQUUsTUFBTSxFQUFFLEVBQVMsRUFBRSxFQUFFLFlBQVksQ0FBQyxDQUFBO0FBQy9FLE1BQU0sR0FBRyxHQUFHLGdCQUFnQixDQUFDLE1BQU0sQ0FBQyxDQUFBO0FBRXBDLE1BQU0sZUFBZ0IsU0FBUSxHQUFHLENBQUMsTUFBTSxFQUFtQixDQUFDLGlCQUFpQixFQUFFLEVBQUUsRUFBRTtJQUNqRixPQUFPLEVBQUUsQ0FBQyxDQUFDLE1BQU07SUFDakIsS0FBSyxFQUFFLFdBQVc7Q0FDbkIsQ0FBQztDQUFHO0FBR0wsTUFBTSxNQUFNLEdBQXdELElBQUksQ0FBQTtBQUN4RSxNQUFNLE9BQU8sR0FBd0QsSUFBSSxDQUFBO0FBRXpFLE1BQU0sYUFBYyxTQUFRLEdBQUcsQ0FBQyxNQUFNLEVBQWlCLENBQUMsZUFBZSxFQUFFLEVBQUUsRUFBRTtJQUMzRSxPQUFPLEVBQUUsQ0FBQyxDQUFDLE1BQU07Q0FDbEIsQ0FBQztDQUFHO0FBRUwsTUFBTSxPQUFPLEdBQTJDLElBQUksQ0FBQTtBQUM1RCxNQUFNLE9BQU8sR0FBMkMsSUFBSSxDQUFBO0FBRTVELE9BQU8sQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUEifQ==

package/test/moreStrings.test.ts

@@ -1,4 +1,4 @@
-import { S } from "effect-app"
+import * as S from "effect-app/Schema"
 import * as fc from "fast-check"
 import { urlAlphabet } from "nanoid"
 import { test } from "vitest"