effect-app 4.0.0-beta.23 → 4.0.0-beta.231

package/src/rpc/RpcContextMap.ts

@@ -2,14 +2,15 @@
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { type Schema as S, ServiceMap } from "effect"
+import type * as S from "effect/Schema"
 import { type AnyWithProps } from "effect/unstable/rpc/Rpc"
+import * as Context from "../Context.js"
 import { type RpcDynamic } from "./RpcMiddleware.js"
 
 type Values<T extends Record<any, any>> = T[keyof T]
 
 /**
- * Middleware is inactivate by default, the Key is optional in route context, and the service is optionally provided as Effect ServiceMap.
+ * Middleware is inactivate by default, the Key is optional in route context, and the service is optionally provided as Effect Context.
  * Unless explicitly configured as `true`.
  */
 export type RpcContextMap<Service, E> = {
@@ -22,7 +23,7 @@ export type RpcContextMap<Service, E> = {
 
 export declare namespace RpcContextMap {
   /**
-   * Middleware is active by default, and provides the Service at Key in route context, and the Service is provided as Effect ServiceMap.
+   * Middleware is active by default, and provides the Service at Key in route context, and the Service is provided as Effect Context.
    * Unless explicitly omitted.
    */
   export type Inverted<Service, E> = {
@@ -97,7 +98,7 @@ export type GetEffectError<RequestContextMap extends Record<string, RpcContextMa
   }
 >
 
-const tag = ServiceMap.Service("RequestContextConfig")
+const tag = Context.Service("RequestContextConfig")
 
 export const makeMap = <const Config extends Record<string, RpcContextMap.Any>>(config: Config) => {
   const cls = class {
@@ -109,7 +110,7 @@ export const makeMap = <const Config extends Record<string, RpcContextMap.Any>>(
   return Object.assign(cls, {
     config, /** Retrieves RequestContextConfig out of the Rpc annotations */
     getConfig: (rpc: AnyWithProps): GetContextConfig<Config> => {
-      return ServiceMap.getOrElse(rpc.annotations, tag as any, () => ({}))
+      return Context.getOrElse(rpc.annotations, tag as any, () => ({}))
     },
     /** Adapter used when setting the dynamic prop on a middleware implementation */
     get: <

package/src/rpc/RpcMiddleware.ts

@@ -1,17 +1,21 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { type Effect, type Schema, type Schema as S, type Scope, type ServiceMap, type Stream } from "effect"
 import { type NonEmptyReadonlyArray } from "effect/Array"
+import type * as Effect from "effect/Effect"
+import type * as S from "effect/Schema"
+import type * as Scope from "effect/Scope"
+import type * as Stream from "effect/Stream"
 import { type Rpc, RpcMiddleware } from "effect/unstable/rpc"
 import { type TypeId } from "effect/unstable/rpc/RpcMiddleware"
+import type * as Context from "../Context.js"
 import { type GetEffectContext, type RpcContextMap } from "./RpcContextMap.js"
 
 export type RpcMiddlewareV4<Provides, E, Requires> = RpcMiddleware.RpcMiddleware<Provides, E, Requires>
 
 export type RpcOptionsOriginal = {
   readonly optional?: boolean
-  readonly error?: Schema.Top
+  readonly error?: S.Top
   readonly requiredForClient?: boolean
 }
 
@@ -39,7 +43,7 @@ export interface TagClassAny extends RpcMiddleware.AnyService {
   readonly optional: boolean
   readonly provides: any
   readonly requires: any
-  readonly error: Schema.Top
+  readonly error: S.Top
   readonly dynamic?: RpcDynamic<any, any> | undefined
   readonly dependsOn?: NonEmptyReadonlyArray<AnyDynamic> | undefined
 }
@@ -49,18 +53,17 @@ export declare namespace TagClass {
    * @since 1.0.0
    * @category models
    */
-  export type FailureSchema<Options> = Options extends { readonly error: Schema.Top; readonly optional?: false }
+  export type FailureSchema<Options> = Options extends { readonly error: S.Top; readonly optional?: false }
     ? Options["error"]
     // actually not, the Failure depends on Dynamic Middleware Configuration!
     // : Options extends { readonly dynamic: RpcDynamic<any, infer A> } ? A["error"]
-    : typeof Schema.Never
+    : typeof S.Never
 
   /**
    * @since 1.0.0
    * @category models
    */
-  export type Failure<Options> = Options extends { readonly error: Schema.Codec<infer _A>; readonly optional?: false }
-    ? _A
+  export type Failure<Options> = Options extends { readonly error: S.Codec<infer _A>; readonly optional?: false } ? _A
     // actually not, the Failure depends on Dynamic Middleware Configuration!
     : Options extends { readonly dynamic: RpcDynamic<any, infer A> } ? S.Schema.Type<A["error"]>
     : never
@@ -69,7 +72,7 @@ export declare namespace TagClass {
    * @since 1.0.0
    * @category models
    */
-  export type FailureContext<Options> = Schema.Codec.DecodingServices<FailureSchema<Options>>
+  export type FailureContext<Options> = S.Codec.DecodingServices<FailureSchema<Options>>
 
   /**
    * @since 1.0.0
@@ -102,8 +105,8 @@ export declare namespace TagClass {
       requires?: any
       provides?: any
     }
-  > extends ServiceMap.Service<Self, Service> {
-    new(_: never): ServiceMap.ServiceClass.Shape<Name, Service>
+  > extends Context.Service<Self, Service> {
+    new(_: never): Context.ServiceClass.Shape<Name, Service>
     readonly [TypeId]: TypeId
     readonly optional: Optional<Options>
     readonly error: FailureSchema<Options>
@@ -226,7 +229,7 @@ export type ExtractProvides<R extends Rpc.Any, Tag extends string> = R extends
   Rpc.Rpc<Tag, infer _Payload, infer _Success, infer _Error, infer _Middleware, infer _Requires> ? _Middleware extends {
     readonly provides: infer _P
   } ? [_P] extends [never] ? never
-    : _P /*_P extends ServiceMap.Service<infer _I, infer _S> ? _I
+    : _P /*_P extends Context.Service<infer _I, infer _S> ? _I
     : never */
   : never
   : never

package/src/rpc.ts

@@ -1,4 +1,4 @@
-export * as RpcX from "./rpc.js"
+export * as Invalidation from "./rpc/Invalidation.js"
 export * as MiddlewareMaker from "./rpc/MiddlewareMaker.js"
 export * as RpcContextMap from "./rpc/RpcContextMap.js"
 export * as RpcMiddleware from "./rpc/RpcMiddleware.js"

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,11 +1,15 @@
 /* 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"
 
@@ -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/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"

package/test/rpc.test.ts

@@ -1,4 +1,8 @@
+import type * as Effect from "effect/Effect"
+import type * as Option from "effect/Option"
+import { expect, test } from "vitest"
 import { makeRpcClient, NotLoggedInError, UnauthorizedError } from "../src/client.js"
+import { ForceVoid } from "../src/client/makeClient.js"
 import { S } from "../src/index.js"
 import { RpcContextMap } from "../src/rpc.js"
 
@@ -8,16 +12,52 @@ export class RequestContextMap extends RpcContextMap.makeMap({
   test: RpcContextMap.make()(S.Never)
 }) {}
 
-const { TaggedRequest } = makeRpcClient(RequestContextMap)
+const stubMiddleware = {
+  requestContextMap: RequestContextMap.config,
+  requestContext: undefined as never
+}
+const { TaggedRequestFor } = makeRpcClient(stubMiddleware)
+const TaggedRequest = TaggedRequestFor("Test").Query
 
 export class Stats extends TaggedRequest<Stats>()("Stats", {}, {
   allowedRoles: ["manager"],
   success: {
-    usersActive24Hours: S.Number,
-    usersActiveLastWeek: S.Number,
-    newUsersLast24Hours: S.Number,
-    newUsersLastWeek: S.Number
+    usersActive24Hours: S.Finite,
+    usersActiveLastWeek: S.Finite,
+    newUsersLast24Hours: S.Finite,
+    newUsersLastWeek: S.Finite
   }
 }) {}
 
-declare const _stats: typeof Stats.success.Type
+declare const _stats: typeof Stats.Type
+declare const _statsSuccess: typeof Stats.success.Type
+declare const _statsError: typeof Stats.error.Type
+declare const _statsRequestType: typeof Stats.type
+
+test("ForceVoid decodes and encodes as void", () => {
+  const statsFromMake = Stats.make({})
+  const statsFromMakeOption = Stats.makeOption({})
+  const statsFromMakeEffect = Stats.makeEffect({})
+
+  expect(S.decodeUnknownSync(ForceVoid)(undefined)).toBe(undefined)
+  expect(S.is(ForceVoid)(undefined)).toBe(true)
+  expect(S.decodeUnknownSync(ForceVoid)("test")).toBe(undefined)
+  expect(S.is(ForceVoid)("test")).toBe(true)
+  expect(S.encodeUnknownSync(ForceVoid)("test")).toBe(undefined)
+  expect(S.encodeUnknownSync(S.toCodecJson(ForceVoid))("test")).toBe(null)
+  expectTypeOf<typeof _stats>().toEqualTypeOf<Stats>()
+  expectTypeOf<typeof _statsSuccess>().toEqualTypeOf<{
+    readonly usersActive24Hours: number
+    readonly usersActiveLastWeek: number
+    readonly newUsersLast24Hours: number
+    readonly newUsersLastWeek: number
+  }>()
+  // Resource error carries only `config.error` (and optional `generalErrors`); rcm-derived
+  // middleware errors no longer leak into `resource.error` — they reach the wire via the
+  // middleware tag attached to the rpc group (`rpc.middlewares[*].error` failure-union).
+  expectTypeOf<typeof _statsError>().toEqualTypeOf<never>()
+  expectTypeOf<typeof _statsRequestType>().toEqualTypeOf<"query">()
+  expectTypeOf(statsFromMake).toEqualTypeOf<Stats>()
+  expectTypeOf(statsFromMakeOption).toEqualTypeOf<Option.Option<Stats>>()
+  expectTypeOf(statsFromMakeEffect).toEqualTypeOf<Effect.Effect<Stats, S.SchemaError>>()
+})