@silkweave/nestjs 2.4.0 → 2.6.0

package/build/index.d.mts

@@ -1,197 +1,14 @@
+import { _ as reflectDtoFields, a as OpenApiDocument, b as unreflectedFields, c as openApiFields, d as classValidatorToField, f as designTypeToField, g as openapiSchemaToField, h as normalizeEnum, i as SilkweaveModuleOptions, l as FieldDesc, m as mergeField, n as NestSilkweaveAdapter, o as OpenApiLookup, p as fieldToZod, r as SILKWEAVE_MODULE_OPTIONS, s as buildOpenApiLookup, t as NestAdapterRegisterContext, u as apiPropertyToField, v as swaggerParamToField, y as typeTokenToBase } from "./types-wmI5n_7i.mjs";
 import { CanActivate, DynamicModule, MiddlewareConsumer, NestModule, Type } from "@nestjs/common";
 import { ApplicationConfig, DiscoveryService, HttpAdapterHost, MetadataScanner, ModuleRef, Reflector } from "@nestjs/core";
-import { Action, SilkweaveContext, SilkweaveOptions } from "@silkweave/core";
+import { Action } from "@silkweave/core";
 import { z } from "zod/v4";
-import { AuthConfig } from "@silkweave/auth";
-import { CorsOptions } from "cors";
 
-//#region src/lib/reflect/schema.d.ts
-/**
- * A transport-neutral description of a single input field. Every metadata
- * source (swagger decorators, class-validator, an OpenAPI document, TypeScript
- * `design:type`) is mapped to this shape, the shapes are merged by precedence,
- * and the result is converted to Zod once. Keeping a single intermediate keeps
- * the per-source mappers small and the Zod construction in one place.
- */
-interface FieldDesc {
-  type?: 'string' | 'number' | 'integer' | 'boolean' | 'array' | 'object' | 'unknown';
-  required?: boolean;
-  description?: string;
-  enum?: (string | number)[];
-  items?: FieldDesc;
-  min?: number;
-  max?: number;
-  minLength?: number;
-  maxLength?: number;
-  format?: string;
-  default?: unknown;
-}
-/** Merge `over` onto `base` - defined keys of `over` win. */
-declare function mergeField(base: FieldDesc, over: FieldDesc): FieldDesc;
-/** Convert a merged {@link FieldDesc} to a Zod schema. */
-declare function fieldToZod(d: FieldDesc): z.ZodType;
-/** Normalise a TS-enum object or an array literal to a flat value list. */
-declare function normalizeEnum(value: unknown): (string | number)[] | undefined;
-/** Map a swagger/`design:type` type token (constructor, `[Type]`, or string) to a base type. */
-declare function typeTokenToBase(type: unknown): FieldDesc['type'] | undefined;
-/** From the constructor TypeScript emits via `emitDecoratorMetadata`. */
-declare function designTypeToField(ctor: unknown): FieldDesc;
-/** From an `@ApiParam`/`@ApiQuery` entry stored under `swagger/apiParameters`. */
-declare function swaggerParamToField(p: Record<string, any>): FieldDesc;
-/** From an `@ApiProperty` options object stored under `swagger/apiModelProperties`. */
-declare function apiPropertyToField(o: Record<string, any>): FieldDesc;
-/** From an array of `class-validator` validation-metadata entries for one property. */
-declare function classValidatorToField(metas: Array<{
-  type?: string;
-  name?: string;
-  constraints?: unknown[];
-}>): FieldDesc;
-/** From an OpenAPI Schema Object (used by both the doc and `@ApiParam({ schema })`). */
-declare function openapiSchemaToField(schema: Record<string, any>): FieldDesc;
-/**
- * Reflect a whole-DTO class (`@Body() dto: CreateDto`) into per-property
- * {@link FieldDesc}s. Property names are the union of `@ApiProperty` and
- * `class-validator` decorated fields; each field merges `design:type` (base),
- * then `class-validator` constraints, then `@ApiProperty` (highest). Properties
- * default to required unless a source marks them optional.
- */
-declare function reflectDtoFields(dtoType: any): Record<string, FieldDesc>;
-//#endregion
-//#region src/lib/reflect/openapi.d.ts
-/**
- * A minimal view of an OpenAPI document - the subset we read. Matches the shape
- * `SwaggerModule.createDocument()` returns, but typed loosely so callers can
- * pass any compatible object without a hard `@nestjs/swagger` dependency.
- */
-interface OpenApiDocument {
-  paths?: Record<string, Record<string, any>>;
-  components?: {
-    schemas?: Record<string, any>;
-  };
-}
-interface OpenApiLookup {
-  doc: OpenApiDocument;
-  /** `${METHOD} ${path}` → operation object. */
-  operations: Map<string, any>;
-}
-/** Index a document's operations by `${METHOD} ${path}` for fast matching. */
-declare function buildOpenApiLookup(doc: OpenApiDocument): OpenApiLookup;
-/**
- * Resolve the per-field descriptors for a route from an ingested OpenAPI
- * document. Merges `parameters` (path/query/header) and the JSON request-body
- * schema's properties into a single field map. Returns `{}` when the operation
- * isn't found - callers fall back to decorator reflection.
- */
-declare function openApiFields(lookup: OpenApiLookup, method: string, openapiPath: string): Record<string, FieldDesc>;
-//#endregion
-//#region src/lib/types.d.ts
-/**
- * Context passed to a Nest Silkweave adapter when `SilkweaveModule` wires it
- * up. Adapters register their routes directly on `httpAdapter` (no
- * placeholder middleware, no `silkweave()` builder), so they only fire
- * `register()` once and own the rest of their lifecycle implicitly through
- * Nest.
- */
-interface NestAdapterRegisterContext {
-  /** Nest's underlying HTTP adapter (Express or Fastify). */
-  httpAdapter: NonNullable<HttpAdapterHost['httpAdapter']>;
-  /** Identity the adapter surfaces to clients (e.g. MCP server name). */
-  silkweaveOptions: SilkweaveOptions;
-  /** Per-adapter context - already forked with `{ adapter: adapter.name, ...userContext }`. */
-  baseContext: SilkweaveContext;
-  /** Actions filtered to those enabled on this adapter. */
-  actions: Action[];
-}
-/**
- * A Silkweave Nest adapter. Each transport (REST, tRPC, MCP) implements this
- * shape. `register()` is called from `SilkweaveModule.configure()` - which
- * runs *before* Nest's controller routes are mapped - so adapter routes
- * always sit ahead of any catch-all controllers in the framework's request
- * pipeline.
- */
-interface NestSilkweaveAdapter {
-  /** Adapter discriminator - set on the silkweave context as `ctx.get('adapter')`. */
-  readonly name: 'mcp';
-  /** URL prefix the adapter mounts on (e.g. `'/mcp'`). Surfaced for introspection. */
-  readonly basePath?: string;
-  /**
-   * When `true`, the adapter receives every discovered action regardless of
-   * each action's `isEnabled` gate. Reserved for non-runtime adapters that need
-   * the entire action surface.
-   */
-  readonly allActions?: boolean;
-  /** Register this adapter's routes on Nest's HTTP server. */
-  register(ctx: NestAdapterRegisterContext): void;
-}
-interface SilkweaveModuleOptions {
-  /** Identity for the silkweave instance - surfaced to MCP clients, OpenAPI, etc. */
-  silkweave: SilkweaveOptions;
-  /** Adapters to mount. Currently `mcp()`. */
-  adapters: NestSilkweaveAdapter[];
-  /** Initial context keys merged into every adapter's `baseContext`. */
-  context?: Record<string, unknown>;
-  /**
-   * Optional OpenAPI document (e.g. from `SwaggerModule.createDocument(app, cfg)`)
-   * used as an authoritative source when reflecting `@Mcp` tool input schemas.
-   * Matched to each method by HTTP verb + path; falls back to decorator
-   * reflection when an operation or field isn't present.
-   */
-  openapi?: OpenApiDocument;
-  /**
-   * Opt-in allow-list of app-global guard classes (registered via
-   * `app.useGlobalGuards()` or `{ provide: APP_GUARD, useClass }`) to run on
-   * every MCP tool call, before each method/class `@UseGuards`. Listed by
-   * class - a blanket "run all globals" is deliberately not offered, since
-   * unrelated globals (e.g. a `ThrottlerGuard` that needs a writable response)
-   * would misbehave over MCP. Empty/omitted ⇒ no global guards run.
-   *
-   * Note: over MCP the request stand-in is headers-only (`params`/`query` are
-   * empty), so per-session or IP-derived guard logic won't apply; header-based
-   * authentication still works.
-   */
-  globalGuards?: Type<CanActivate>[];
-  /**
-   * Default MCP result format for every `@Mcp` tool - `'json'` (compact JSON,
-   * `jsonToolResult`) or `'smart'` (inline small / embedded-resource large,
-   * `smartToolResult`). Defaults to `'smart'`. A per-method `@Mcp({ result })`
-   * overrides this, and a client's per-call `_meta.disposition` overrides both.
-   */
-  defaultResult?: 'json' | 'smart';
-}
-declare const SILKWEAVE_MODULE_OPTIONS = "__silkweave_module_options__";
-//#endregion
-//#region src/adapter/mcp.d.ts
-interface McpAdapterOptions {
-  /** URL prefix the MCP namespace lives under - the transport itself is at this exact path. Default `'/mcp'`. */
-  basePath?: string;
-  /** Optional bearer-token / OAuth 2.1 config. */
-  auth?: AuthConfig;
-  /** CORS configuration. `false` to disable, `true`/omitted for permissive defaults, or a `CorsOptions` object. */
-  cors?: CorsOptions | boolean;
-  /** Mount the sideload resource route at `${basePath}/resource/:id`. Default `true`. */
-  sideloadResources?: boolean;
-  /** Directory the sideload route reads from. Default `'resources'`. */
-  resourceDir?: string;
-}
-/**
- * MCP adapter for `@silkweave/nestjs`. Registers the MCP Streamable HTTP
- * transport, sideload, well-known and OAuth routes individually on Nest's
- * HTTP adapter at the configured `basePath` (default `/mcp`):
- *
- * - `POST/GET/DELETE ${basePath}` - Streamable HTTP transport
- * - `GET ${basePath}/resource/:id` - sideload (`sideloadResources` opt-out)
- * - `GET ${basePath}/.well-known/oauth-protected-resource` - RFC 9728 metadata (when `auth.resourceUrl`/`auth.authorizationServers` set)
- * - `GET ${basePath}/authorize`, `POST ${basePath}/token`, `POST ${basePath}/register`, `GET ${basePath}${callbackPath}` (when `auth.provider` set)
- *
- * Each route is a real Nest-level route - they show up in
- * `RoutesResolver`'s log and there is no sub-app or middleware-slot
- * indirection.
- */
-declare function mcp(options?: McpAdapterOptions): NestSilkweaveAdapter;
-//#endregion
 //#region src/lib/metadata.d.ts
 /** Reflect-metadata key carrying `@Mcp` options on a controller method. */
 declare const MCP_METADATA = "__silkweave_mcp__";
+/** Reflect-metadata key carrying `@Trpc` options on a controller method. */
+declare const TRPC_METADATA = "__silkweave_trpc__";
 /**
  * Options for the `@Mcp()` method decorator. Every field is optional - an empty
  * `@Mcp()` exposes the decorated controller route as an MCP tool with its name,
@@ -212,11 +29,16 @@ interface McpMetadata {
    */
   description?: string;
   /**
-   * Zod raw-shape override merged over the reflected input fields (override
-   * wins per field). The escape hatch for shapes reflection can't express
-   * losslessly - discriminated unions, custom validators, `@Transform`, etc.
+   * Zod override merged over the reflected input fields (override wins per
+   * field). Accepts either a raw shape (`{ field: z.string() }`) or a whole
+   * `z.object({ ... })` - the object's `.shape` is unwrapped. The escape hatch
+   * for shapes reflection can't express losslessly - discriminated unions,
+   * custom validators, `@Transform`, etc. Note it *adds to* the reflected
+   * fields; it does not replace them, so a field reflection silently dropped
+   * (see the unreflectable-param warning) is not recovered by listing the
+   * others here.
    */
-  input?: Record<string, z.ZodType>;
+  input?: Record<string, z.ZodType> | z.ZodObject;
   /**
    * Whether to apply the controller method's parameter-bound pipes
    * (`@Param('id', ParseIntPipe)`) when re-binding the call. Default `'apply'`.
@@ -233,6 +55,65 @@ interface McpMetadata {
    */
   result?: 'json' | 'smart';
 }
+/** tRPC procedure kind for a `@Trpc`-decorated route. */
+type TrpcKind = 'query' | 'mutation' | 'subscription';
+/**
+ * Options for the `@Trpc()` method decorator - the tRPC sibling of `@Mcp`. An
+ * empty `@Trpc()` exposes the decorated controller route as a tRPC procedure
+ * with its key, input schema, and kind reflected from the route + parameter
+ * decorators + swagger/class-validator metadata (identically to `@Mcp`).
+ *
+ * Unlike MCP, tRPC carries precise *output* types into the generated router, so
+ * `@Trpc` adds an `output`/`chunk` hatch and a `kind` override on top of the
+ * shared reflection. The two decorators compose on the same method.
+ */
+interface TrpcMetadata {
+  /**
+   * Procedure-name override (before camelCasing). When unset it is derived from
+   * the controller class + method name (e.g. `UsersController.listBySpace` →
+   * `Users.listBySpace`, camelCased by the router to `usersListBySpace`).
+   */
+  name?: string;
+  /**
+   * Procedure description override. When unset it falls back to the method's
+   * `@ApiOperation({ summary | description })`, then a generated default.
+   */
+  description?: string;
+  /**
+   * Zod override merged over the reflected input fields (override wins per
+   * field). Accepts a raw shape (`{ field: z.string() }`) or a whole
+   * `z.object({ ... })` (its `.shape` is unwrapped). Same escape hatch as
+   * `@Mcp({ input })`.
+   */
+  input?: Record<string, z.ZodType> | z.ZodObject;
+  /**
+   * Explicit output schema driving the generated procedure's output type - a Zod
+   * type, a DTO class (reflected like `@ApiOkResponse`), or a raw shape (wrapped
+   * in `z.object`). Wins over `@ApiOkResponse` reflection. The biggest reason to
+   * set this is when the return shape can't be reflected losslessly from a DTO.
+   */
+  output?: z.ZodType | Type | Record<string, z.ZodType>;
+  /**
+   * Chunk schema for an async-generator route exposed as a tRPC **subscription**.
+   * A Zod type or a DTO class. Drives the emitted
+   * `TRPCSubscriptionProcedure<{ output }>` type. When unset the chunk type falls
+   * back to `unknown`.
+   */
+  chunk?: z.ZodType | Type;
+  /**
+   * Procedure kind. When unset it is inferred: an `async *` route ⇒
+   * `'subscription'`, a `@Get` route ⇒ `'query'`, anything else ⇒ `'mutation'`.
+   * Set this to expose a verb-less route (no `@Get`/`@Post`) as a query or
+   * subscription - `@Trpc({ kind })` works without an HTTP-verb decorator, so the
+   * route is served over tRPC (and/or MCP) without becoming a public REST route.
+   */
+  kind?: TrpcKind;
+  /**
+   * Whether to apply the method's parameter-bound pipes when re-binding the call.
+   * Default `'apply'`. Same semantics as `@Mcp({ pipes })`.
+   */
+  pipes?: 'apply' | 'skip';
+}
 //#endregion
 //#region src/decorator/mcp.d.ts
 /**
@@ -270,7 +151,48 @@ interface McpMetadata {
  */
 declare function Mcp(options?: McpMetadata): MethodDecorator;
 //#endregion
+//#region src/decorator/trpc.d.ts
+/**
+ * Method decorator that exposes a NestJS controller route as a **tRPC
+ * procedure** - the sibling of `@Mcp`. Like `@Mcp` it is additive and reflects
+ * the procedure's input from the method's own metadata (route + `@Param`/
+ * `@Query`/`@Body` + swagger/class-validator), so a single method can carry both
+ * `@Trpc()` and `@Mcp()` and `@UseGuards()`.
+ *
+ * Two things differ from MCP because tRPC consumers need them:
+ * - **kind** - inferred from the route (`@Get` ⇒ query, others ⇒ mutation) or an
+ *   `async *` body (⇒ subscription); override with `@Trpc({ kind })`.
+ * - **output** - the generated `AppRouter` carries precise output types. Drive
+ *   them with `@ApiOkResponse({ type: Dto })` reflection or `@Trpc({ output })`.
+ *
+ * `@Trpc()` works **without** an HTTP-verb decorator: with no `@Get`/`@Post` the
+ * route is never mapped as REST, so `@Trpc({ kind })` exposes it over tRPC (and
+ * `@Mcp` over MCP) while keeping it off the public REST surface.
+ *
+ * @example
+ * ```ts
+ * @Controller('users')
+ * export class UsersController {
+ *   @Get('list-by-space')
+ *   @ApiOperation({ summary: 'List users in a space' })
+ *   @ApiOkResponse({ type: ListUsersResponse })   // drives the output type
+ *   @UseGuards(AuthGuard)
+ *   @Trpc()                                        // → procedure `usersListBySpace` (query)
+ *   @Mcp()                                         // → MCP tool `UsersListBySpace`
+ *   listBySpace(@Query() q: ListBySpaceQuery, @Req() req: AppRequest) {
+ *     return this.service.list(req.user, q.spaceId)
+ *   }
+ * }
+ * ```
+ */
+declare function Trpc(options?: TrpcMetadata): MethodDecorator;
+//#endregion
 //#region src/lib/controllerDiscovery.d.ts
+interface DiscoverOptions {
+  openapi?: OpenApiDocument;
+  globalGuards?: Type<CanActivate>[];
+  defaultResult?: 'json' | 'smart';
+}
 declare class ControllerDiscovery {
   private readonly discovery;
   private readonly scanner;
@@ -279,17 +201,24 @@ declare class ControllerDiscovery {
   private readonly appConfig;
   constructor(discovery: DiscoveryService, scanner: MetadataScanner, reflector: Reflector, moduleRef: ModuleRef, appConfig: ApplicationConfig);
   /**
-   * Walk every Nest provider/controller, find methods annotated with `@Mcp`,
-   * and build a core `Action` per method whose input schema is reflected from
-   * the route + parameter decorators (+ optional OpenAPI document) and whose
-   * `run` re-binds the validated input back into the method's positional
-   * arguments (with `@UseGuards` guards - and any opted-in `globalGuards` -
-   * applied first).
+   * Walk every Nest provider/controller, find methods annotated with `@Mcp`
+   * and/or `@Trpc`, and build a core `Action` per decorator present on each
+   * method. The input schema is reflected from the route + parameter decorators
+   * (+ optional OpenAPI document) and the `run` re-binds the validated input back
+   * into the method's positional arguments (with `@UseGuards` guards applied
+   * first). A method carrying both decorators yields two actions - one gated to
+   * the `mcp` adapter, one to the `trpc`/`typegen` adapters - sharing the same
+   * reflected input, bindings, and guards.
    */
-  discover(openapi?: OpenApiDocument, globalGuards?: Type<CanActivate>[], defaultResult?: 'json' | 'smart'): Action[];
-  private toAction;
-  /** Build the merged Zod input shape and the per-argument re-bind plan. */
-  private buildInput;
+  discover(options?: DiscoverOptions): Action[];
+  /** Compute the per-method reflection shared by the `mcp` and `trpc` builders. */
+  private reflect;
+  /** Build a guard-application closure shared by both run shapes. */
+  private guardRunner;
+  /** Synthesize the MCP-targeted action (unchanged behavior from v2.4). */
+  private mcpAction;
+  /** Synthesize the tRPC-targeted action (kind/output/subscription + httpStatus errors). */
+  private trpcAction;
 }
 //#endregion
 //#region src/lib/guards.d.ts
@@ -377,7 +306,7 @@ interface RequestLike {
  * tool `input` (and the request stand-in for `@Req`/`@Headers`/...), then call
  * it. `applyParamPipes` controls whether parameter-bound pipes run.
  */
-declare function invokeRebound(method: (...args: any[]) => any, instance: object, input: Record<string, unknown>, bindings: Binding[], request: RequestLike | undefined, applyParamPipes: boolean): Promise<unknown>;
+declare function invokeRebound(method: (...args: any[]) => any, instance: object, input: Record<string, unknown>, bindings: Binding[], request: RequestLike | undefined, response: unknown, applyParamPipes: boolean): Promise<unknown>;
 /** Map a non-input parameter slot (`@Req`/`@Headers`/`@Ip`/...) to its runtime binding. */
 declare function specialBinding(paramtype: number, data: string | undefined): Binding | null;
 //#endregion
@@ -385,11 +314,12 @@ declare function specialBinding(paramtype: number, data: string | undefined): Bi
 /**
  * Root module for `@silkweave/nestjs`.
  *
- * Discovers every `@Mcp`-decorated **controller method** via `DiscoveryService`,
- * reflects each into a Silkweave action (input schema from the route + parameter
- * decorators + optional OpenAPI document; invocation by re-binding the validated
- * input back into the method), and registers the configured adapter(s) - `mcp()` -
- * directly on Nest's HTTP adapter inside `configure()`.
+ * Discovers every `@Mcp`/`@Trpc`-decorated **controller method** via
+ * `DiscoveryService`, reflects each into a Silkweave action (input schema from
+ * the route + parameter decorators + optional OpenAPI document; invocation by
+ * re-binding the validated input back into the method), and registers the
+ * configured adapter(s) - `mcp()`, `trpc()`, `typegen()` - directly on Nest's
+ * HTTP adapter inside `configure()`.
  *
  * Because `configure()` runs during `registerModules` - before Nest's
  * `registerRouter()` step - Silkweave's routes always sit ahead of every
@@ -419,5 +349,5 @@ declare class SilkweaveModule implements NestModule {
   configure(_consumer: MiddlewareConsumer): void;
 }
 //#endregion
-export { Binding, ControllerDiscovery, FieldDesc, MCP_METADATA, Mcp, McpAdapterOptions, McpMetadata, NestAdapterRegisterContext, NestSilkweaveAdapter, OpenApiDocument, OpenApiLookup, SILKWEAVE_MODULE_OPTIONS, SilkweaveModule, SilkweaveModuleOptions, apiPropertyToField, buildOpenApiLookup, classValidatorToField, collectGlobalGuards, collectGuards, designTypeToField, fieldToZod, invokeRebound, mcp, mergeField, normalizeEnum, openApiFields, openapiSchemaToField, reflectDtoFields, runGuards, specialBinding, swaggerParamToField, typeTokenToBase };
+export { Binding, ControllerDiscovery, DiscoverOptions, FieldDesc, MCP_METADATA, Mcp, McpMetadata, NestAdapterRegisterContext, NestSilkweaveAdapter, OpenApiDocument, OpenApiLookup, SILKWEAVE_MODULE_OPTIONS, SilkweaveModule, SilkweaveModuleOptions, TRPC_METADATA, Trpc, TrpcKind, TrpcMetadata, apiPropertyToField, buildOpenApiLookup, classValidatorToField, collectGlobalGuards, collectGuards, designTypeToField, fieldToZod, invokeRebound, mergeField, normalizeEnum, openApiFields, openapiSchemaToField, reflectDtoFields, runGuards, specialBinding, swaggerParamToField, typeTokenToBase, unreflectedFields };
 //# sourceMappingURL=index.d.mts.map

package/build/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/lib/reflect/schema.ts","../src/lib/reflect/openapi.ts","../src/lib/types.ts","../src/adapter/mcp.ts","../src/lib/metadata.ts","../src/decorator/mcp.ts","../src/lib/controllerDiscovery.ts","../src/lib/guards.ts","../src/lib/rebind.ts","../src/lib/silkweave.module.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/lib/metadata.ts","../src/decorator/mcp.ts","../src/decorator/trpc.ts","../src/lib/controllerDiscovery.ts","../src/lib/guards.ts","../src/lib/rebind.ts","../src/lib/silkweave.module.ts"],"mappings":";;;;;;;;cAIa,YAAA;;cAGA,aAAA;;AAHb;;;;;AAGA;;UAUiB,WAAA;EAVS;;AAU1B;;EAKE,IAAA;EAgByB;;;;EAXzB,WAAA;EALA;;;;;;;;;;EAgBA,KAAA,GAAQ,MAAA,SAAe,CAAA,CAAE,OAAA,IAAW,CAAA,CAAE,SAAA;EAehC;AAIR;;;;;EAZE,KAAA;EAwB2B;;;;;;;EAhB3B,MAAA;AAAA;;KAIU,QAAA;;;;;;;;;;;UAYK,YAAA;EAyBf;;;;;EAnBA,IAAA;EAmB6C;;;;EAd7C,WAAA;EA6BA;;;;;;EAtBA,KAAA,GAAQ,MAAA,SAAe,CAAA,CAAE,OAAA,IAAW,CAAA,CAAE,SAAA;;ACnDxC;;;;;ED0DE,MAAA,GAAS,CAAA,CAAE,OAAA,GAAU,IAAA,GAAO,MAAA,SAAe,CAAA,CAAE,OAAA;EC1DC;;;;;;EDiE9C,KAAA,GAAQ,CAAA,CAAE,OAAA,GAAU,IAAA;EEjEF;;;;;;;EFyElB,IAAA,GAAO,QAAA;;;;AG/DT;EHoEE,KAAA;AAAA;;;;;;;;;AA9GF;;;;;AAGA;;;;;AAUA;;;;;;;;;;;;;;;;;iBCmBgB,GAAA,CAAI,OAAA,GAAS,WAAA,GAAmB,eAAA;;;;;;;;;ADhChD;;;;;AAGA;;;;;AAUA;;;;;;;;;;;;;;;;;iBEmBgB,IAAA,CAAK,OAAA,GAAS,YAAA,GAAoB,eAAA;;;UCUjC,eAAA;EACf,OAAA,GAAU,eAAA;EACV,YAAA,GAAe,IAAA,CAAK,WAAA;EACpB,aAAA;AAAA;AAAA,cAIW,mBAAA;EAAA,iBAEQ,SAAA;EAAA,iBACA,OAAA;EAAA,iBACA,SAAA;EAAA,iBACA,SAAA;EAAA,iBACA,SAAA;cAJA,SAAA,EAAW,gBAAA,EACX,OAAA,EAAS,eAAA,EACT,SAAA,EAAW,SAAA,EACX,SAAA,EAAW,SAAA,EACX,SAAA,EAAW,iBAAA;EHpDN;AAU1B;;;;;;;;;EGuDE,QAAA,CAAS,OAAA,GAAS,eAAA,GAAuB,MAAA;EHlCzC;EAAA,QGgEQ,OAAA;EHhEe;EAAA,QGuFf,WAAA;EHvF4B;EAAA,QG0G5B,SAAA;EHnGR;EAAA,QGkIQ,UAAA;AAAA;;;KCzKL,QAAA,GAAW,IAAA,CAAK,WAAA,IAAe,WAAA;;;;;AJFpC;;;;;AAGA;;;;;AAUA;;iBIOgB,mBAAA,CACd,SAAA,EAAW,iBAAA,EACX,SAAA,EAAW,IAAA,CAAK,WAAA,MACf,WAAA;;;;;;iBAca,aAAA,CACd,SAAA,EAAW,SAAA,EACX,QAAA,EAAU,IAAA,WACV,OAAA,MAAa,IAAA,0BACZ,QAAA;;;;;;;;;;;;AJYH;;iBIkBsB,SAAA,CACpB,MAAA,EAAQ,QAAA,IACR,SAAA,EAAW,SAAA,EACX,SAAA,EAAW,SAAA,EACX,QAAA,EAAU,IAAA,WACV,OAAA,MAAa,IAAA,yBACb,OAAA,WACA,QAAA,WACA,WAAA,oBACC,OAAA;;;;;;;KC7ES,OAAA;EACN,IAAA;EAAe,KAAA;EAAe,MAAA;EAAmC,QAAA;EAAoB,KAAA;AAAA;EACrF,IAAA;EAAgB,MAAA;EAA0B,MAAA;EAAkB,QAAA;EAAoB,KAAA;AAAA;EAChF,IAAA;EAAgB,MAAA;AAAA;EAChB,IAAA;AAAA;EACA,IAAA;AAAA;EACA,IAAA;EAAiB,IAAA;AAAA;EACjB,IAAA;AAAA;EACA,IAAA;EAAc,IAAA;AAAA;EACd,IAAA;AAAA;AAAA,UAEI,WAAA;EACR,OAAA,GAAU,MAAA;EACV,EAAA;EACA,KAAA,GAAQ,MAAA;AAAA;;;;ALgDV;;iBKsBsB,aAAA,CACpB,MAAA,MAAY,IAAA,iBACZ,QAAA,UACA,KAAA,EAAO,MAAA,mBACP,QAAA,EAAU,OAAA,IACV,OAAA,EAAS,WAAA,cACT,QAAA,WACA,eAAA,YACC,OAAA;;iBASa,cAAA,CAAe,SAAA,UAAmB,IAAA,uBAA2B,OAAA;;;;;;ALxG7E;;;;;AAGA;;;;;AAUA;;;;;;;;;;;;;;;;cMmBa,eAAA,YAA2B,UAAA;EAAA,iBAEe,OAAA;EAAA,iBAClC,SAAA;EAAA,iBACA,eAAA;cAFkC,OAAA,EAAS,sBAAA,EAC3C,SAAA,EAAW,mBAAA,EACX,eAAA,EAAiB,eAAA;EAAA,OAG7B,OAAA,CAAQ,OAAA,EAAS,sBAAA,GAAyB,aAAA;EAajD,SAAA,CAAU,SAAA,EAAW,kBAAA;AAAA"}