@snail-js/api 0.1.27 → 1.0.0

package/dist/core/resolve-stream.d.ts

@@ -0,0 +1,45 @@
+import type { SnailSseHandlers, SnailWsHandlers } from "../decorators/stream.js";
+import type { SnailHttpStreamOptions, SnailSseOptions, SnailWsOptions } from "../typings/stream.js";
+/** Resolved description of an `@Sse` endpoint. */
+export interface ResolvedSseEndpoint {
+    url: string;
+    options: SnailSseOptions;
+    handlers: SnailSseHandlers;
+}
+/** Resolved description of an `@WebSocket` endpoint. */
+export interface ResolvedWsEndpoint {
+    url: string;
+    options: SnailWsOptions;
+    handlers: SnailWsHandlers;
+}
+/** Resolved description of an `@HttpStream` method. */
+export interface ResolvedHttpStreamEndpoint {
+    url: string;
+    options: SnailHttpStreamOptions;
+}
+/** Read the `@Sse(...)` options and its registered handlers. */
+export declare function resolveSseEndpoint(streamClass: unknown): ResolvedSseEndpoint | undefined;
+/** Read the `@WebSocket(...)` options and its registered handlers. */
+export declare function resolveWsEndpoint(streamClass: unknown): ResolvedWsEndpoint | undefined;
+/** Read the `@HttpStream(...)` options of one method. */
+export declare function resolveHttpStreamEndpoint(apiClass: unknown, methodName: string): ResolvedHttpStreamEndpoint | undefined;
+/**
+ * Turn an http(s) `baseURL` into the matching WebSocket origin.
+ *
+ * `https://api.example.com` → `wss://api.example.com`. A relative `baseURL`
+ * (the common browser case) keeps working because `new WebSocket` resolves a
+ * relative url against the document base — but the scheme still has to be
+ * upgraded explicitly, which is what this does.
+ */
+export declare function toWebSocketURL(url: string): string;
+/**
+ * Bind every SSE handler to the instance that will receive the events.
+ *
+ * Decorators only ever see the prototype, so the raw functions are stored and
+ * bound here — one binding per `open()`, against the instance actually created by
+ * `createSse`.
+ */
+export declare function rebindSseHandlers(handlers: SnailSseHandlers, instance: object): SnailSseHandlers;
+/** Bind every WebSocket handler to the instance. @see rebindSseHandlers */
+export declare function rebindWsHandlers(handlers: SnailWsHandlers, instance: object): SnailWsHandlers;
+//# sourceMappingURL=resolve-stream.d.ts.map

package/dist/core/resolve-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-stream.d.ts","sourceRoot":"","sources":["../../src/core/resolve-stream.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC9E,OAAO,KAAK,EACV,sBAAsB,EACtB,eAAe,EACf,cAAc,EACf,MAAM,mBAAmB,CAAC;AAS3B,kDAAkD;AAClD,MAAM,WAAW,mBAAmB;IAClC,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,eAAe,CAAC;IACzB,QAAQ,EAAE,gBAAgB,CAAC;CAC5B;AAED,wDAAwD;AACxD,MAAM,WAAW,kBAAkB;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,cAAc,CAAC;IACxB,QAAQ,EAAE,eAAe,CAAC;CAC3B;AAED,uDAAuD;AACvD,MAAM,WAAW,0BAA0B;IACzC,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,sBAAsB,CAAC;CACjC;AAUD,gEAAgE;AAChE,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,OAAO,GACnB,mBAAmB,GAAG,SAAS,CAcjC;AAED,sEAAsE;AACtE,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,OAAO,GACnB,kBAAkB,GAAG,SAAS,CAchC;AAED,yDAAyD;AACzD,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,OAAO,EACjB,UAAU,EAAE,MAAM,GACjB,0BAA0B,GAAG,SAAS,CAQxC;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAIlD;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,gBAAgB,EAC1B,QAAQ,EAAE,MAAM,GACf,gBAAgB,CASlB;AAED,2EAA2E;AAC3E,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,eAAe,EACzB,QAAQ,EAAE,MAAM,GACf,eAAe,CAOjB"}

package/dist/core/resolve.d.ts

@@ -0,0 +1,50 @@
+import { AxiosHeaders } from "axios";
+import type { InternalAxiosRequestConfig } from "axios";
+import type { SnailApiOptions, SnailMethodOptions, SnailMethodType } from "../typings/api.js";
+import type { ResolvedServerOptions } from "../typings/server.js";
+/**
+ * Turns raw decorator metadata into concrete, fully-defaulted options.
+ *
+ * Everything a request needs is resolved *here* rather than spread across the
+ * server, the proxy and the method. One place to read, one place to test.
+ */
+/** Read and default the options written by `@Server(...)`. */
+export declare function resolveServerOptions(serverClass: unknown, fallbackName: string): ResolvedServerOptions;
+/** Read and default the options written by `@Api(...)`. */
+export declare function resolveApiOptions(apiClass: new () => unknown, fallbackName: string): Required<SnailApiOptions>;
+/** Read the request verb written by `@Get()` / `@Post()` / … */
+export declare function resolveRequestMethod(apiClass: new () => unknown, methodName: string): SnailMethodType | undefined;
+/** Read the full request-method options written by `@Get(path, options)`. */
+export declare function resolveMethodDecoratorOptions(apiClass: new () => unknown, methodName: string): (SnailMethodOptions & {
+    method: SnailMethodType;
+    url: string;
+}) | undefined;
+/**
+ * Merge the three levels of `@Header(...)` — api class, then method.
+ *
+ * Method-level headers win, which is the only ordering that lets a single
+ * endpoint override a class-wide default.
+ */
+export declare function resolveHeaders(apiClass: new () => unknown, methodName: string): AxiosHeaders;
+/** Progress callbacks written by `@UploadProgress()` / `@DownloadProgress()`. */
+export declare function resolveProgress(apiClass: new () => unknown, methodName: string): {
+    onUploadProgress: SnailMethodOptions["onUploadProgress"];
+    onDownloadProgress: SnailMethodOptions["onDownloadProgress"];
+};
+/** Join the api prefix with a method path. */
+export declare function resolveRoute(apiURL: string, methodPath: string): string;
+/**
+ * Build the axios config a request starts from.
+ *
+ * Values cascade method → api → server, and only the winner survives. The
+ * argument decorators and the plugins refine this further during the pipeline.
+ */ export declare function buildBaseRequestConfig(input: {
+    serverOptions: ResolvedServerOptions;
+    apiOptions: Required<SnailApiOptions>;
+    methodOptions: SnailMethodOptions & {
+        url: string;
+    };
+    methodType: SnailMethodType;
+    headers: AxiosHeaders;
+}): InternalAxiosRequestConfig;
+//# sourceMappingURL=resolve.d.ts.map

package/dist/core/resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../src/core/resolve.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,OAAO,CAAC;AACrC,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,OAAO,CAAC;AAaxD,OAAO,KAAK,EACV,eAAe,EACf,kBAAkB,EAClB,eAAe,EAChB,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,qBAAqB,EAAsB,MAAM,mBAAmB,CAAC;AAGnF;;;;;GAKG;AAEH,8DAA8D;AAC9D,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,OAAO,EACpB,YAAY,EAAE,MAAM,GACnB,qBAAqB,CAuBvB;AAED,2DAA2D;AAC3D,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,UAAU,OAAO,EAC3B,YAAY,EAAE,MAAM,GACnB,QAAQ,CAAC,eAAe,CAAC,CAe3B;AAED,gEAAgE;AAChE,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,UAAU,OAAO,EAC3B,UAAU,EAAE,MAAM,GACjB,eAAe,GAAG,SAAS,CAO7B;AAED,6EAA6E;AAC7E,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,UAAU,OAAO,EAC3B,UAAU,EAAE,MAAM,GACjB,CAAC,kBAAkB,GAAG;IAAE,MAAM,EAAE,eAAe,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,SAAS,CAM7E;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,UAAU,OAAO,EAC3B,UAAU,EAAE,MAAM,GACjB,YAAY,CAKd;AAED,iFAAiF;AACjF,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,UAAU,OAAO,EAC3B,UAAU,EAAE,MAAM,GACjB;IACD,gBAAgB,EAAE,kBAAkB,CAAC,kBAAkB,CAAC,CAAC;IACzD,kBAAkB,EAAE,kBAAkB,CAAC,oBAAoB,CAAC,CAAC;CAC9D,CAKA;AAED,8CAA8C;AAC9C,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAEvE;AAED;;;;;GAKG,CAAA,wBAAgB,sBAAsB,CAAC,KAAK,EAAE;IAC/C,aAAa,EAAE,qBAAqB,CAAC;IACrC,UAAU,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAC;IACtC,aAAa,EAAE,kBAAkB,GAAG;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;IACpD,UAAU,EAAE,eAAe,CAAC;IAC5B,OAAO,EAAE,YAAY,CAAC;CACvB,GAAG,0BAA0B,CAkC7B"}

package/dist/core/response.d.ts

@@ -0,0 +1,60 @@
+import type { AxiosResponse, InternalAxiosRequestConfig } from "axios";
+import type { SnailCodeValidator, SnailResult } from "../typings/response.js";
+/**
+ * Response normalisation helpers.
+ *
+ * Responsibilities, in the order they run per request:
+ *   1. optionally repair a JSON body the server sent with the wrong content-type
+ *   2. decide whether the response *is* an envelope or a raw payload
+ *   3. validate the business status code
+ *   4. assemble the {@link SnailResult} handed to the caller
+ */
+/**
+ * Parse a JSON string body.
+ *
+ * Some gateways answer `Content-Type: text/plain` (or omit the header) while
+ * sending a JSON envelope. Without this repair the caller would receive a
+ * string where the types promise an object — a silent, very confusing bug.
+ *
+ * Returns the original response when parsing is disabled, when the caller asked
+ * for `responseType: "text"` explicitly (they want the raw string), or when the
+ * body does not look like JSON.
+ */
+export declare function coerceJSONStringBody<T>(response: AxiosResponse<T>, enabled: boolean): AxiosResponse<T>;
+/** `true` when the response body looks like an envelope carrying `dataKey`. */
+export declare function looksLikeEnvelope(body: unknown, dataKey: string): boolean;
+/** Read one key off an unknown body, or `undefined`. */
+export declare function readKey<T = unknown>(body: unknown, key: string): T | undefined;
+/** Extract the payload out of an envelope, tolerating raw pass-through bodies. */
+export declare function unwrapEnvelope<T>(body: unknown, dataKey: string): T;
+/**
+ * The default business-code rule: accept `0` and `200`.
+ *
+ * Chosen because `0` is the overwhelmingly common "no error" code in Chinese
+ * backends and `200` mirrors HTTP for teams that reuse it. Applications with a
+ * different convention pass `validateCode` to `@Server(...)`.
+ */
+export declare function createDefaultCodeValidator(accepted?: readonly (number | string)[]): SnailCodeValidator;
+/**
+ * Assert the business status code, throwing a {@link SnailResponseError} when
+ * the application's rule rejects it.
+ */
+export declare function assertBusinessCode(options: {
+    body: unknown;
+    code: number | string | undefined;
+    dataKey: string;
+    validate: SnailCodeValidator | undefined;
+    fullName: string;
+    message: string;
+}): void;
+/** Assemble the value `send()` resolves to. */
+export declare function buildResult<S, T, D extends string, C extends string, M extends string>(options: {
+    response: AxiosResponse;
+    envelope: unknown;
+    codeKey: string;
+    messageKey: string;
+    dataKey: string;
+    fromCache: boolean;
+    config: InternalAxiosRequestConfig;
+}): SnailResult<S, T, D, C, M>;
+//# sourceMappingURL=response.d.ts.map

package/dist/core/response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../../src/core/response.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,0BAA0B,EAAE,MAAM,OAAO,CAAC;AAGvE,OAAO,KAAK,EACV,kBAAkB,EAClB,WAAW,EACZ,MAAM,qBAAqB,CAAC;AAC7B;;;;;;;;GAQG;AAEH;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EACpC,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,EAC1B,OAAO,EAAE,OAAO,GACf,aAAa,CAAC,CAAC,CAAC,CAelB;AAED,+EAA+E;AAC/E,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAOzE;AAED,wDAAwD;AACxD,wBAAgB,OAAO,CAAC,CAAC,GAAG,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS,CAG9E;AAED,kFAAkF;AAClF,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,CAAC,CAKnE;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,GAAE,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,EAA2B,GAC9D,kBAAkB,CAGpB;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE;IAC1C,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,kBAAkB,GAAG,SAAS,CAAC;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB,GAAG,IAAI,CAQP;AAED,+CAA+C;AAC/C,wBAAgB,WAAW,CACzB,CAAC,EACD,CAAC,EACD,CAAC,SAAS,MAAM,EAChB,CAAC,SAAS,MAAM,EAChB,CAAC,SAAS,MAAM,EAChB,OAAO,EAAE;IACT,QAAQ,EAAE,aAAa,CAAC;IACxB,QAAQ,EAAE,OAAO,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,0BAA0B,CAAC;CACpC,GAAG,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAY7B"}

package/dist/core/server.d.ts

@@ -0,0 +1,132 @@
+import type { AxiosInstance, AxiosRequestConfig, AxiosResponse } from "axios";
+import type { SnailApiProxy } from "../typings/api.js";
+import type { SnailPlugin, SnailPluginObject } from "../typings/plugin.js";
+import type { SnailEnvelopeSchema } from "../typings/response.js";
+import type { SnailSseEndpoint, SnailWsEndpoint } from "../typings/stream.js";
+import type { ResolvedServerOptions } from "../typings/server.js";
+import { PluginManager } from "./plugin-manager.js";
+/**
+ * The server base class.
+ *
+ * Extend it, decorate the subclass with `@Server(...)` and instantiate once:
+ *
+ * ```ts
+ * @Server({ baseURL: "/api", timeout: 5000 })
+ * class BackEnd extends SnailServer {}
+ *
+ * export const Service = new BackEnd();
+ * ```
+ *
+ * The instance owns an axios instance, a plugin registry and the resolved
+ * options. It is created eagerly at module load, so `use()` is synchronous and
+ * chainable: `Service.use(A()).use(B())`.
+ */
+export declare class SnailServer<ServerResponse = SnailEnvelopeSchema, DataKey extends string = "data", CodeKey extends string = "code", MessageKey extends string = "message"> {
+    /** Server name — `@Server({ name })` or the subclass name. */
+    readonly name: string;
+    /** Fully resolved options, defaults applied. */
+    readonly options: ResolvedServerOptions;
+    /** The axios instance every request of this server goes through. */
+    readonly axios: AxiosInstance;
+    /** This server's plugin registry. */
+    readonly pluginManager: PluginManager;
+    private readonly logger;
+    private readonly apiCache;
+    constructor();
+    /**
+     * Register a plugin.
+     *
+     * Synchronous and chainable. Validation (name, duplicates, `dependsOn`) throws
+     * immediately; an async `install` hook is awaited once, before the first
+     * request, via the manager's `ready` promise.
+     */
+    use(plugin: SnailPluginObject<any> | SnailPlugin<any>): this;
+    /** Unregister a plugin by instance or by name. */
+    remove(plugin: SnailPluginObject<any> | string): Promise<boolean>;
+    /** `true` when a plugin with this name is registered. */
+    hasPlugin(name: string): boolean;
+    /** Registered plugin names, in chain order. */
+    get plugins(): readonly string[];
+    /**
+     * Turn a decorated api class into a proxy whose methods build requests.
+     *
+     * ```ts
+     * @Api("/user")
+     * class UserApi {
+     *   @Get("/:id")
+     *   getUser(@Params("id") id: string): Promise<User> { return null!; }
+     * }
+     *
+     * export const userApi = Service.createApi(UserApi);
+     * const method = userApi.getUser("1");  // nothing sent yet
+     * const { data } = await method.send();
+     * ```
+     *
+     * A declared return type — `Promise<User>` above — becomes the payload type,
+     * so `data` is `User` with no explicit generic.
+     */
+    createApi<TClass extends new (...args: any[]) => object>(apiClass: TClass): SnailApiProxy<InstanceType<TClass>, ServerResponse, DataKey, CodeKey, MessageKey>;
+    /**
+     * Turn a class decorated with `@Sse(...)` into an endpoint factory.
+     *
+     * ```ts
+     * @Sse("/events")
+     * class Events { @SseEvent() onMessage(m: SnailSseMessage) {} }
+     *
+     * const events = Service.createSse(Events);
+     * const connection = events.open();
+     * ```
+     */
+    createSse<TClass extends new (...args: any[]) => object>(sseClass: TClass): SnailSseEndpoint;
+    /**
+     * Turn a class decorated with `@WebSocket(...)` into an endpoint factory.
+     *
+     * ```ts
+     * @WebSocket("/ws")
+     * class Chat { @OnWsMessage() incoming(event: MessageEvent) {} }
+     *
+     * const chat = Service.createWebSocket(Chat);
+     * const socket = chat.open();
+     * socket.send({ hello: "world" });
+     * ```
+     */
+    createWebSocket<TClass extends new (...args: any[]) => object>(wsClass: TClass): SnailWsEndpoint;
+    /**
+     * Send a one-off request that is **not** backed by a decorated api class.
+     *
+     * This is an escape hatch, and it is deliberately thin: it awaits plugin
+     * installation and then calls the axios instance directly. **No lifecycle hook
+     * runs** — no `beforeRequest`, no `afterResponse`, no caching, no validation, no
+     * response transformation — and the envelope is *not* unwrapped, so you get the
+     * raw `AxiosResponse` back.
+     *
+     * Prefer a decorated api method for anything that should participate in the
+     * plugin pipeline. Reach for this only for a call that genuinely has no place in
+     * a service definition, such as a health check against a third party.
+     */
+    request<T = unknown, R = AxiosResponse<T>>(config: AxiosRequestConfig): Promise<R>;
+    /** Uninstall every plugin, running their cleanup hooks. */
+    dispose(): Promise<void>;
+    /** Metadata helper for tooling and tests. */
+    describe(): Record<string, unknown>;
+    /**
+     * Resolve everything static about one decorated method.
+     *
+     * Called once per method per api class. Returns `null` for a member that is not
+     * a decorated endpoint, which is how an api class may keep plain helpers next to
+     * its requests.
+     */
+    private resolveMethodDescriptor;
+    /**
+     * Build the stream controller behind an `@HttpStream` method.
+     *
+     * A real context is constructed rather than a look-alike, so the `@Query()` /
+     * `@Data()` / `@HeaderValue()` resolvers behave exactly as they do for a normal
+     * request. The plugin pipeline is deliberately skipped: a byte stream has no
+     * envelope to cache or validate.
+     */
+    private createHttpStream;
+    /** Construct the request object a proxied method call returns. */
+    private createMethod;
+}
+//# sourceMappingURL=server.d.ts.map

package/dist/core/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/core/server.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAE9E,OAAO,KAAK,EAAE,aAAa,EAAuC,MAAM,gBAAgB,CAAC;AAEzF,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACxE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,KAAK,EAEV,gBAAgB,EAChB,eAAe,EAChB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAS/D,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAqBjD;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,WAAW,CACtB,cAAc,GAAG,mBAAmB,EACpC,OAAO,SAAS,MAAM,GAAG,MAAM,EAC/B,OAAO,SAAS,MAAM,GAAG,MAAM,EAC/B,UAAU,SAAS,MAAM,GAAG,SAAS;IAErC,8DAA8D;IAC9D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,gDAAgD;IAChD,QAAQ,CAAC,OAAO,EAAE,qBAAqB,CAAC;IAExC,oEAAoE;IACpE,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAE9B,qCAAqC;IACrC,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;IAEtC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;IACxB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkC;IAE3D,cAiBC;IAED;;;;;;OAMG;IACH,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC,GAAG,CAAC,GAAG,IAAI,CAI3D;IAED,kDAAkD;IAC5C,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,GAAG,CAAC,GAAG,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAKtE;IAED,yDAAyD;IACzD,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE/B;IAED,+CAA+C;IAC/C,IAAI,OAAO,IAAI,SAAS,MAAM,EAAE,CAE/B;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,SAAS,CAAC,MAAM,SAAS,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,MAAM,EACrD,QAAQ,EAAE,MAAM,GACf,aAAa,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,cAAc,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU,CAAC,CAkEnF;IAED;;;;;;;;;;OAUG;IACH,SAAS,CAAC,MAAM,SAAS,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,MAAM,EACrD,QAAQ,EAAE,MAAM,GACf,gBAAgB,CAoBlB;IAED;;;;;;;;;;;OAWG;IACH,eAAe,CAAC,MAAM,SAAS,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,MAAM,EAC3D,OAAO,EAAE,MAAM,GACd,eAAe,CAoBjB;IAED;;;;;;;;;;;;OAYG;IACG,OAAO,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,EAC7C,MAAM,EAAE,kBAAkB,GACzB,OAAO,CAAC,CAAC,CAAC,CAQZ;IAED,2DAA2D;IACrD,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAE7B;IAED,6CAA6C;IAC7C,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAclC;IAID;;;;;;OAMG;IACH,OAAO,CAAC,uBAAuB;IA4D/B;;;;;;;OAOG;IACH,OAAO,CAAC,gBAAgB;IAsDxB,kEAAkE;IAClE,OAAO,CAAC,YAAY;CAsCrB"}

package/dist/core/sse.d.ts

@@ -0,0 +1,27 @@
+import type { SnailSseConnection, SnailSseOptions } from "../typings/stream.js";
+import type { SnailSseHandlers } from "../decorators/stream.js";
+import type { SnailLogger } from "./logger.js";
+/** Everything the SSE transport needs to open a connection. */
+export interface SseConnectionInit {
+    /** Fully qualified url. */
+    url: string;
+    /** Options from `@Sse(path, options)`. */
+    options: SnailSseOptions;
+    /** Handlers registered by the decorators. */
+    handlers: SnailSseHandlers;
+    /** Name used in log lines. */
+    name: string;
+    /** Extra headers (server-level, auth, …). */
+    headers?: Record<string, string>;
+    /** Logger. */
+    logger: SnailLogger;
+}
+/**
+ * Server-Sent Events over `fetch`.
+ *
+ * `EventSource` is deliberately not used: it cannot send request headers, cannot
+ * `POST`, cannot be aborted cleanly and reconnects on its own terms. A `fetch`
+ * stream reader supports all four, and the parser below is ~50 lines.
+ */
+export declare function createSseConnection(init: SseConnectionInit): SnailSseConnection;
+//# sourceMappingURL=sse.d.ts.map

package/dist/core/sse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse.d.ts","sourceRoot":"","sources":["../../src/core/sse.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,kBAAkB,EAElB,eAAe,EAChB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAI7D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C,+DAA+D;AAC/D,MAAM,WAAW,iBAAiB;IAChC,2BAA2B;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,0CAA0C;IAC1C,OAAO,EAAE,eAAe,CAAC;IACzB,6CAA6C;IAC7C,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,8BAA8B;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,6CAA6C;IAC7C,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,cAAc;IACd,MAAM,EAAE,WAAW,CAAC;CACrB;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,iBAAiB,GAAG,kBAAkB,CAkN/E"}

package/dist/core/state-bag.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Typed key/value bag.
+ *
+ * Two independent bags ride along every request:
+ *
+ * - `ctx.state` — **plugin scratch space**. Timers, cache keys, in-flight
+ *   promises, tracing ids. Never exposed to the caller.
+ * - `ctx.meta` — **caller-visible reactive values** (`data`, `loading`, `error`)
+ *   created by the framework adapter's `initMeta` hook.
+ *
+ * Keeping them separate matters: a plugin writing bookkeeping into `meta` would
+ * leak internal state into the object the UI renders.
+ */
+export declare class StateBag {
+    private readonly values;
+    /** Read a value, optionally falling back when the key is absent. */
+    get<T = unknown>(key: string): T | undefined;
+    get<T = unknown>(key: string, fallback: T): T;
+    /** Read a value, throwing when the key is absent. */
+    require<T = unknown>(key: string): T;
+    /** Write a value. */
+    set<T = unknown>(key: string, value: T): this;
+    /** Write a value only when the key is currently absent. */
+    setDefault<T = unknown>(key: string, value: T): T;
+    /** `true` when the key was ever set (even to `undefined`). */
+    has(key: string): boolean;
+    /** Remove a key. Returns whether it existed. */
+    delete(key: string): boolean;
+    /** Drop everything. */
+    clear(): void;
+    /** Current keys. */
+    keys(): string[];
+    /** Shallow snapshot, handy for logging and assertions. */
+    snapshot(): Record<string, unknown>;
+}
+//# sourceMappingURL=state-bag.d.ts.map

package/dist/core/state-bag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-bag.d.ts","sourceRoot":"","sources":["../../src/core/state-bag.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,qBAAa,QAAQ;IACnB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA8B;IAErD,oEAAoE;IACpE,GAAG,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS,CAAC;IAC7C,GAAG,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,CAAC,CAAC;IAK9C,qDAAqD;IACrD,OAAO,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC,CAKnC;IAED,qBAAqB;IACrB,GAAG,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAG5C;IAED,2DAA2D;IAC3D,UAAU,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAGhD;IAED,8DAA8D;IAC9D,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAExB;IAED,gDAAgD;IAChD,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAE3B;IAED,uBAAuB;IACvB,KAAK,IAAI,IAAI,CAEZ;IAED,oBAAoB;IACpB,IAAI,IAAI,MAAM,EAAE,CAEf;IAED,0DAA0D;IAC1D,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAElC;CACF"}

package/dist/core/websocket.d.ts

@@ -0,0 +1,29 @@
+import type { SnailSocketConnection, SnailWsOptions } from "../typings/stream.js";
+import type { SnailWsHandlers } from "../decorators/stream.js";
+import type { SnailLogger } from "./logger.js";
+/** Everything the WebSocket transport needs. */
+export interface WsConnectionInit {
+    /** Fully qualified `ws://` / `wss://` url. */
+    url: string;
+    /** Options from `@WebSocket(path, options)`. */
+    options: SnailWsOptions;
+    /** Handlers registered by the decorators. */
+    handlers: SnailWsHandlers;
+    /** Name used in log lines. */
+    name: string;
+    /** Logger. */
+    logger: SnailLogger;
+}
+/**
+ * WebSocket with reconnecting and an outbound queue.
+ *
+ * Two behaviours the platform socket does not give you, and which every real
+ * application ends up writing by hand:
+ *
+ * - **Reconnect with backoff** — `close` is normal; without a policy the socket
+ *   simply stays dead after a blip.
+ * - **Send-before-open queueing** — `open()` returns immediately, so a caller
+ *   that sends on the next line would otherwise throw `InvalidStateError`.
+ */
+export declare function createWsConnection(init: WsConnectionInit): SnailSocketConnection;
+//# sourceMappingURL=websocket.d.ts.map

package/dist/core/websocket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket.d.ts","sourceRoot":"","sources":["../../src/core/websocket.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAC/E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAI5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C,gDAAgD;AAChD,MAAM,WAAW,gBAAgB;IAC/B,8CAA8C;IAC9C,GAAG,EAAE,MAAM,CAAC;IACZ,gDAAgD;IAChD,OAAO,EAAE,cAAc,CAAC;IACxB,6CAA6C;IAC7C,QAAQ,EAAE,eAAe,CAAC;IAC1B,8BAA8B;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,cAAc;IACd,MAAM,EAAE,WAAW,CAAC;CACrB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,gBAAgB,GAAG,qBAAqB,CA4IhF"}

package/dist/decorators/api.d.ts

@@ -1,4 +1,24 @@
-import "reflect-metadata";
-import { ApiOptions } from "../typings";
-export declare const API_CONFIG_KEY: unique symbol;
-export declare const Api: (url?: string, config?: ApiOptions) => ClassDecorator;
+import type { SnailApiOptions } from "../typings/api.js";
+/**
+ * Declare an api class.
+ *
+ * ```ts
+ * @Api("/user")
+ * class UserApi {
+ *   @Get("/:id")
+ *   getUser(@Params("id") id: string): Promise<User> { return null!; }
+ * }
+ * ```
+ *
+ * The url is a *prefix*: it is joined with the server `baseURL` and the method
+ * path, in that order.
+ *
+ * Always declare `@Api()` even when there is no prefix. It is what names the api
+ * for logging, cache namespacing and `@HitSource` targets; without it those fall
+ * back to the class name. The library does **not** enforce it at runtime —
+ * inherited api classes are legitimate and a base class may carry the decorator —
+ * so a missing `@Api()` silently degrades rather than throwing.
+ */
+export declare function Api(url?: string): ClassDecorator;
+export declare function Api(options: SnailApiOptions): ClassDecorator;
+//# sourceMappingURL=api.d.ts.map

package/dist/decorators/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../src/decorators/api.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAItD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,GAAG,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,cAAc,CAAC;AAClD,wBAAgB,GAAG,CAAC,OAAO,EAAE,eAAe,GAAG,cAAc,CAAC"}

package/dist/decorators/args.d.ts

@@ -1,20 +1,83 @@
-import "reflect-metadata";
-export declare const REQUEST_ARGS_KEY: unique symbol;
+import type { SnailParamResolver } from "../typings/args.js";
 /**
- * 将被装饰的参数定义为查询参数
- * @param key 可选，查询参数的key，未给定key，则被装饰的参数应为对象
- * @returns
+ * Parameter decorators.
+ *
+ * Two shapes, on purpose:
+ *
+ * - `@Query("page") page: number` — a **keyed** argument places one value.
+ * - `@Query() query: SomeShape` — a **key-less** argument spreads a plain object.
+ *
+ * A key-less argument that is not a plain object throws, naming the method and
+ * the parameter. The pre-rewrite code logged to `console.error` and then threw a
+ * message that did not say which method was at fault.
  */
-export declare const Params: (key?: string) => (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/** A parameter decorator's accepted argument. */
+export type ParamDecoratorInput<O = void> = string | (O & {
+    key?: string;
+});
+/** Normalise `"key"` / `{ key, ...options }` / `undefined`. */
+export declare function normalizeParamInput<O>(input: ParamDecoratorInput<O> | undefined): {
+    key: string | undefined;
+    options: O | undefined;
+};
 /**
- * 将被装饰的参数定义为查询参数
- * @param key 可选，查询参数的key，未给定key，则被装饰的参数应为对象
- * @returns
+ * Write one parameter descriptor onto the decorated method.
+ *
+ * Parameter decorators run *before* the method decorator and in reverse index
+ * order, so this only ever appends — the descriptor list is sorted by index when
+ * the arguments are applied.
  */
-export declare const Query: (key?: string) => (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+export declare function defineParamDescriptor(source: string, resolver: SnailParamResolver, input: ParamDecoratorInput<any> | undefined, target: unknown, propertyKey: string | symbol | undefined, index: number): void;
 /**
- * 将被装饰的参数定义为请求数据
- * @param key 可选，请求data的key，未给定key，则被装饰的参数应为对象
- * @returns
+ * Build a parameter decorator for a registered source.
+ *
+ * Built-in sources are `params`, `query`, `data` and `header`. A plugin can add
+ * its own with `createPlugin`'s `defineParamSource`.
  */
-export declare const Data: (key?: string) => (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+export declare function createParamDecoratorFor<O = void>(source: string): (input?: ParamDecoratorInput<O>) => ParameterDecorator;
+/**
+ * Path placeholders.
+ *
+ * ```ts
+ * @Api("/user")
+ * class UserApi {
+ *   @Get("/:id/:tab")
+ *   get(@Params("id") id: string, @Params("tab") tab: string) {}
+ *   // or, equivalently
+ *   @Get("/:id/:tab")
+ *   get(@Params() params: { id: string; tab: string }) {}
+ * }
+ * ```
+ */
+export declare const Params: (input?: ParamDecoratorInput<void> | undefined) => ParameterDecorator;
+/**
+ * Query string parameters.
+ *
+ * ```ts
+ * @Get("/list")
+ * list(@Query("page") page: number, @Query() filters: { q?: string }) {}
+ * ```
+ */
+export declare const Query: (input?: ParamDecoratorInput<void> | undefined) => ParameterDecorator;
+/**
+ * Request body.
+ *
+ * Keyed arguments merge into an object body. A key-less plain object merges too,
+ * while any other value (`FormData`, `Blob`, a raw string, an array) replaces the
+ * body outright so non-JSON uploads stay possible.
+ */
+export declare const Data: (input?: ParamDecoratorInput<void> | undefined) => ParameterDecorator;
+/**
+ * A single request header.
+ *
+ * ```ts
+ * @Get("/me")
+ * me(@HeaderValue("authorization") token: string) {}
+ * ```
+ *
+ * For *static* headers use the class/method level `@Header({ ... })` instead.
+ */
+export declare const HeaderValue: (input?: ParamDecoratorInput<void> | undefined) => ParameterDecorator;
+/** Legacy alias — the pre-rewrite library exposed the header source as `Header`. */
+export declare const HeaderParam: (input?: ParamDecoratorInput<void> | undefined) => ParameterDecorator;
+//# sourceMappingURL=args.d.ts.map

package/dist/decorators/args.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"args.d.ts","sourceRoot":"","sources":["../../src/decorators/args.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAwB,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAKhF;;;;;;;;;;;GAWG;AAEH,iDAAiD;AACjD,MAAM,MAAM,mBAAmB,CAAC,CAAC,GAAG,IAAI,IAAI,MAAM,GAAG,CAAC,CAAC,GAAG;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAE5E,+DAA+D;AAC/D,wBAAgB,mBAAmB,CAAC,CAAC,EACnC,KAAK,EAAE,mBAAmB,CAAC,CAAC,CAAC,GAAG,SAAS,GACxC;IAAE,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,OAAO,EAAE,CAAC,GAAG,SAAS,CAAA;CAAE,CAgBrD;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,kBAAkB,EAC5B,KAAK,EAAE,mBAAmB,CAAC,GAAG,CAAC,GAAG,SAAS,EAC3C,MAAM,EAAE,OAAO,EACf,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,EACxC,KAAK,EAAE,MAAM,GACZ,IAAI,CAgBN;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,GAAG,IAAI,EAC9C,MAAM,EAAE,MAAM,GACb,CAAC,KAAK,CAAC,EAAE,mBAAmB,CAAC,CAAC,CAAC,KAAK,kBAAkB,CAgBxD;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,MAAM,qDAhCoB,kBAgCgB,CAAC;AAExD;;;;;;;GAOG;AACH,eAAO,MAAM,KAAK,qDA1CqB,kBA0Cc,CAAC;AAEtD;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,qDAnDsB,kBAmDY,CAAC;AAEpD;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW,qDA/De,kBA+DqB,CAAC;AAE7D,oFAAoF;AACpF,eAAO,MAAM,WAAW,qDAlEe,kBAkED,CAAC"}

package/dist/decorators/custom.d.ts

@@ -0,0 +1,81 @@
+import type { SnailParamResolver } from "../typings/args.js";
+import { type ParamDecoratorInput } from "./args.js";
+/**
+ * Extension factories for third-party decorators.
+ *
+ * The library's own decorators are built from these, so anything the core can do
+ * a plugin can do too.
+ *
+ * ## Key namespacing
+ *
+ * Custom keys are derived from a name you supply:
+ *
+ * ```ts
+ * const TENANT = customMetadataKey("acme/tenant");
+ * ```
+ *
+ * Prefix your name with your package to make collisions impossible. The reserved
+ * prefix `@snail-js/api:` belongs to the core.
+ */
+/** Build a namespaced metadata key for a custom decorator. */
+export declare function customMetadataKey(name: string): symbol;
+/**
+ * Create a **parameter** decorator.
+ *
+ * ```ts
+ * // 1. register a source (usually inside a plugin's setup)
+ * api.defineParamSource("tenant", ({ ctx, value }) => {
+ *   ctx.request.headers.set("x-tenant", String(value));
+ * });
+ *
+ * // 2. expose a decorator built on it
+ * export const Tenant = createParamDecorator("tenant");
+ *
+ * // 3. use it
+ * @Get("/orders")
+ * orders(@Tenant() tenantId: string) {}
+ * ```
+ *
+ * Pass an explicit `resolver` to skip step 1 and keep everything in one place.
+ */
+export declare function createParamDecorator<O = void>(source: string, resolver?: SnailParamResolver): (input?: ParamDecoratorInput<O>) => ParameterDecorator;
+/**
+ * Create a **class** decorator.
+ *
+ * ```ts
+ * export const Entity = createClassDecorator<string>("acme/entity");
+ * @Entity("orders") class OrderApi {}
+ * ```
+ *
+ * @param name metadata key name
+ * @param merge when `true` (the default) repeated applications keep every value
+ *   in an array instead of overwriting
+ */
+export declare function createClassDecorator<T = unknown>(name: string, merge?: boolean): (value: T) => ClassDecorator;
+/**
+ * Create a **method** decorator.
+ *
+ * ```ts
+ * export const Retry = createMethodDecorator<number>("acme/retry");
+ * @Get("/flaky") @Retry(3) flaky() {}
+ * ```
+ */
+export declare function createMethodDecorator<T = unknown>(name: string, merge?: boolean): (value: T) => MethodDecorator;
+/** Read metadata written by a custom method decorator. */
+export declare function getMethodMetadata<T>(name: string, target: unknown, methodName: string): T | undefined;
+/** Read metadata written by a custom class decorator. */
+export declare function getClassMetadata<T>(name: string, target: unknown): T | undefined;
+/** Read metadata written by a custom method decorator on exactly this class. */
+export declare function getOwnMethodMetadata<T>(name: string, target: unknown, methodName: string): T | undefined;
+/**
+ * Create a **property** decorator.
+ *
+ * Property decorators are handy for DTO classes consumed by the transform plugin:
+ *
+ * ```ts
+ * const Alias = createPropertyDecorator<string>("acme/alias");
+ * class UserDto { @Alias("user_name") userName!: string }
+ * ```
+ */
+export declare function createPropertyDecorator<T = unknown>(name: string): (value: T) => PropertyDecorator;
+//# sourceMappingURL=custom.d.ts.map

package/dist/decorators/custom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom.d.ts","sourceRoot":"","sources":["../../src/decorators/custom.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,EAAyB,KAAK,mBAAmB,EAAE,MAAM,QAAQ,CAAC;AAEzE;;;;;;;;;;;;;;;;GAgBG;AAEH,8DAA8D;AAC9D,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAKtD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,GAAG,IAAI,EAC3C,MAAM,EAAE,MAAM,EACd,QAAQ,CAAC,EAAE,kBAAkB,GAC5B,CAAC,KAAK,CAAC,EAAE,mBAAmB,CAAC,CAAC,CAAC,KAAK,kBAAkB,CAexD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,GAAG,OAAO,EAC9C,IAAI,EAAE,MAAM,EACZ,KAAK,UAAO,GACX,CAAC,KAAK,EAAE,CAAC,KAAK,cAAc,CAM9B;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,GAAG,OAAO,EAC/C,IAAI,EAAE,MAAM,EACZ,KAAK,UAAO,GACX,CAAC,KAAK,EAAE,CAAC,KAAK,eAAe,CAW/B;AAED,0DAA0D;AAC1D,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS,CAErG;AAED,yDAAyD;AACzD,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,CAAC,GAAG,SAAS,CAEhF;AAED,gFAAgF;AAChF,wBAAgB,oBAAoB,CAAC,CAAC,EACpC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,OAAO,EACf,UAAU,EAAE,MAAM,GACjB,CAAC,GAAG,SAAS,CAEf;AAED;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,GAAG,OAAO,EACjD,IAAI,EAAE,MAAM,GACX,CAAC,KAAK,EAAE,CAAC,KAAK,iBAAiB,CAKjC"}