@effect-app/infra 2.54.5 → 2.55.1

package/src/api/routing.ts

@@ -11,6 +11,7 @@ import type { GetEffectContext, RPCContextMap } from "effect-app/client/req"
 import { type HttpHeaders, HttpRouter } from "effect-app/http"
 import { pretty, typedKeysOf, typedValuesOf } from "effect-app/utils"
 import type { Contravariant } from "effect/Types"
+import { type YieldWrap } from "effect/Utils"
 import { makeRpc, type Middleware } from "./routing/DynamicMiddleware.js"
 
 const logRequestError = logError("Request")
@@ -204,6 +205,7 @@ export const makeRouter = <
     const items = typedKeysOf(filtered).reduce(
       (prev, cur) => {
         ;(prev as any)[cur] = Object.assign((fnOrEffect: any) => {
+          if (fnOrEffect[Symbol.toStringTag] === "GeneratorFunction") fnOrEffect = Effect.fnUntraced(fnOrEffect)
           const stack = new Error().stack?.split("\n").slice(2).join("\n")
           return Effect.isEffect(fnOrEffect)
             ? class {
@@ -265,6 +267,86 @@ export const makeRouter = <
       ? { [k in keyof Layers]: Layer.Layer.Error<Layers[k]> }[number]
       : never
 
+    const total = Object.keys(filtered).length
+    const router: AddAction<Filtered[keyof Filtered]> = {
+      accum: {},
+      add(a: any) {
+        ;(this.accum as any)[a.request._tag] = a
+        ;(this as any)[a.request._tag] = a
+        if (Object.keys(this.accum).length === total) return this.accum as any
+        return this as any
+      }
+    }
+
+    type HndlrWithInputG<
+      Action extends AnyRequestModule,
+      Mode extends "d" | "raw"
+    > = (
+      req: S.Schema.Type<Action>
+    ) => Generator<
+      YieldWrap<Effect<any, S.Schema.Type<GetFailure<Action>> | S.ParseResult.ParseError, any>>,
+      GetSuccessShape<Action, Mode>,
+      never
+    >
+
+    type HndlrWithInput<Action extends AnyRequestModule, Mode extends "d" | "raw"> = (
+      req: S.Schema.Type<Action>
+    ) => Effect<
+      GetSuccessShape<Action, Mode>,
+      S.Schema.Type<GetFailure<Action>> | S.ParseResult.ParseError,
+      any
+    >
+
+    type Hndlr<Action extends AnyRequestModule, Mode extends "d" | "raw"> = Effect<
+      GetSuccessShape<Action, Mode>,
+      S.Schema.Type<GetFailure<Action>> | S.ParseResult.ParseError,
+      any
+    >
+
+    type Hndlrs<Action extends AnyRequestModule, Mode extends "d" | "raw"> =
+      | HndlrWithInputG<Action, Mode>
+      | HndlrWithInput<Action, Mode>
+      | Hndlr<Action, Mode>
+
+    type DHndlrs<Action extends AnyRequestModule> = Hndlrs<Action, "d">
+
+    type RawHndlrs<Action extends AnyRequestModule> =
+      | { raw: HndlrWithInputG<Action, "raw"> }
+      | { raw: HndlrWithInput<Action, "raw"> }
+      | { raw: Hndlr<Action, "raw"> }
+
+    type AnyHndlrs<Action extends AnyRequestModule> = RawHndlrs<Action> | DHndlrs<Action>
+
+    const router3: <
+      const Impl extends {
+        [K in keyof Filter<Rsc>]: AnyHndlrs<Rsc[K]>
+      }
+    >(
+      impl: Impl
+    ) => {
+      [K in keyof Impl & keyof Filter<Rsc>]: Handler<
+        Filter<Rsc>[K],
+        Impl[K] extends { raw: any } ? "raw" : "d",
+        Exclude<
+          | Context
+          | Exclude<
+            Impl[K] extends { raw: any } ? Impl[K]["raw"] extends (...args: any[]) => Effect<any, any, infer R> ? R
+              : Impl[K]["raw"] extends Effect<any, any, infer R> ? R
+              : never
+              : Impl[K] extends (...args: any[]) => Effect<any, any, infer R> ? R
+              : Impl[K] extends Effect<any, any, infer R> ? R
+              : never,
+            GetEffectContext<CTXMap, Rsc[K]["config"]>
+          >,
+          HttpRouter.HttpRouter.Provided
+        >
+      >
+    } = (obj: Record<keyof Filtered, any>) =>
+      typedKeysOf(obj).reduce((acc, cur) => {
+        acc[cur] = "raw" in obj[cur] ? items[cur].raw(obj[cur].raw) : items[cur](obj[cur])
+        return acc
+      }, {} as any)
+
     const f = <
       E,
       R,
@@ -275,7 +357,7 @@ export const makeRouter = <
       TLayers extends NonEmptyReadonlyArray<Layer.Layer.Any> | never[]
     >(
       layers: TLayers,
-      make: Effect<THandlers, E, R>
+      make: Effect<THandlers, E, R> | Generator<YieldWrap<Effect<any, any, any>>, THandlers, E>
     ) => {
       type ProvidedLayers =
         | { [k in keyof Layers]: Layer.Layer.Success<Layers[k]> }[number]
@@ -285,6 +367,10 @@ export const makeRouter = <
       const layer = (requestLayers: any) =>
         Effect
           .gen(function*() {
+            make = (make as any)[Symbol.toStringTag] === "GeneratorFunction"
+              ? Effect.fnUntraced(make as any)(router3) as any
+              : make
+
             const controllers = yield* make
             const rpc = yield* makeRpc(middleware)
 
@@ -466,6 +552,35 @@ export const makeRouter = <
 
     const effect: {
       // Multiple times duplicated the "good" overload, so that errors will only mention the last overload when failing
+      <
+        const Make extends {
+          dependencies: Array<Layer.Layer.Any>
+          effect: (match: typeof router3) => Generator<
+            YieldWrap<Effect<any, any, Make["strict"] extends false ? any : GetSuccess<Make["dependencies"]>>>,
+            { [K in keyof Filter<Rsc>]: AHandler<Rsc[K]> },
+            any
+          >
+
+          strict?: boolean
+          /** @deprecated */
+          readonly ಠ_ಠ: never
+        }
+      >(
+        make: Make
+      ): {
+        moduleName: ModuleName
+
+        routes: (requestLayers: any) => Layer.Layer<
+          RouterShape<Rsc>,
+          MakeErrors<Make> | GetError<Make["dependencies"]>,
+          | GetContext<Make["dependencies"]>
+          // | GetContext<Layers> // elsewhere provided
+          | Exclude<MakeContext<Make> | RMW, GetSuccess<Make["dependencies"]> | GetSuccess<Layers>>
+        >
+
+        // just for type testing purposes
+        make: Make
+      }
       <
         const Make extends {
           dependencies: Array<Layer.Layer.Any>
@@ -490,6 +605,9 @@ export const makeRouter = <
           // | GetContext<Layers> // elsewhere provided
           | Exclude<MakeContext<Make> | RMW, GetSuccess<Make["dependencies"]> | GetSuccess<Layers>>
         >
+
+        // just for type testing purposes
+        make: Make
       }
       <
         const Make extends {
@@ -515,6 +633,9 @@ export const makeRouter = <
           // | GetContext<Layers> // elsewhere provided
           | Exclude<MakeContext<Make> | RMW, GetSuccess<Make["dependencies"]> | GetSuccess<Layers>>
         >
+
+        // just for type testing purposes
+        make: Make
       }
       <
         const Make extends {
@@ -540,6 +661,9 @@ export const makeRouter = <
           // | GetContext<Layers> // elsewhere provided
           | Exclude<MakeContext<Make> | RMW, GetSuccess<Make["dependencies"]> | GetSuccess<Layers>>
         >
+
+        // just for type testing purposes
+        make: Make
       }
       <
         const Make extends {
@@ -565,6 +689,9 @@ export const makeRouter = <
           // | GetContext<Layers> // elsewhere provided
           | Exclude<MakeContext<Make> | RMW, GetSuccess<Make["dependencies"]> | GetSuccess<Layers>>
         >
+
+        // just for type testing purposes
+        make: Make
       }
       <
         const Make extends {
@@ -588,6 +715,36 @@ export const makeRouter = <
           // | GetContext<Layers> // elsewhere provided
           | Exclude<MakeContext<Make> | RMW, GetSuccess<Make["dependencies"]> | GetSuccess<Layers>>
         >
+
+        // just for type testing purposes
+        make: Make
+      }
+      <
+        const Make extends {
+          dependencies: Array<Layer.Layer.Any>
+          effect: (match: typeof router3) => Generator<
+            YieldWrap<Effect<any, any, Make["strict"] extends false ? any : GetSuccess<Make["dependencies"]>>>,
+            { [K in keyof Filter<Rsc>]: AHandler<Rsc[K]> },
+            any
+          >
+
+          strict?: boolean
+        }
+      >(
+        make: Make
+      ): {
+        moduleName: ModuleName
+
+        routes: (requestLayers: any) => Layer.Layer<
+          RouterShape<Rsc>,
+          MakeErrors<Make> | GetError<Make["dependencies"]>,
+          | GetContext<Make["dependencies"]>
+          // | GetContext<Layers> // elsewhere provided
+          | Exclude<MakeContext<Make> | RMW, GetSuccess<Make["dependencies"]> | GetSuccess<Layers>>
+        >
+
+        // just for type testing purposes
+        make: Make
       }
       <
         const Make extends {
@@ -619,75 +776,13 @@ export const makeRouter = <
         //   HttpRouter.HttpRouter.Provided
         // >
         routes: any
-      }
-    } = ((m: { dependencies: any; effect: any; strict?: any }) => f(m.dependencies, m.effect)) as any
 
-    const total = Object.keys(filtered).length
-    const router: AddAction<Filtered[keyof Filtered]> = {
-      accum: {},
-      add(a: any) {
-        ;(this.accum as any)[a.request._tag] = a
-        ;(this as any)[a.request._tag] = a
-        if (Object.keys(this.accum).length === total) return this.accum as any
-        return this as any
-      }
-    }
-
-    type HndlrWithInput<Action extends AnyRequestModule, Mode extends "d" | "raw"> = (
-      req: S.Schema.Type<Action>
-    ) => Effect<
-      GetSuccessShape<Action, Mode>,
-      S.Schema.Type<GetFailure<Action>> | S.ParseResult.ParseError,
-      any
-    >
-
-    type Hndlr<Action extends AnyRequestModule, Mode extends "d" | "raw"> = Effect<
-      GetSuccessShape<Action, Mode>,
-      S.Schema.Type<GetFailure<Action>> | S.ParseResult.ParseError,
-      any
-    >
-
-    type Hndlrs<Action extends AnyRequestModule, Mode extends "d" | "raw"> =
-      | HndlrWithInput<Action, Mode>
-      | Hndlr<Action, Mode>
-
-    type DHndlrs<Action extends AnyRequestModule> = Hndlrs<Action, "d">
-
-    type RawHndlrs<Action extends AnyRequestModule> =
-      | { raw: HndlrWithInput<Action, "raw"> }
-      | { raw: Hndlr<Action, "raw"> }
-
-    type AnyHndlrs<Action extends AnyRequestModule> = RawHndlrs<Action> | DHndlrs<Action>
-
-    const router3: <
-      const Impl extends {
-        [K in keyof Filter<Rsc>]: AnyHndlrs<Rsc[K]>
+        // just for type testing purposes
+        make: Make
       }
-    >(
-      impl: Impl
-    ) => {
-      [K in keyof Impl & keyof Filter<Rsc>]: Handler<
-        Filter<Rsc>[K],
-        Impl[K] extends { raw: any } ? "raw" : "d",
-        Exclude<
-          | Context
-          | Exclude<
-            Impl[K] extends { raw: any } ? Impl[K]["raw"] extends (...args: any[]) => Effect<any, any, infer R> ? R
-              : Impl[K]["raw"] extends Effect<any, any, infer R> ? R
-              : never
-              : Impl[K] extends (...args: any[]) => Effect<any, any, infer R> ? R
-              : Impl[K] extends Effect<any, any, infer R> ? R
-              : never,
-            GetEffectContext<CTXMap, Rsc[K]["config"]>
-          >,
-          HttpRouter.HttpRouter.Provided
-        >
-      >
-    } = (obj: Record<keyof Filtered, any>) =>
-      typedKeysOf(obj).reduce((acc, cur) => {
-        acc[cur] = "raw" in obj[cur] ? items[cur].raw(obj[cur].raw) : items[cur](obj[cur])
-        return acc
-      }, {} as any)
+    } =
+      ((m: { dependencies: any; effect: any; strict?: any }) =>
+        Object.assign(f(m.dependencies, m.effect), { make: m })) as any
 
     return Object.assign(effect, items, { router, router3 })
   }
@@ -729,14 +824,17 @@ export type MakeDeps<Make> = Make extends { readonly dependencies: ReadonlyArray
   : never
 
 export type MakeErrors<Make> = Make extends { readonly effect: Effect<any, infer E, any> } ? E
+  : Make extends { readonly effect: (_: any) => Generator<YieldWrap<Effect<any, infer E, any>>, any, any> } ? E
   : never
 
 export type MakeContext<Make> = Make extends { readonly effect: Effect<any, any, infer R> } ? R
+  : Make extends { readonly effect: (_: any) => Generator<YieldWrap<Effect<any, any, infer R>>, any, any> } ? R
   : never
 
 export type MakeHandlers<Make, Handlers extends Record<string, any>> = Make extends
   { readonly effect: Effect<{ [K in keyof Handlers]: AHandler<Handlers[K]> }, any, any> }
   ? Effect.Success<Make["effect"]>
+  : Make extends { readonly effect: (_: any) => Generator<YieldWrap<any>, infer S, any> } ? S
   : never
 
 /**

package/test/{controller.test.ts.bak → controller.test.ts}

@@ -1,12 +1,11 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-import { makeMiddleware, makeRouter } from "@effect-app/infra/api/routing"
+import { type MakeContext, type MakeErrors, makeMiddleware, makeRouter } from "@effect-app/infra/api/routing"
 import type { RequestContext } from "@effect-app/infra/RequestContext"
-import { Rpc } from "@effect/rpc"
-import type { Request } from "effect-app"
-import { Context, Effect, FiberRef, Layer, S, Schedule } from "effect-app"
-import { type GetEffectContext, makeRpcClient, type RPCContextMap, UnauthorizedError } from "effect-app/client"
-import { HttpHeaders, HttpServerRequest } from "effect-app/http"
+import { expectTypeOf } from "@effect/vitest"
+import { Context, Effect, Layer, type Request, S, Schedule } from "effect-app"
+import { type GetEffectContext, InvalidStateError, makeRpcClient, type RPCContextMap, UnauthorizedError } from "effect-app/client"
+import { type HttpServerRequest } from "effect-app/http"
 import type * as EffectRequest from "effect/Request"
 import { it } from "vitest"
 
@@ -29,11 +28,15 @@ const middleware = makeMiddleware({
   execute: Effect.gen(function*() {
     return <T extends { config?: { [K in keyof CTXMap]?: any } }, Req extends S.TaggedRequest.All, R>(
       _schema: T & S.Schema<Req, any, never>,
-      handler: (request: Req) => Effect.Effect<EffectRequest.Request.Success<Req>, EffectRequest.Request.Error<Req>, R>,
+      handler: (
+        request: Req,
+        headers: any
+      ) => Effect.Effect<EffectRequest.Request.Success<Req>, EffectRequest.Request.Error<Req>, R>,
       moduleName?: string
     ) =>
     (
-      req: Req
+      req: Req,
+      headers: any
     ): Effect.Effect<
       Request.Request.Success<Req>,
       Request.Request.Error<Req>,
@@ -88,7 +91,7 @@ const middleware = makeMiddleware({
           //   }
           // }
 
-          return yield* handler(req).pipe(
+          return yield* handler(req, headers).pipe(
             Effect.retry(optimisticConcurrencySchedule),
             Effect.provide(ctx as Context.Context<GetEffectContext<CTXMap, T["config"]>>)
           )
@@ -102,16 +105,16 @@ const middleware = makeMiddleware({
                 //   ..._,
                 //   name: NonEmptyString255(moduleName ? `${moduleName}.${req._tag}` : req._tag)
                 // }))
-                const httpReq = yield* HttpServerRequest.HttpServerRequest
+                // const httpReq = yield* HttpServerRequest.HttpServerRequest
                 // TODO: only pass Authentication etc, or move headers to actual Rpc Headers
-                yield* FiberRef.update(
-                  Rpc.currentHeaders,
-                  (headers) =>
-                    HttpHeaders.merge(
-                      httpReq.headers,
-                      headers
-                    )
-                )
+                // yield* FiberRef.update(
+                //   Rpc.currentHeaders,
+                //   (headers) =>
+                //     HttpHeaders.merge(
+                //       httpReq.headers,
+                //       headers
+                //     )
+                // )
               })
               .pipe(Layer.effectDiscard)
           )
@@ -286,3 +289,55 @@ Router(Something)({
     })
   })
 })
+
+const { make: _make, routes: _routes } = Router(Something)({
+  dependencies: [
+    SomethingRepo.Default,
+    SomethingService.Default,
+    SomethingService2.Default
+  ],
+  *effect(match) {
+    const repo = yield* SomethingRepo
+    const smth = yield* SomethingService
+    const smth2 = yield* SomethingService2
+
+    // this gets catched in 'routes' type
+    if (Math.random() > 0.5) {
+      return yield* new InvalidStateError("ciao")
+    }
+
+    console.log({ repo, smth, smth2 })
+
+    return match({
+      *GetSomething(req) {
+        console.log(req.id)
+
+        const _b = yield* Effect.succeed(false)
+        if (_b) {
+          //   expected errors here because RequestError is not a valid error for controllers
+          // yield* new RequestError(1 as any)
+          // return yield* new RequestError(1 as any)
+        }
+        if (Math.random() > 0.5) {
+          return yield* Effect.succeed("12")
+        }
+        if (!_b) {
+          return yield* new UnauthorizedError()
+        } else {
+          // expected an error here because a boolean is not a string
+          // return _b
+          return "12"
+        }
+      },
+      DoSomething: {
+        *raw() {
+          return yield* Effect.succeed(undefined)
+        }
+      },
+      GetSomething2: { raw: SomethingService2.use(() => Effect.succeed("12")) }
+    })
+  }
+})
+
+expectTypeOf({} as MakeErrors<typeof _make>).toEqualTypeOf<InvalidStateError>()
+expectTypeOf({} as MakeContext<typeof _make>).toEqualTypeOf<SomethingService | SomethingRepo | SomethingService2>()

package/test/dist/controller.test copy.d.ts

@@ -0,0 +1,169 @@
+import type { RequestContext } from "@effect-app/infra/RequestContext";
+import { Rpc } from "@effect/rpc";
+import { Effect, Layer, S } from "effect-app";
+import { type RPCContextMap, UnauthorizedError } from "effect-app/client";
+import { HttpServerRequest } from "effect-app/http";
+export interface CTX {
+    context: RequestContext;
+}
+export type CTXMap = {
+    requireRoles: RPCContextMap.Custom<"", never, typeof UnauthorizedError, Array<string>>;
+};
+export declare const matchAll: <T extends {
+    [key: string]: {
+        Router: {
+            router: Effect<import("@effect/platform/HttpRouter").HttpRouter<any, any>, any, any>;
+        };
+        routes: Layer.Layer<any, any, any>;
+        moduleName: string;
+    };
+}, A, E, R>(handlers: T, requestLayer: Layer.Layer<A, E, R>) => {
+    layer: Layer.Layer<never, Layer.Layer.Error<T[keyof T]["routes"]>, Layer.Layer.Context<T[keyof T]["routes"]>>;
+    Router: import("@effect/platform/HttpRouter").HttpRouter.TagClass<"RootRouter", "RootRouter", Effect.Effect.Success<T[keyof T]["Router"]["router"]> extends infer T_1 ? T_1 extends T_1 & Effect.Effect.Success<T[keyof T]["Router"]["router"]> ? T_1 extends import("@effect/platform/HttpRouter").HttpRouter<infer E_1, any> ? E_1 : never : never : never, R | Exclude<Effect.Effect.Success<T[keyof T]["Router"]["router"]> extends infer T_2 ? T_2 extends T_2 & Effect.Effect.Success<T[keyof T]["Router"]["router"]> ? T_2 extends import("@effect/platform/HttpRouter").HttpRouter<any, infer R_1> ? R_1 : never : never : never, A>>;
+}, matchFor: <const ModuleName extends string, const Rsc extends Record<string, any>>(rsc: Rsc & {
+    meta: {
+        moduleName: ModuleName;
+    };
+}) => {
+    <const Make extends {
+        dependencies: import("effect-app").Array<Layer.Layer.Any>;
+        effect: Effect<{ [K_1 in keyof { [K in keyof Rsc as Rsc[K] extends import("@effect-app/infra/api/routing").AnyRequestModule ? K : never]: Rsc[K]; }]: import("@effect-app/infra/api/routing").Handler<Rsc[K_1], any, any>; }, any, Make["strict"] extends false ? any : Make["dependencies"] extends infer T ? T extends Make["dependencies"] ? T extends readonly [Layer.Layer.Any, ...Layer.Layer.Any[]] ? { [k in keyof T]: Layer.Layer.Success<T[k]>; }[number] : never : never : never>;
+        strict?: boolean;
+        readonly ಠ_ಠ: never;
+    }>(make: Make): {
+        moduleName: ModuleName;
+        Router: import("@effect/platform/HttpRouter").HttpRouter.TagClass<import("@effect-app/infra/api/routing").RouterShape<Rsc>, `${ModuleName}Router`, never, Exclude<[{ [K_2 in keyof { [K in keyof Rsc as Rsc[K] extends import("@effect-app/infra/api/routing").AnyRequestModule ? K : never]: Rsc[K]; }]: Rpc.Rpc<Rsc[K_2], import("@effect-app/infra/api/routing")._R<ReturnType<import("@effect-app/infra/api/routing").MakeHandlers<Make, { [K in keyof Rsc as Rsc[K] extends import("@effect-app/infra/api/routing").AnyRequestModule ? K : never]: Rsc[K]; }>[K_2]["handler"]>>>; }[keyof { [K in keyof Rsc as Rsc[K] extends import("@effect-app/infra/api/routing").AnyRequestModule ? K : never]: Rsc[K]; }]] extends [Rpc.Rpc<any, infer R>] ? R : never, import("@effect/platform/HttpRouter").HttpRouter.Provided>>;
+        routes: Layer.Layer<import("@effect-app/infra/api/routing").RouterShape<Rsc>, import("@effect-app/infra/api/routing").MakeErrors<Make> | (Make["dependencies"] extends infer T_1 ? T_1 extends Make["dependencies"] ? T_1 extends readonly [Layer.Layer.Any, ...Layer.Layer.Any[]] ? { [k_1 in keyof T_1]: Layer.Layer.Error<T_1[k_1]>; }[number] : never : never : never), (Make["dependencies"] extends infer T_2 ? T_2 extends Make["dependencies"] ? T_2 extends readonly [Layer.Layer.Any, ...Layer.Layer.Any[]] ? { [k_2 in keyof T_2]: Layer.Layer.Context<T_2[k_2]>; }[number] : never : never : never) | Exclude<import("@effect-app/infra/api/routing").MakeContext<Make>, Make["dependencies"] extends infer T_3 ? T_3 extends Make["dependencies"] ? T_3 extends readonly [Layer.Layer.Any, ...Layer.Layer.Any[]] ? { [k_3 in keyof T_3]: Layer.Layer.Success<T_3[k_3]>; }[number] : never : never : never>>;
+    };
+    <const Make extends {
+        dependencies: import("effect-app").Array<Layer.Layer.Any>;
+        effect: Effect<{ [K in keyof { [K in keyof Rsc as Rsc[K] extends import("@effect-app/infra/api/routing").AnyRequestModule ? K : never]: Rsc[K]; }]: import("@effect-app/infra/api/routing").Handler<Rsc[K], any, any>; }, any, Make["strict"] extends false ? any : Make["dependencies"] extends infer T ? T extends Make["dependencies"] ? T extends readonly [Layer.Layer.Any, ...Layer.Layer.Any[]] ? { [k in keyof T]: Layer.Layer.Success<T[k]>; }[number] : never : never : never>;
+        strict?: boolean;
+        readonly ಠ_ಠ: never;
+    }>(make: Make): {
+        moduleName: ModuleName;
+        Router: import("@effect/platform/HttpRouter").HttpRouter.TagClass<import("@effect-app/infra/api/routing").RouterShape<Rsc>, `${ModuleName}Router`, never, Exclude<[{ [K_1 in keyof { [K in keyof Rsc as Rsc[K] extends import("@effect-app/infra/api/routing").AnyRequestModule ? K : never]: Rsc[K]; }]: Rpc.Rpc<Rsc[K_1], import("@effect-app/infra/api/routing")._R<ReturnType<import("@effect-app/infra/api/routing").MakeHandlers<Make, { [K in keyof Rsc as Rsc[K] extends import("@effect-app/infra/api/routing").AnyRequestModule ? K : never]: Rsc[K]; }>[K_1]["handler"]>>>; }[keyof { [K in keyof Rsc as Rsc[K] extends import("@effect-app/infra/api/routing").AnyRequestModule ? K : never]: Rsc[K]; }]] extends [Rpc.Rpc<any, infer R>] ? R : never, import("@effect/platform/HttpRouter").HttpRouter.Provided>>;
+        routes: Layer.Layer<import("@effect-app/infra/api/routing").RouterShape<Rsc>, import("@effect-app/infra/api/routing").MakeErrors<Make> | (Make["dependencies"] extends infer T_1 ? T_1 extends Make["dependencies"] ? T_1 extends readonly [Layer.Layer.Any, ...Layer.Layer.Any[]] ? { [k_1 in keyof T_1]: Layer.Layer.Error<T_1[k_1]>; }[number] : never : never : never), (Make["dependencies"] extends infer T_2 ? T_2 extends Make["dependencies"] ? T_2 extends readonly [Layer.Layer.Any, ...Layer.Layer.Any[]] ? { [k_2 in keyof T_2]: Layer.Layer.Context<T_2[k_2]>; }[number] : never : never : never) | Exclude<import("@effect-app/infra/api/routing").MakeContext<Make>, Make["dependencies"] extends infer T_3 ? T_3 extends Make["dependencies"] ? T_3 extends readonly [Layer.Layer.Any, ...Layer.Layer.Any[]] ? { [k_3 in keyof T_3]: Layer.Layer.Success<T_3[k_3]>; }[number] : never : never : never>>;
+    };
+    <const Make extends {
+        dependencies: import("effect-app").Array<Layer.Layer.Any>;
+        effect: Effect<{ [K in keyof { [K in keyof Rsc as Rsc[K] extends import("@effect-app/infra/api/routing").AnyRequestModule ? K : never]: Rsc[K]; }]: import("@effect-app/infra/api/routing").Handler<Rsc[K], any, any>; }, any, Make["strict"] extends false ? any : Make["dependencies"] extends infer T ? T extends Make["dependencies"] ? T extends readonly [Layer.Layer.Any, ...Layer.Layer.Any[]] ? { [k in keyof T]: Layer.Layer.Success<T[k]>; }[number] : never : never : never>;
+        strict?: boolean;
+        readonly ಠ_ಠ: never;
+    }>(make: Make): {
+        moduleName: ModuleName;
+        Router: import("@effect/platform/HttpRouter").HttpRouter.TagClass<import("@effect-app/infra/api/routing").RouterShape<Rsc>, `${ModuleName}Router`, never, Exclude<[{ [K_1 in keyof { [K in keyof Rsc as Rsc[K] extends import("@effect-app/infra/api/routing").AnyRequestModule ? K : never]: Rsc[K]; }]: Rpc.Rpc<Rsc[K_1], import("@effect-app/infra/api/routing")._R<ReturnType<import("@effect-app/infra/api/routing").MakeHandlers<Make, { [K in keyof Rsc as Rsc[K] extends import("@effect-app/infra/api/routing").AnyRequestModule ? K : never]: Rsc[K]; }>[K_1]["handler"]>>>; }[keyof { [K in keyof Rsc as Rsc[K] extends import("@effect-app/infra/api/routing").AnyRequestModule ? K : never]: Rsc[K]; }]] extends [Rpc.Rpc<any, infer R>] ? R : never, import("@effect/platform/HttpRouter").HttpRouter.Provided>>;
+        routes: Layer.Layer<import("@effect-app/infra/api/routing").RouterShape<Rsc>, import("@effect-app/infra/api/routing").MakeErrors<Make> | (Make["dependencies"] extends infer T_1 ? T_1 extends Make["dependencies"] ? T_1 extends readonly [Layer.Layer.Any, ...Layer.Layer.Any[]] ? { [k_1 in keyof T_1]: Layer.Layer.Error<T_1[k_1]>; }[number] : never : never : never), (Make["dependencies"] extends infer T_2 ? T_2 extends Make["dependencies"] ? T_2 extends readonly [Layer.Layer.Any, ...Layer.Layer.Any[]] ? { [k_2 in keyof T_2]: Layer.Layer.Context<T_2[k_2]>; }[number] : never : never : never) | Exclude<import("@effect-app/infra/api/routing").MakeContext<Make>, Make["dependencies"] extends infer T_3 ? T_3 extends Make["dependencies"] ? T_3 extends readonly [Layer.Layer.Any, ...Layer.Layer.Any[]] ? { [k_3 in keyof T_3]: Layer.Layer.Success<T_3[k_3]>; }[number] : never : never : never>>;
+    };
+    <const Make extends {
+        dependencies: import("effect-app").Array<Layer.Layer.Any>;
+        effect: Effect<{ [K in keyof { [K in keyof Rsc as Rsc[K] extends import("@effect-app/infra/api/routing").AnyRequestModule ? K : never]: Rsc[K]; }]: import("@effect-app/infra/api/routing").Handler<Rsc[K], any, any>; }, any, Make["dependencies"] extends infer T ? T extends Make["dependencies"] ? T extends readonly [Layer.Layer.Any, ...Layer.Layer.Any[]] ? { [k in keyof T]: Layer.Layer.Success<T[k]>; }[number] : never : never : never>;
+        strict?: boolean;
+        readonly ಠ_ಠ: never;
+    }>(make: Make): {
+        moduleName: ModuleName;
+        Router: import("@effect/platform/HttpRouter").HttpRouter.TagClass<import("@effect-app/infra/api/routing").RouterShape<Rsc>, `${ModuleName}Router`, never, Exclude<[{ [K_1 in keyof { [K in keyof Rsc as Rsc[K] extends import("@effect-app/infra/api/routing").AnyRequestModule ? K : never]: Rsc[K]; }]: Rpc.Rpc<Rsc[K_1], import("@effect-app/infra/api/routing")._R<ReturnType<import("@effect-app/infra/api/routing").MakeHandlers<Make, { [K in keyof Rsc as Rsc[K] extends import("@effect-app/infra/api/routing").AnyRequestModule ? K : never]: Rsc[K]; }>[K_1]["handler"]>>>; }[keyof { [K in keyof Rsc as Rsc[K] extends import("@effect-app/infra/api/routing").AnyRequestModule ? K : never]: Rsc[K]; }]] extends [Rpc.Rpc<any, infer R>] ? R : never, import("@effect/platform/HttpRouter").HttpRouter.Provided>>;
+        routes: Layer.Layer<import("@effect-app/infra/api/routing").RouterShape<Rsc>, import("@effect-app/infra/api/routing").MakeErrors<Make> | (Make["dependencies"] extends infer T_1 ? T_1 extends Make["dependencies"] ? T_1 extends readonly [Layer.Layer.Any, ...Layer.Layer.Any[]] ? { [k_1 in keyof T_1]: Layer.Layer.Error<T_1[k_1]>; }[number] : never : never : never), (Make["dependencies"] extends infer T_2 ? T_2 extends Make["dependencies"] ? T_2 extends readonly [Layer.Layer.Any, ...Layer.Layer.Any[]] ? { [k_2 in keyof T_2]: Layer.Layer.Context<T_2[k_2]>; }[number] : never : never : never) | Exclude<import("@effect-app/infra/api/routing").MakeContext<Make>, Make["dependencies"] extends infer T_3 ? T_3 extends Make["dependencies"] ? T_3 extends readonly [Layer.Layer.Any, ...Layer.Layer.Any[]] ? { [k_3 in keyof T_3]: Layer.Layer.Success<T_3[k_3]>; }[number] : never : never : never>>;
+    };
+    <const Make extends {
+        dependencies: import("effect-app").Array<Layer.Layer.Any>;
+        effect: Effect<{ [K in keyof { [K in keyof Rsc as Rsc[K] extends import("@effect-app/infra/api/routing").AnyRequestModule ? K : never]: Rsc[K]; }]: import("@effect-app/infra/api/routing").Handler<Rsc[K], any, any>; }, any, Make["dependencies"] extends infer T ? T extends Make["dependencies"] ? T extends readonly [Layer.Layer.Any, ...Layer.Layer.Any[]] ? { [k in keyof T]: Layer.Layer.Success<T[k]>; }[number] : never : never : never>;
+        strict?: boolean;
+    }>(make: Make): {
+        moduleName: ModuleName;
+        Router: import("@effect/platform/HttpRouter").HttpRouter.TagClass<import("@effect-app/infra/api/routing").RouterShape<Rsc>, `${ModuleName}Router`, never, Exclude<[{ [K_1 in keyof { [K in keyof Rsc as Rsc[K] extends import("@effect-app/infra/api/routing").AnyRequestModule ? K : never]: Rsc[K]; }]: Rpc.Rpc<Rsc[K_1], import("@effect-app/infra/api/routing")._R<ReturnType<import("@effect-app/infra/api/routing").MakeHandlers<Make, { [K in keyof Rsc as Rsc[K] extends import("@effect-app/infra/api/routing").AnyRequestModule ? K : never]: Rsc[K]; }>[K_1]["handler"]>>>; }[keyof { [K in keyof Rsc as Rsc[K] extends import("@effect-app/infra/api/routing").AnyRequestModule ? K : never]: Rsc[K]; }]] extends [Rpc.Rpc<any, infer R>] ? R : never, import("@effect/platform/HttpRouter").HttpRouter.Provided>>;
+        routes: Layer.Layer<import("@effect-app/infra/api/routing").RouterShape<Rsc>, import("@effect-app/infra/api/routing").MakeErrors<Make> | (Make["dependencies"] extends infer T_1 ? T_1 extends Make["dependencies"] ? T_1 extends readonly [Layer.Layer.Any, ...Layer.Layer.Any[]] ? { [k_1 in keyof T_1]: Layer.Layer.Error<T_1[k_1]>; }[number] : never : never : never), (Make["dependencies"] extends infer T_2 ? T_2 extends Make["dependencies"] ? T_2 extends readonly [Layer.Layer.Any, ...Layer.Layer.Any[]] ? { [k_2 in keyof T_2]: Layer.Layer.Context<T_2[k_2]>; }[number] : never : never : never) | Exclude<import("@effect-app/infra/api/routing").MakeContext<Make>, Make["dependencies"] extends infer T_3 ? T_3 extends Make["dependencies"] ? T_3 extends readonly [Layer.Layer.Any, ...Layer.Layer.Any[]] ? { [k_3 in keyof T_3]: Layer.Layer.Success<T_3[k_3]>; }[number] : never : never : never>>;
+    };
+    <const Make extends {
+        dependencies: [...Make["dependencies"], ...Exclude<Effect.Effect.Context<Make["effect"]>, import("effect/Types").Contravariant.Type<import("@effect-app/infra/api/routing").MakeDeps<Make>[typeof Layer.LayerTypeId]["_ROut"]>> extends never ? [] : [Layer.Layer<Exclude<Effect.Effect.Context<Make["effect"]>, import("effect/Types").Contravariant.Type<import("@effect-app/infra/api/routing").MakeDeps<Make>[typeof Layer.LayerTypeId]["_ROut"]>>, never, never>]];
+        effect: Effect<{ [K in keyof { [K in keyof Rsc as Rsc[K] extends import("@effect-app/infra/api/routing").AnyRequestModule ? K : never]: Rsc[K]; }]: import("@effect-app/infra/api/routing").Handler<Rsc[K], any, any>; }, any, any>;
+        strict?: boolean;
+    }>(make: Make): {
+        moduleName: ModuleName;
+        Router: import("@effect/platform/HttpRouter").HttpRouter.TagClass<import("@effect-app/infra/api/routing").RouterShape<Rsc>, `${ModuleName}Router`, never, never>;
+        routes: any;
+    };
+} & import("@effect-app/infra/api/routing").RouteMatcher<CTXMap, Rsc, HttpServerRequest.HttpServerRequest> & {
+    router: import("@effect-app/infra/api/routing").AddAction<{ [K in keyof Rsc as Rsc[K] extends import("@effect-app/infra/api/routing").AnyRequestModule ? K : never]: Rsc[K]; }[keyof { [K in keyof Rsc as Rsc[K] extends import("@effect-app/infra/api/routing").AnyRequestModule ? K : never]: Rsc[K]; }], {}>;
+    router2: { [K in keyof Rsc as Rsc[K] extends import("@effect-app/infra/api/routing").AnyRequestModule ? K : never]: Rsc[K]; } extends infer T extends Record<string, import("@effect-app/infra/api/routing").AnyRequestModule> ? { [K in keyof T]: import("@effect-app/infra/api/routing").Method<{ [K in keyof Rsc as Rsc[K] extends import("@effect-app/infra/api/routing").AnyRequestModule ? K : never]: Rsc[K]; }, K, "d", {}>; } : never;
+};
+export type RequestConfig = {
+    /** Disable authentication requirement */
+    allowAnonymous?: true;
+    /** Control the roles that are required to access the resource */
+    allowRoles?: readonly string[];
+};
+export declare const Req: <Self>() => {
+    <Tag extends string, Payload extends S.Struct.Fields, C extends {
+        success: S.Schema.Any | S.Struct.Fields;
+        failure: S.Schema.Any | S.Struct.Fields;
+    }>(tag: Tag, fields: Payload, config: RequestConfig & C): S.TaggedRequestClass<Self, Tag, {
+        readonly _tag: S.tag<Tag>;
+    } & Payload, (RequestConfig & C)["success"] extends infer T ? T extends (RequestConfig & C)["success"] ? T extends import("effect/Schema").Struct.Fields ? S.TypeLiteral<T, []> : T extends S.Schema.Any ? T : never : never : never, ([((RequestConfig & C)["failure"] extends infer T_1 ? T_1 extends (RequestConfig & C)["failure"] ? T_1 extends import("effect/Schema").Struct.Fields ? S.TypeLiteral<T_1, []> : T_1 extends S.Schema.Any ? T_1 : never : never : never) | import("effect-app/client").GetEffectError<CTXMap, C>] extends [never] ? [] : [((RequestConfig & C)["failure"] extends infer T_1 ? T_1 extends (RequestConfig & C)["failure"] ? T_1 extends import("effect/Schema").Struct.Fields ? S.TypeLiteral<T_1, []> : T_1 extends S.Schema.Any ? T_1 : never : never : never) | import("effect-app/client").GetEffectError<CTXMap, C>]) extends infer T_2 ? T_2 extends ([((RequestConfig & C)["failure"] extends infer T_1 ? T_1 extends (RequestConfig & C)["failure"] ? T_1 extends import("effect/Schema").Struct.Fields ? S.TypeLiteral<T_1, []> : T_1 extends S.Schema.Any ? T_1 : never : never : never) | import("effect-app/client").GetEffectError<CTXMap, C>] extends [never] ? [] : [((RequestConfig & C)["failure"] extends infer T_1 ? T_1 extends (RequestConfig & C)["failure"] ? T_1 extends import("effect/Schema").Struct.Fields ? S.TypeLiteral<T_1, []> : T_1 extends S.Schema.Any ? T_1 : never : never : never) | import("effect-app/client").GetEffectError<CTXMap, C>]) ? T_2 extends readonly S.Schema.All[] ? S.Union<T_2> : typeof S.Never : never : never> & {
+        config: Omit<C, "success" | "failure">;
+    };
+    <Tag extends string, Payload_1 extends S.Struct.Fields, C_1 extends {
+        success: S.Schema.Any | S.Struct.Fields;
+    }>(tag: Tag, fields: Payload_1, config: RequestConfig & C_1): S.TaggedRequestClass<Self, Tag, {
+        readonly _tag: S.tag<Tag>;
+    } & Payload_1, (RequestConfig & C_1)["success"] extends infer T ? T extends (RequestConfig & C_1)["success"] ? T extends import("effect/Schema").Struct.Fields ? S.TypeLiteral<T, []> : T extends S.Schema.Any ? T : never : never : never, ([import("effect-app/client").GetEffectError<CTXMap, C_1>] extends [never] ? [] : [import("effect-app/client").GetEffectError<CTXMap, C_1>]) extends infer T_1 ? T_1 extends ([import("effect-app/client").GetEffectError<CTXMap, C_1>] extends [never] ? [] : [import("effect-app/client").GetEffectError<CTXMap, C_1>]) ? T_1 extends readonly S.Schema.All[] ? S.Union<T_1> : typeof S.Never : never : never> & {
+        config: Omit<C_1, "success" | "failure">;
+    };
+    <Tag extends string, Payload_2 extends S.Struct.Fields, C_2 extends {
+        failure: S.Schema.Any | S.Struct.Fields;
+    }>(tag: Tag, fields: Payload_2, config: RequestConfig & C_2): S.TaggedRequestClass<Self, Tag, {
+        readonly _tag: S.tag<Tag>;
+    } & Payload_2, typeof S.Void, ([((RequestConfig & C_2)["failure"] extends infer T ? T extends (RequestConfig & C_2)["failure"] ? T extends import("effect/Schema").Struct.Fields ? S.TypeLiteral<T, []> : T extends S.Schema.Any ? T : never : never : never) | import("effect-app/client").GetEffectError<CTXMap, C_2>] extends [never] ? [] : [((RequestConfig & C_2)["failure"] extends infer T ? T extends (RequestConfig & C_2)["failure"] ? T extends import("effect/Schema").Struct.Fields ? S.TypeLiteral<T, []> : T extends S.Schema.Any ? T : never : never : never) | import("effect-app/client").GetEffectError<CTXMap, C_2>]) extends infer T_1 ? T_1 extends ([((RequestConfig & C_2)["failure"] extends infer T ? T extends (RequestConfig & C_2)["failure"] ? T extends import("effect/Schema").Struct.Fields ? S.TypeLiteral<T, []> : T extends S.Schema.Any ? T : never : never : never) | import("effect-app/client").GetEffectError<CTXMap, C_2>] extends [never] ? [] : [((RequestConfig & C_2)["failure"] extends infer T ? T extends (RequestConfig & C_2)["failure"] ? T extends import("effect/Schema").Struct.Fields ? S.TypeLiteral<T, []> : T extends S.Schema.Any ? T : never : never : never) | import("effect-app/client").GetEffectError<CTXMap, C_2>]) ? T_1 extends readonly S.Schema.All[] ? S.Union<T_1> : typeof S.Never : never : never> & {
+        config: Omit<C_2, "success" | "failure">;
+    };
+    <Tag extends string, Payload_3 extends S.Struct.Fields, C_3 extends Record<string, any>>(tag: Tag, fields: Payload_3, config: C_3 & RequestConfig): S.TaggedRequestClass<Self, Tag, {
+        readonly _tag: S.tag<Tag>;
+    } & Payload_3, typeof S.Void, ([import("effect-app/client").GetEffectError<CTXMap, C_3>] extends [never] ? [] : [import("effect-app/client").GetEffectError<CTXMap, C_3>]) extends infer T ? T extends ([import("effect-app/client").GetEffectError<CTXMap, C_3>] extends [never] ? [] : [import("effect-app/client").GetEffectError<CTXMap, C_3>]) ? T extends readonly S.Schema.All[] ? S.Union<T> : typeof S.Never : never : never> & {
+        config: Omit<C_3, "success" | "failure">;
+    };
+    <Tag extends string, Payload_4 extends S.Struct.Fields>(tag: Tag, fields: Payload_4): S.TaggedRequestClass<Self, Tag, {
+        readonly _tag: S.tag<Tag>;
+    } & Payload_4, typeof S.Void, never>;
+};
+declare const GetSomething_base: S.TaggedRequestClass<GetSomething, "GetSomething", {
+    readonly _tag: S.tag<"GetSomething">;
+} & {
+    id: typeof S.String;
+}, typeof S.Void, S.Union<[typeof UnauthorizedError]>> & {
+    config: Omit<{
+        success: typeof S.Void;
+    }, "success" | "failure">;
+};
+export declare class GetSomething extends GetSomething_base {
+}
+declare const GetSomethingElse_base: S.TaggedRequestClass<GetSomethingElse, "GetSomethingElse", {
+    readonly _tag: S.tag<"GetSomethingElse">;
+} & {
+    id: typeof S.String;
+}, typeof S.String, S.Union<[typeof UnauthorizedError]>> & {
+    config: Omit<{
+        success: typeof S.String;
+    }, "success" | "failure">;
+};
+export declare class GetSomethingElse extends GetSomethingElse_base {
+}
+declare const SomethingService_base: import("effect/Effect").Service.Class<SomethingService, "SomethingService", {
+    readonly dependencies: readonly [];
+    readonly effect: Effect.Effect<{}, never, never>;
+}>;
+export declare class SomethingService extends SomethingService_base {
+}
+declare const SomethingRepo_base: import("effect/Effect").Service.Class<SomethingRepo, "SomethingRepo", {
+    readonly dependencies: readonly [Layer.Layer<SomethingService, never, never>];
+    readonly effect: Effect.Effect<{}, never, SomethingService>;
+}>;
+export declare class SomethingRepo extends SomethingRepo_base {
+}
+declare const SomethingService2_base: import("effect/Effect").Service.Class<SomethingService2, "SomethingService2", {
+    readonly dependencies: readonly [];
+    readonly effect: Effect.Effect<{}, never, never>;
+}>;
+export declare class SomethingService2 extends SomethingService2_base {
+}
+export {};
+//# sourceMappingURL=controller.test%20copy.d.ts.map

package/test/dist/controller.test copy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"controller.test copy.d.ts","sourceRoot":"","sources":["../controller.test copy.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAA;AACtE,OAAO,EAAE,GAAG,EAAE,MAAM,aAAa,CAAA;AAEjC,OAAO,EAAW,MAAM,EAAY,KAAK,EAAE,CAAC,EAAY,MAAM,YAAY,CAAA;AAC1E,OAAO,EAAwC,KAAK,aAAa,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAC/G,OAAO,EAAe,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAOhE,MAAM,WAAW,GAAG;IAClB,OAAO,EAAE,cAAc,CAAA;CACxB;AAED,MAAM,MAAM,MAAM,GAAG;IAGnB,YAAY,EAAE,aAAa,CAAC,MAAM,CAAC,EAAE,EAAE,KAAK,EAAE,OAAO,iBAAiB,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAAA;CACvF,CAAA;AAmGD,eAAO,MAAQ,QAAQ;;;;;sBA2DnB,KACH;;;;;;GA5DwB,QAAQ;;;;;;uDAmG8B,KAAK,CAAC,GAAG;;;;;;;;;;uDAAkyD,KAAK,CAAC,GAAG;;;;;;;;;;uDAAkyD,KAAK,CAAC,GAAG;;;;;;;;;;uDAAkyD,KAAK,CAAC,GAAG;;;;;;;;;;uDAA6vD,KAAK,CAAC,GAAG;;;;;;;;;;;;;;;;;;;;CAnG7oO,CAAA;AAElE,MAAM,MAAM,aAAa,GAAG;IAC1B,yCAAyC;IACzC,cAAc,CAAC,EAAE,IAAI,CAAA;IACrB,iEAAiE;IACjE,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAC/B,CAAA;AACD,eAAO,MAAuB,GAAG;2CAxEM,MAAM,CAAC,MAAM;mBAgC1C,MA9BA,CAAC,GAAG,KA8BJ,MA5BD,CA4BC,MA5BM;mBA4BN,MA3BC,CAAE,GAAE,KAAM,MAAK,CAAC,MAAM;;;;;;6CASqB,MAAM,CAAC,MAAM;mBACtD,MAAK,CAAC,GAAG,KAAK,MAAM,CAAC,MAAM;;;;;;6CAUpB,MAAM,CAAC,MAAM;mBACG,MAAM,CAAC,GAAG,KAAK,MAAM,CAAE,MAAK;;;;;;6CAclD,MAAG,CAAC,MAAM;;;;;6CAMwC,MAAM,CAAC,MACrE;;;CA4BA,CAAA;;;;;;;;;;AAEF,qBAAa,YAAa,SAAQ,iBAEX;CAAG;;;;;;;;;;AAE1B,qBAAa,gBAAiB,SAAQ,qBAEb;CAAG;;;;;AAI5B,qBAAa,gBAAiB,SAAQ,qBAKpC;CAAG;;;;;AASL,qBAAa,aAAc,SAAQ,kBAOjC;CAAG;;;;;AAEL,qBAAa,iBAAkB,SAAQ,sBAKrC;CAAG"}