effect-app 4.0.0-beta.195 → 4.0.0-beta.197

package/src/Schema.ts

@@ -1,10 +1,13 @@
 import { SchemaAST, type Tracer } from "effect"
 import * as S from "effect/Schema"
+import { type Simplify } from "effect/Struct"
+import type { RequiredKeys } from "effect/Types"
 import type { NonEmptyReadonlyArray } from "./Array.js"
 import { fakerArb } from "./faker.js"
 import { Email as EmailT, type Email as EmailType } from "./Schema/email.js"
 import { concurrencyUnbounded, withDefaultMake, withDefaultParseOptions } from "./Schema/ext.js"
 import { PhoneNumber as PhoneNumberT, type PhoneNumber as PhoneNumberType } from "./Schema/phoneNumber.js"
+import { type AST } from "./Schema/schema.js"
 import { copy, extendM, type StructuralCopyOrigin } from "./utils.js"
 
 export * from "effect/Schema"
@@ -41,18 +44,9 @@ export { Void as Void_ } from "effect/Schema"
 // Struct / NonEmptyArray / Record
 // ---------------------------------------------------------------------------
 
-type WithSchemaCopy<Self extends S.Top & { readonly Type: object }> = Self & {
-  readonly copy: StructuralCopyOrigin<Self["Type"]>
-}
-
-type OptionalMakeInput<Fields extends S.Struct.Fields> = {} extends S.Struct.MakeIn<Fields> ? {
-    make(input?: S.Struct.MakeIn<Fields>, options?: S.MakeOptions): S.Struct.Type<Fields>
-  }
-  : {}
-
 export function Struct<const Fields extends S.Struct.Fields>(
   fields: Fields
-): Struct<Fields> & OptionalMakeInput<Fields> {
+): Struct<Fields> {
   const result = S.Struct(fields).annotate(concurrencyUnbounded)
   const allowVoidMake = (schema: any): any => {
     // Normalize omitted input to an empty object so optional/default-only structs can be constructed with make().
@@ -107,27 +101,79 @@ export function Struct<const Fields extends S.Struct.Fields>(
   }
   ;(result as any).copy = copy
   allowVoidMake(result)
-  return result as Struct<Fields> & OptionalMakeInput<Fields>
+  return result as Struct<Fields>
 }
-export interface Struct<Fields extends S.Struct.Fields> extends WithSchemaCopy<S.Struct<Fields>> {
-  annotate(
-    annotations: S.Annotations.Bottom<S.Struct.Type<Fields>, S.Struct<Fields>["~type.parameters"]>
-  ): Struct<Fields>
-  annotateKey(annotations: S.Annotations.Key<S.Struct.Type<Fields>>): Struct<Fields>
-  mapFields<To extends S.Struct.Fields>(
+
+export interface Struct<Fields extends S.Struct.Fields> extends
+  S.Bottom<
+    Struct.Type<Fields>,
+    Struct.Encoded<Fields>,
+    Struct.DecodingServices<Fields>,
+    Struct.EncodingServices<Fields>,
+    AST.Objects,
+    // Rebuild is what's returned from annotate etc
+    Struct<Fields>,
+    Struct.MakeIn<Fields>,
+    Struct.Iso<Fields>
+  >
+{
+  /**
+   * The field definitions of this struct. Spread them into a new struct to
+   * reuse fields across schemas.
+   *
+   * **Example** (Reusing fields across structs)
+   *
+   * ```ts
+   * import { Schema } from "effect"
+   *
+   * const Timestamped = Schema.Struct({
+   *   createdAt: Schema.Date,
+   *   updatedAt: Schema.Date
+   * })
+   *
+   * const User = Schema.Struct({
+   *   ...Timestamped.fields,
+   *   name: Schema.String,
+   *   email: Schema.String
+   * })
+   * ```
+   */
+  readonly fields: Fields
+  /**
+   * Returns a new struct with the fields modified by the provided function.
+   *
+   * **Options**
+   *
+   * - `unsafePreserveChecks` - if `true`, keep any `.check(...)` constraints
+   *   that were attached to the original union. Defaults to `false`.
+   *
+   *   **Warning**: This is an unsafe operation. Since `mapFields`
+   *   transformations change the schema type, the original refinement functions
+   *   may no longer be valid or safe to apply to the transformed schema. Only
+   *   use this option if you have verified that your refinements remain correct
+   *   after the transformation.
+   */
+  mapFields<To extends Struct.Fields>(
     f: (fields: Fields) => To,
     options?: {
       readonly unsafePreserveChecks?: boolean | undefined
-    }
-  ): Struct<Readonly<To>>
+    } | undefined
+  ): Struct<Simplify<Readonly<To>>>
+
+  // added copy
+  readonly copy: StructuralCopyOrigin<Struct.Type<Fields>>
 }
+
 export declare namespace Struct {
   export type Fields = S.Struct.Fields
   export type Type<F extends S.Struct.Fields> = S.Struct.Type<F>
   export type Encoded<F extends S.Struct.Fields> = S.Struct.Encoded<F>
   export type DecodingServices<F extends S.Struct.Fields> = S.Struct.DecodingServices<F>
   export type EncodingServices<F extends S.Struct.Fields> = S.Struct.EncodingServices<F>
-  export type MakeIn<F extends S.Struct.Fields> = S.Struct.MakeIn<F>
+  // changed; all optional allows void
+  export type MakeIn<F extends S.Struct.Fields> = RequiredKeys<S.Struct.MakeIn<F>> extends never
+    ? void | S.Struct.MakeIn<F>
+    : S.Struct.MakeIn<F>
   export type Iso<F extends S.Struct.Fields> = S.Struct.Iso<F>
 }
 
@@ -151,11 +197,32 @@ export function TaggedStruct<const Tag extends SchemaAST.LiteralValue, const Fie
 ): TaggedStruct<Tag, Fields> {
   return Struct({ _tag: S.tag(value), ...fields }) as any
 }
-export type TaggedStruct<Tag extends SchemaAST.LiteralValue, Fields extends S.Struct.Fields> =
-  & WithSchemaCopy<
-    S.TaggedStruct<Tag, Fields>
+export interface TaggedStruct<Tag extends SchemaAST.LiteralValue, Fields extends S.Struct.Fields>
+  extends Struct<{ readonly _tag: S.tag<Tag> } & Fields>
+{}
+export declare namespace TaggedStruct {
+  export type Fields = S.Struct.Fields
+  export type Type<Tag extends SchemaAST.LiteralValue, F extends S.Struct.Fields> = S.Struct.Type<
+    { readonly _tag: S.tag<Tag> } & F
+  >
+  export type Encoded<Tag extends SchemaAST.LiteralValue, F extends S.Struct.Fields> = S.Struct.Encoded<
+    { readonly _tag: S.tag<Tag> } & F
   >
-  & OptionalMakeInput<Readonly<{ readonly _tag: S.tag<Tag> } & Fields>>
+  export type DecodingServices<Tag extends SchemaAST.LiteralValue, F extends S.Struct.Fields> =
+    S.Struct.DecodingServices<
+      { readonly _tag: S.tag<Tag> } & F
+    >
+  export type EncodingServices<Tag extends SchemaAST.LiteralValue, F extends S.Struct.Fields> =
+    S.Struct.EncodingServices<
+      { readonly _tag: S.tag<Tag> } & F
+    >
+  export type MakeIn<Tag extends SchemaAST.LiteralValue, F extends S.Struct.Fields> = S.Struct.MakeIn<
+    { readonly _tag: S.tag<Tag> } & F
+  >
+  export type Iso<Tag extends SchemaAST.LiteralValue, F extends S.Struct.Fields> = S.Struct.Iso<
+    { readonly _tag: S.tag<Tag> } & F
+  >
+}
 
 export function Record<Key extends S.Record.Key, Value extends S.Top>(
   key: Key,

package/src/client/apiClientFactory.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { flow } from "effect/Function"
+import { constant, flow } from "effect/Function"
 import * as Layer from "effect/Layer"
 import * as ManagedRuntime from "effect/ManagedRuntime"
 import * as Option from "effect/Option"
@@ -44,8 +44,8 @@ export type Req = S.Top & {
   config?: Record<string, any>
   readonly id: string
   readonly moduleName: string
-  readonly type: "command" | "query" | "stream"
-  readonly "~decodingServices"?: unknown
+  readonly type: "command" | "query"
+  readonly stream: boolean
 }
 
 class RequestName extends Context.Reference("RequestName", {
@@ -126,18 +126,18 @@ export const makeRpcGroupFromRequestsAndModuleName = <M extends RequestsAny, con
     .make(
       ...typedValuesOf(filtered).map((_) => {
         const r = _ as any
-        const isStream = r.type === "stream"
+        const isStream = r.stream
         const isCommand = r.type === "command"
         return (isCommand
-          ? Invalidation.makeCommandRpc(r._tag, { payload: r, success: r.success, error: r.error })
-          : isStream
-          ? Invalidation.makeStreamRpc(r._tag, {
-            payload: r,
-            success: r.success,
-            error: r.error,
-            stream: true as const
-          })
-          : Rpc.make(r._tag, { payload: r, success: r.success, error: r.error })) as any
+          ? isStream
+            ? Invalidation.makeStreamRpc(r._tag, {
+              payload: r,
+              success: r.success,
+              error: r.error,
+              stream: true as const
+            })
+            : Invalidation.makeCommandRpc(r._tag, { payload: r, success: r.success, error: r.error })
+          : Rpc.make(r._tag, { payload: r, success: r.success, error: r.error, stream: isStream })) as any
       })
     )
     .prefix(`${moduleName}.`) as unknown as RpcGroup.RpcGroup<
@@ -245,7 +245,7 @@ const makeApiClientFactory = Effect
             const fields = Struct.omit(Request.fields, ["_tag"] as const)
             const requestAttr = `${meta.moduleName}.${h._tag}`
             const isCommand = h.type === "command"
-            const isStream = h.type === "stream"
+            const isStream = h.stream
 
             const buildEffect = (input: any) =>
               mr.contextEffect.pipe(
@@ -314,7 +314,7 @@ const makeApiClientFactory = Effect
             // @ts-expect-error doc
             prev[cur] = Object.keys(fields).length === 0
               ? {
-                handler: isStream ? buildStream({}) : buildEffect({}),
+                handler: isStream ? constant(buildStream({})) : constant(buildEffect({})),
                 ...requestMeta
               }
               : {

package/src/client/clientFor.ts

@@ -85,13 +85,6 @@ export const makeQueryKey = ({ id, options }: { id: string; options?: ClientForO
     .join(".")
     .split(".")
 
-export interface RequestHandler<A, E, R, Request extends Req, Id extends string> {
-  handler: Effect.Effect<A, E, R>
-  id: Id
-  options?: ClientForOptions
-  Request: Request
-}
-
 export interface RequestHandlerWithInput<I, A, E, R, Request extends Req, Id extends string> {
   handler: (i: I) => Effect.Effect<A, E, R>
   id: Id
@@ -99,20 +92,15 @@ export interface RequestHandlerWithInput<I, A, E, R, Request extends Req, Id ext
   Request: Request
 }
 
-export interface RequestStreamHandler<A, E, R, Request extends Req, Id extends string, Final = A> {
-  handler: Stream.Stream<A, E, R>
-  id: Id
-  options?: ClientForOptions
-  Request: Request
-  /**
-   * Phantom type property (never set at runtime) that carries the `Final` type to
-   * `StreamMutationWithExtensions`. The tilde prefix follows the Effect convention for
-   * phantom/virtual properties and prevents accidental runtime access.
-   * Stream failures bubble through the execute effect's typed error channel `E`;
-   * the reactive `AsyncResult` ref also mirrors the failure for live progress UI.
-   */
-  readonly "~final"?: Final
-}
+/** Type alias: a no-input handler is simply `RequestHandlerWithInput<void, …>`. */
+export type RequestHandler<A, E, R, Request extends Req, Id extends string> = RequestHandlerWithInput<
+  void,
+  A,
+  E,
+  R,
+  Request,
+  Id
+>
 
 export interface RequestStreamHandlerWithInput<I, A, E, R, Request extends Req, Id extends string, Final = A> {
   handler: (i: I) => Stream.Stream<A, E, R>
@@ -129,9 +117,11 @@ export interface RequestStreamHandlerWithInput<I, A, E, R, Request extends Req,
   readonly "~final"?: Final
 }
 
-// make sure this is exported or d.ts of apiClientFactory breaks?!
-type ReqDecodingServices<M> = M extends { readonly "~decodingServices": infer DS } ? DS : never
+/** Type alias: a no-input stream handler is simply `RequestStreamHandlerWithInput<void, …>`. */
+export type RequestStreamHandler<A, E, R, Request extends Req, Id extends string, Final = A> =
+  RequestStreamHandlerWithInput<void, A, E, R, Request, Id, Final>
 
+// make sure this is exported or d.ts of apiClientFactory breaks?!
 export type RequestInputFromMake<I extends { readonly make: (...args: any[]) => any }> = Parameters<I["make"]> extends
   [] ? void : Parameters<I["make"]>[0]
 
@@ -154,36 +144,21 @@ export type HandlerInput<I extends { readonly make: (...args: any[]) => any }> =
 type FinalTypeOf<T extends Req> = T extends { readonly final: infer F extends S.Top } ? S.Schema.Type<F>
   : S.Schema.Type<T["success"]>
 
-type RequestHandlerFor<R, E, T extends Req, Id extends string> = T["type"] extends "stream"
-  ? HasNoFields<T> extends true ? RequestStreamHandler<
-      S.Schema.Type<T["success"]>,
-      S.Schema.Type<T["error"]> | E,
-      R | ReqDecodingServices<T>,
-      T,
-      Id,
-      FinalTypeOf<T>
-    >
-  : RequestStreamHandlerWithInput<
-    RequestInput<T>,
+type RequestHandlerFor<R, E, T extends Req, Id extends string> = T["stream"] extends true
+  ? RequestStreamHandlerWithInput<
+    HandlerInput<T>,
     S.Schema.Type<T["success"]>,
     S.Schema.Type<T["error"]> | E,
-    R | ReqDecodingServices<T>,
+    R | S.Codec.DecodingServices<T["success"]> | S.Codec.DecodingServices<T["error"]>,
     T,
     Id,
     FinalTypeOf<T>
   >
-  : HasNoFields<T> extends true ? RequestHandler<
-      S.Schema.Type<T["success"]>,
-      S.Schema.Type<T["error"]> | E,
-      R | ReqDecodingServices<T>,
-      T,
-      Id
-    >
   : RequestHandlerWithInput<
-    RequestInput<T>,
+    HandlerInput<T>,
     S.Schema.Type<T["success"]>,
     S.Schema.Type<T["error"]> | E,
-    R | ReqDecodingServices<T>,
+    R | S.Codec.DecodingServices<T["success"]> | S.Codec.DecodingServices<T["error"]>,
     T,
     Id
   >

package/src/client/makeClient.ts

@@ -87,21 +87,22 @@ type TaggedRequestForResult<
   Error extends S.Top,
   Config,
   ModuleName extends string,
-  Type extends "command" | "query" | "stream",
+  Type extends "command" | "query",
+  Stream extends boolean,
   Resources = never,
   Final extends S.Top = never
 > =
-  & S.EnhancedClass<Self, TaggedRequestSchema<Tag, Payload>, {}>
+  & S.Opaque<Self, S.ExtendedSchemaNoEncoded, TaggedRequestSchema<Tag, Payload>, {}>
   & {
+    readonly fields: TaggedRequestSchema<Tag, Payload>["fields"]
     readonly _tag: Tag
     readonly success: Success
     readonly error: Error
     readonly config: Config
-    readonly "~decodingServices": S.Codec.DecodingServices<Success> | S.Codec.DecodingServices<Error>
-    readonly "~encodingServices": S.Codec.EncodingServices<Success> | S.Codec.EncodingServices<Error>
     readonly id: `${ModuleName}.${Tag}`
     readonly moduleName: ModuleName
     readonly type: Type
+    readonly stream: Stream
     readonly "~invalidationResources"?: Resources
   }
   & ([Final] extends [never] ? {} : { readonly final: Final })
@@ -115,6 +116,7 @@ export const makeRpcClient = <
     success: S.Top | S.Struct.Fields // SchemaOrFields will make a Schema type out of Struct.Fields
     error: S.Top | S.Struct.Fields // SchemaOrFields will make a Schema type out of Struct.Fields
     final?: S.Top | S.Struct.Fields // optional final-value schema for stream requests
+    stream?: boolean // request metadata — stripped from stored config
   }
 
   type RequestConfig = GetContextConfig<RequestContextMap["config"]>
@@ -145,23 +147,124 @@ export const makeRpcClient = <
     const finalConfig = (config as any)?.final
     const finalSchema = finalConfig && S.isSchema(finalConfig) ? finalConfig : undefined
 
-    const RequestClass = S.TaggedClass<any>()(tag, fields)
+    // Strip stream from the stored config — it's request metadata, not handler config
+    const { stream: _stream, ...restConfig } = config ?? ({} as C)
+
+    const RequestClass = S.Opaque()(S.TaggedStruct(tag, fields))
     Object.assign(RequestClass, {
       _tag: tag,
       success: successSchema,
       error: failureSchema,
       ...(finalSchema !== undefined ? { final: finalSchema } : {}),
-      config
+      config: restConfig
     })
 
     return RequestClass
   }
 
-  function makeTaggedRequestWithMeta<ModuleName extends string, Type extends "command" | "query" | "stream">(
+  function makeTaggedRequestWithMeta<
+    ModuleName extends string,
+    Type extends "command" | "query"
+  >(
     moduleName: ModuleName,
     type: Type
   ) {
     function TaggedRequestWithMeta<Self, Resources extends InvalidationResources = never>(): {
+      // ─── stream: true overloads (must come before non-stream so TypeScript picks them) ───────────
+      <
+        Tag extends string,
+        Payload extends S.Struct.Fields,
+        Success extends S.Top | S.Struct.Fields,
+        Error extends S.Top | S.Struct.Fields,
+        Final extends S.Top | S.Struct.Fields = never,
+        C extends RequestConfig & Record<string, any> = RequestConfig & Record<string, any>
+      >(
+        tag: Tag,
+        fields: Payload,
+        config:
+          & Omit<C, "invalidatesQueries">
+          & { stream: true; success: Success; error: Error; final?: Final },
+        invalidatesQueries?: InvalidationCallback<
+          Resources,
+          InputFromPayload<Payload>,
+          OutputFromSuccess<SchemaOrFields<Success>>,
+          S.Schema.Type<ErrorResult<C & { success: Success; error: Error }>>
+        >
+      ): TaggedRequestForResult<
+        Self,
+        Tag,
+        Payload,
+        SchemaOrFields<Success>,
+        ErrorResult<C & { success: Success; error: Error }>,
+        Omit<
+          & Omit<C, "invalidatesQueries">
+          & {
+            success: Success
+            error: Error
+          }
+          & Partial<
+            InvalidationConfigForCommand<
+              Resources,
+              Payload,
+              SchemaOrFields<Success>,
+              ErrorResult<C & { success: Success; error: Error }>
+            >
+          >,
+          "success" | "error" | "stream"
+        >,
+        ModuleName,
+        Type,
+        true,
+        Resources,
+        [Final] extends [never] ? never : SchemaOrFields<Final>
+      >
+      <
+        Tag extends string,
+        Payload extends S.Struct.Fields,
+        Success extends S.Top | S.Struct.Fields,
+        Final extends S.Top | S.Struct.Fields = never,
+        C extends RequestConfig & Record<string, any> & { error?: never } =
+          & RequestConfig
+          & Record<string, any>
+          & { error?: never }
+      >(
+        tag: Tag,
+        fields: Payload,
+        config:
+          & Omit<C, "invalidatesQueries">
+          & { stream: true; success: Success; final?: Final },
+        invalidatesQueries?: InvalidationCallback<
+          Resources,
+          InputFromPayload<Payload>,
+          OutputFromSuccess<SchemaOrFields<Success>>,
+          S.Schema.Type<ErrorResult<C & { success: Success }>>
+        >
+      ): TaggedRequestForResult<
+        Self,
+        Tag,
+        Payload,
+        SchemaOrFields<Success>,
+        ErrorResult<C & { success: Success }>,
+        Omit<
+          & Omit<C, "invalidatesQueries">
+          & { success: Success }
+          & Partial<
+            InvalidationConfigForCommand<
+              Resources,
+              Payload,
+              SchemaOrFields<Success>,
+              ErrorResult<C & { success: Success }>
+            >
+          >,
+          "success" | "error" | "stream"
+        >,
+        ModuleName,
+        Type,
+        true,
+        Resources,
+        [Final] extends [never] ? never : SchemaOrFields<Final>
+      >
+      // ─── non-stream overloads ────────────────────────────────────────────────────────────────────
       <
         Tag extends string,
         Payload extends S.Struct.Fields,
@@ -201,10 +304,11 @@ export const makeRpcClient = <
               ErrorResult<C & { success: Success; error: Error }>
             >
           >,
-          "success" | "error"
+          "success" | "error" | "stream"
         >,
         ModuleName,
         Type,
+        false,
         Resources,
         [Final] extends [never] ? never : SchemaOrFields<Final>
       >
@@ -213,9 +317,12 @@ export const makeRpcClient = <
         Payload extends S.Struct.Fields,
         Success extends S.Top | S.Struct.Fields,
         Final extends S.Top | S.Struct.Fields = never,
-        C extends RequestConfig & Record<string, any> & { error?: never } = RequestConfig & Record<string, any> & {
-          error?: never
-        }
+        C extends RequestConfig & Record<string, any> & { error?: never } =
+          & RequestConfig
+          & Record<string, any>
+          & {
+            error?: never
+          }
       >(
         tag: Tag,
         fields: Payload,
@@ -247,10 +354,11 @@ export const makeRpcClient = <
               ErrorResult<C & { success: Success }>
             >
           >,
-          "success" | "error"
+          "success" | "error" | "stream"
         >,
         ModuleName,
         Type,
+        false,
         Resources,
         [Final] extends [never] ? never : SchemaOrFields<Final>
       >
@@ -290,10 +398,11 @@ export const makeRpcClient = <
               ErrorResult<C & { error: Error }>
             >
           >,
-          "success" | "error"
+          "success" | "error" | "stream"
         >,
         ModuleName,
         Type,
+        false,
         Resources
       >
       <
@@ -319,10 +428,11 @@ export const makeRpcClient = <
         Omit<
           & Omit<C, "invalidatesQueries">
           & Partial<InvalidationConfigForCommand<Resources, Payload, typeof ForceVoid, ErrorResult<C>>>,
-          "success" | "error"
+          "success" | "error" | "stream"
         >,
         ModuleName,
         Type,
+        false,
         Resources
       >
       <Tag extends string, Payload extends S.Struct.Fields>(
@@ -336,7 +446,8 @@ export const makeRpcClient = <
         ErrorResult<{}>,
         Record<string, never>,
         ModuleName,
-        Type
+        Type,
+        false
       >
     } {
       return (<Tag extends string, Fields extends S.Struct.Fields, C extends ServiceMap>(
@@ -345,9 +456,10 @@ export const makeRpcClient = <
         config?: C,
         invalidatesQueries?: InvalidationCallback<Resources>
       ) => {
+        const isStream = (config as any)?.stream === true
         const requestConfig = invalidatesQueries === undefined ? config : { ...config, invalidatesQueries }
         const cls = makeRequestClass(tag, fields, requestConfig)
-        Object.assign(cls, { id: `${moduleName}.${tag}`, moduleName, type })
+        Object.assign(cls, { id: `${moduleName}.${tag}`, moduleName, type, stream: isStream })
         return cls
       }) as any
     }
@@ -357,26 +469,21 @@ export const makeRpcClient = <
   function TaggedRequestFor<ModuleName extends string>(moduleName: ModuleName) {
     const Query = makeTaggedRequestWithMeta(moduleName, "query")
     const Command = makeTaggedRequestWithMeta(moduleName, "command")
-    const Stream = makeTaggedRequestWithMeta(moduleName, "stream")
 
     return {
       moduleName,
       /**
        * Create query request classes for this module.
        * Queries read state and should not mutate server state.
+       * Pass `stream: true` in the config to produce a Stream of `success` values (QueryStream behaviour).
        */
       Query,
       /**
        * Create command request classes for this module.
        * Commands mutate state and should avoid returning complex read models.
+       * Pass `stream: true` in the config to produce a Stream of `success` values (CommandStream behaviour).
        */
-      Command,
-      /**
-       * Create stream request classes for this module.
-       * Streams produce a Stream of `success` values, may also fail with `error`.
-       * Handlers must return an `Effect`-compatible Stream rather than an Effect.
-       */
-      Stream
+      Command
     } as const
   }
 

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

@@ -1 +1 @@
-{"version":3,"file":"rpc.test.d.ts","sourceRoot":"","sources":["../rpc.test.ts"],"names":[],"mappings":"AAEA,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKL,qBAAa,KAAM,SAAQ,UAQzB;CAAG"}
+{"version":3,"file":"rpc.test.d.ts","sourceRoot":"","sources":["../rpc.test.ts"],"names":[],"mappings":"AAEA,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKL,qBAAa,KAAM,SAAQ,UAQzB;CAAG"}