alepha 0.23.0 → 0.24.0

package/src/server/swagger/providers/ServerSwaggerProvider.ts

@@ -10,7 +10,7 @@ import {
   type Static,
   type TObject,
   type TSchema,
-  t,
+  z,
 } from "alepha";
 import { $logger } from "alepha/logger";
 import {
@@ -36,12 +36,11 @@ import {
  */
 export const swaggerOptions = $atom({
   name: "alepha.server.swagger.options",
-  schema: t.object({
-    excludeKeys: t.optional(
-      t.array(t.string(), {
-        description: "Keys to exclude from swagger schema",
-      }),
-    ),
+  schema: z.object({
+    excludeKeys: z
+      .array(z.string())
+      .describe("Keys to exclude from swagger schema")
+      .optional(),
   }),
   default: {
     excludeKeys: [],
@@ -136,21 +135,34 @@ export class ServerSwaggerProvider {
     const excludeTags = doc.excludeTags ?? [];
     const schemas: Record<string, any> = {};
 
-    const schema = (source: TSchema) => {
-      if ("title" in source && typeof source.title === "string") {
-        schemas[source.title] = copy(source);
-        return { $ref: `#/components/schemas/${source.title}` };
+    const toJson = (source: TSchema): any => {
+      let json: any;
+      try {
+        json = z.toJSONSchema(source as any);
+      } catch {
+        json = {};
       }
-      return copy(source);
-    };
-
-    const copy = (obj: any) => {
-      const newValue = JSON.parse(JSON.stringify(obj));
-      this.removePrivateFields(newValue, [
+      // zod stamps a `$schema` dialect URL we don't want in OpenAPI fragments.
+      json.$schema = undefined;
+      this.removePrivateFields(json, [
         ...(this.options.excludeKeys || []),
         "~options",
       ]);
-      return newValue;
+      return json;
+    };
+
+    const schema = (source: TSchema): any => {
+      const json = toJson(source);
+      // A titled schema is hoisted into `components/schemas` and referenced.
+      const title =
+        (typeof (source as any)?.meta === "function"
+          ? (source as any).meta()?.title
+          : undefined) ?? json.title;
+      if (typeof title === "string") {
+        schemas[title] = json;
+        return { $ref: `#/components/schemas/${title}` };
+      }
+      return json;
     };
 
     for (const route of actions) {
@@ -202,11 +214,11 @@ export class ServerSwaggerProvider {
       }
 
       if (
-        t.schema.isObject(route.options.schema.body) ||
-        t.schema.isArray(route.options.schema.body)
+        z.schema.isObject(route.options.schema.body) ||
+        z.schema.isArray(route.options.schema.body)
       ) {
         if (
-          t.schema.isObject(route.options.schema.body) &&
+          z.schema.isObject(route.options.schema.body) &&
           this.isBodyMultipart(route.options.schema.body)
         ) {
           operation.requestBody = {
@@ -229,10 +241,11 @@ export class ServerSwaggerProvider {
         }
       }
 
-      if (t.schema.isObject(route.options.schema.query)) {
+      if (z.schema.isObject(route.options.schema.query)) {
         operation.parameters ??= [];
-        const requiredKeys: string[] =
-          route.options.schema.query.required ?? [];
+        const requiredKeys: string[] = z.schema.requiredKeys(
+          route.options.schema.query,
+        );
         for (const [key, value] of Object.entries(
           route.options.schema.query.properties,
         )) {
@@ -248,14 +261,18 @@ export class ServerSwaggerProvider {
         }
       }
 
-      if (t.schema.isObject(route.options.schema.params)) {
+      if (z.schema.isObject(route.options.schema.params)) {
         operation.parameters ??= [];
         for (const [key, value] of Object.entries(
           route.options.schema.params.properties,
         )) {
+          const valueMeta =
+            typeof (value as any)?.meta === "function"
+              ? ((value as any).meta() ?? {})
+              : {};
           const description =
-            "description" in value && typeof value.description === "string"
-              ? value.description
+            typeof valueMeta.description === "string"
+              ? valueMeta.description
               : undefined;
           const ref = schema(value);
           ref.description = undefined;
@@ -335,7 +352,7 @@ export class ServerSwaggerProvider {
       };
     }
 
-    if (t.schema.isObject(schema) || t.schema.isArray(schema)) {
+    if (z.schema.isObject(schema) || z.schema.isArray(schema)) {
       return {
         schema,
         status: 200,
@@ -343,7 +360,7 @@ export class ServerSwaggerProvider {
       };
     }
 
-    if (t.schema.isString(schema)) {
+    if (z.schema.isString(schema)) {
       return {
         schema,
         status: 200,
@@ -352,9 +369,9 @@ export class ServerSwaggerProvider {
     }
 
     if (
-      t.schema.isNumber(schema) ||
-      t.schema.isInteger(schema) ||
-      t.schema.isBoolean(schema)
+      z.schema.isNumber(schema) ||
+      z.schema.isInteger(schema) ||
+      z.schema.isBoolean(schema)
     ) {
       return {
         schema,
@@ -371,7 +388,7 @@ export class ServerSwaggerProvider {
       };
     }
 
-    // Status-code-keyed map: e.g. { 201: t.object({...}) }
+    // Status-code-keyed map: e.g. { 201: z.object({...}) }
     const status = Object.keys(schema)[0];
     if (status && !Number.isNaN(Number(status))) {
       const inner = schema[status];
@@ -384,11 +401,17 @@ export class ServerSwaggerProvider {
   }
 
   protected extractExample(schema: any): any {
-    if ("examples" in schema && Array.isArray(schema.examples)) {
-      return schema.examples[0];
+    const meta =
+      typeof schema?.meta === "function" ? (schema.meta() ?? {}) : {};
+    if (Array.isArray(meta.examples) && meta.examples.length > 0) {
+      return meta.examples[0];
+    }
+    if (meta.example !== undefined) {
+      return meta.example;
     }
-    if ("default" in schema) {
-      return schema.default;
+    const def = z.schema.getDefault(schema);
+    if (def !== undefined) {
+      return def;
     }
     return undefined;
   }
@@ -418,14 +441,14 @@ export class ServerSwaggerProvider {
 
   protected getContentType(schema: any): string | undefined {
     if (!schema) return undefined;
-    if (t.schema.isObject(schema) || t.schema.isArray(schema)) {
+    if (z.schema.isObject(schema) || z.schema.isArray(schema)) {
       return "application/json";
     }
-    if (t.schema.isString(schema)) return "text/plain";
+    if (z.schema.isString(schema)) return "text/plain";
     if (
-      t.schema.isNumber(schema) ||
-      t.schema.isInteger(schema) ||
-      t.schema.isBoolean(schema)
+      z.schema.isNumber(schema) ||
+      z.schema.isInteger(schema) ||
+      z.schema.isBoolean(schema)
     ) {
       return "application/json";
     }
@@ -438,7 +461,7 @@ export class ServerSwaggerProvider {
       method: "GET",
       path: `${prefix}/json`,
       schema: {
-        response: t.json(),
+        response: z.json(),
       },
       handler: () => json,
     });

package/src/system/__tests__/NodeShellProvider.spec.ts

@@ -0,0 +1,46 @@
+import { Alepha } from "alepha";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { NodeShellProvider } from "../providers/NodeShellProvider.ts";
+import { ShellProvider } from "../providers/ShellProvider.ts";
+
+// ---------------------------------------------------------------------------------------------------------------------
+
+describe("NodeShellProvider", () => {
+  let alepha: Alepha;
+  let shell: ShellProvider;
+
+  beforeAll(async () => {
+    alepha = Alepha.create().with({
+      provide: ShellProvider,
+      use: NodeShellProvider,
+    });
+    shell = alepha.inject(ShellProvider);
+    await alepha.start();
+  });
+
+  afterAll(async () => {
+    await alepha?.stop().catch(() => {});
+  });
+
+  describe("run with capture", () => {
+    it("captures stdout from a successful command", async () => {
+      const cmd = `node -e "process.stdout.write('hello-node')"`;
+      const out = await shell.run(cmd, { capture: true });
+      expect(out).toContain("hello-node");
+    });
+
+    it("attaches both stdout and stderr to the error on failure", async () => {
+      const cmd = `node -e "process.stdout.write('OUT');process.stderr.write('ERR');process.exit(3)"`;
+
+      const err = await shell.run(cmd, { capture: true }).then(
+        () => {
+          throw new Error("expected the command to reject");
+        },
+        (e) => e as { stdout?: string; stderr?: string },
+      );
+
+      expect(err.stdout).toContain("OUT");
+      expect(err.stderr).toContain("ERR");
+    });
+  });
+});

package/src/system/providers/NodeShellProvider.ts

@@ -122,9 +122,12 @@ export class NodeShellProvider implements ShellProvider {
             ...options.env,
           },
         },
-        (err, stdout) => {
+        (err, stdout, stderr) => {
           if (err) {
+            // Attach both streams so callers (e.g. the CLI Runner) can surface
+            // the full output of a failed command, not just stdout.
             (err as any).stdout = stdout;
+            (err as any).stderr = stderr;
             reject(err);
           } else {
             resolve(stdout);

package/src/topic/core/__tests__/$subscriber.spec.ts

@@ -1,4 +1,4 @@
-import { Alepha, createMiddleware, t } from "alepha";
+import { Alepha, createMiddleware, z } from "alepha";
 import { describe, expect, test } from "vitest";
 import {
   $subscriber,
@@ -21,9 +21,9 @@ const $track = (log: string[], tag: string) =>
   });
 
 const eventSchema = {
-  payload: t.object({
-    id: t.text(),
-    action: t.text(),
+  payload: z.object({
+    id: z.text(),
+    action: z.text(),
   }),
 };
 

package/src/topic/core/__tests__/shared.ts

@@ -1,4 +1,4 @@
-import { $inject, Alepha, type Service, t } from "alepha";
+import { $inject, Alepha, type Service, z } from "alepha";
 import {
   $subscriber,
   $topic,
@@ -17,8 +17,8 @@ export const testTopicParams = async (
     sensor = $topic({
       name: "devices/{deviceId}/sensor",
       schema: {
-        params: t.object({ deviceId: t.text() }),
-        payload: t.object({ temp: t.number() }),
+        params: z.object({ deviceId: z.text() }),
+        payload: z.object({ temp: z.number() }),
       },
     });
   }
@@ -58,9 +58,9 @@ export const testTopicParams = async (
   await app.stop();
 };
 
-export const payloadSchema = t.object({
-  id: t.text(),
-  count: t.integer(),
+export const payloadSchema = z.object({
+  id: z.text(),
+  count: z.integer(),
 });
 
 export const subscriptions: Record<string, SubscribeCallback[]> = {};
@@ -139,7 +139,7 @@ export const testTopicAsSub = async (
     t = $topic({
       name: "a",
       schema: {
-        payload: t.object({ n: t.integer() }),
+        payload: z.object({ n: z.integer() }),
       },
       handler: async ({ payload }) => {
         count += payload.n;
@@ -176,7 +176,7 @@ export const testTopicRetain = async (
     t = $topic({
       name: `retain-test-${crypto.randomUUID()}`,
       schema: {
-        payload: t.object({ value: t.text() }),
+        payload: z.object({ value: z.text() }),
       },
       retain: true,
     });

package/src/topic/core/primitives/$subscriber.ts

@@ -35,10 +35,10 @@ import type {
  *   userEvents = $topic({
  *     name: "user-activity",
  *     schema: {
- *       payload: t.object({
- *         userId: t.text(),
- *         action: t.enum(["login", "logout", "purchase"]),
- *         timestamp: t.number()
+ *       payload: z.object({
+ *         userId: z.text(),
+ *         action: z.enum(["login", "logout", "purchase"]),
+ *         timestamp: z.number()
  *       })
  *     }
  *   });
@@ -97,7 +97,7 @@ export interface SubscriberPrimitiveOptions<T extends TopicMessageSchema>
    * userEvents = $topic({
    *   name: "user-activity",
    *   schema: {
-   *     payload: t.object({ userId: t.text(), action: t.text() })
+   *     payload: z.object({ userId: z.text(), action: z.text() })
    *   }
    * });
    *

package/src/topic/core/primitives/$topic.ts

@@ -29,10 +29,10 @@ import {
  *   userActivity = $topic({
  *     name: "user-activity",
  *     schema: {
- *       payload: t.object({
- *         userId: t.text(),
- *         action: t.enum(["login", "logout", "purchase"]),
- *         timestamp: t.number()
+ *       payload: z.object({
+ *         userId: z.text(),
+ *         action: z.enum(["login", "logout", "purchase"]),
+ *         timestamp: z.number()
  *       })
  *     },
  *     handler: async (message) => {
@@ -158,17 +158,17 @@ export interface TopicPrimitiveOptions<T extends TopicMessageSchema> {
    * @example
    * ```ts
    * {
-   *   payload: t.object({
-   *     eventId: t.text(),
-   *     eventType: t.enum(["created", "updated"]),
-   *     data: t.record(t.text(), t.any()),
-   *     timestamp: t.number(),
-   *     userId: t.optional(t.text())
+   *   payload: z.object({
+   *     eventId: z.text(),
+   *     eventType: z.enum(["created", "updated"]),
+   *     data: z.record(z.text(), z.any()),
+   *     timestamp: z.number(),
+   *     userId: z.text().optional()
    *   }),
-   *   headers: t.optional(t.object({
-   *     source: t.text(),
-   *     correlationId: t.text()
-   *   }))
+   *   headers: z.object({
+   *     source: z.text(),
+   *     correlationId: z.text()
+   *   }).optional()
    * }
    * ```
    */

package/src/topic/redis/providers/RedisTopicProvider.ts

@@ -1,4 +1,4 @@
-import { $atom, $hook, $inject, $state, Alepha, type Static, t } from "alepha";
+import { $atom, $hook, $inject, $state, Alepha, type Static, z } from "alepha";
 import { $logger } from "alepha/logger";
 import { RedisProvider, RedisSubscriberProvider } from "alepha/redis";
 import {
@@ -16,8 +16,8 @@ import {
  */
 export const redisTopicOptions = $atom({
   name: "alepha.topic.redis.options",
-  schema: t.object({
-    prefix: t.text({
+  schema: z.object({
+    prefix: z.text({
       default: "topic",
       description: "Prefix for all topic channels in Redis.",
     }),

package/dist/container/core/index.d.ts

@@ -1,236 +0,0 @@
-import { Alepha, KIND, Primitive } from "alepha";
-import { DurationLike } from "alepha/datetime";
-
-//#region ../../src/container/core/interfaces/ContainerOptions.d.ts
-/**
- * Options for the `$container` primitive.
- *
- * Describes a remote Alepha app running in an ephemeral container. The
- * primitive returns a typed Proxy that calls the container's `$action`
- * endpoints through whatever transport the active provider chooses
- * (Cloudflare Containers binding on `target=cloudflare`, plain HTTP on
- * Node when `url` is set).
- */
-interface ContainerPrimitiveOptions {
-  /**
-   * Logical container name. Defaults to the property key.
-   *
-   * Cloudflare provider uppercases this to look up the binding
-   * (`env.<NAME>`), so prefer lowercase here.
-   */
-  name?: string;
-  /**
-   * Docker image the container runs. Required.
-   *
-   * The build task uses this verbatim in `wrangler.jsonc`'s
-   * `containers[].image` entry.
-   */
-  image: string;
-  /**
-   * Explicit URL the Node provider should call. When set, `$container`
-   * routes through `LinkProvider` exactly like `$remote({ url })`.
-   *
-   * On `target=cloudflare`, this is ignored — the Containers binding is
-   * used instead.
-   */
-  url?: string | (() => string);
-  /**
-   * Port the container app listens on. Defaults to 3000 (Alepha
-   * convention — NOT Cloudflare's 8080). Used in build-time codegen.
-   */
-  port?: number;
-  /**
-   * Idle window before the platform stops the container instance.
-   *
-   * @default "15m"
-   */
-  sleepAfter?: DurationLike;
-  /**
-   * Environment variables injected into the container at runtime.
-   */
-  envVars?: Record<string, string>;
-  /**
-   * Cloudflare-specific instance class. Ignored on other targets.
-   *
-   * @default "dev"
-   */
-  instanceType?: "dev" | "basic" | "standard";
-  /**
-   * Maximum concurrent container instances.
-   *
-   * @default 5
-   */
-  maxInstances?: number;
-}
-//#endregion
-//#region ../../src/container/core/providers/ContainerProvider.d.ts
-interface ContainerInvokeConfig {
-  body?: unknown;
-  query?: Record<string, unknown>;
-  params?: Record<string, unknown>;
-  headers?: Record<string, string>;
-}
-/**
- * Abstract transport for `$container` proxies.
- *
- * Concrete subclasses translate a `(container, action, config)` call
- * into an HTTP request that reaches the running container. The default
- * binding on Node throws — apps must register either a
- * `NodeContainerProvider` (with `url` on each primitive) or the
- * Cloudflare workerd variant.
- */
-declare abstract class ContainerProvider {
-  protected readonly log: import("alepha/logger").Logger;
-  /**
-   * Invoke a remote action on the container. Subclasses do the work;
-   * the default implementation rejects to make missing wiring obvious.
-   */
-  invoke(container: ContainerPrimitive, action: string, config: ContainerInvokeConfig): Promise<unknown>;
-  /**
-   * Helper: build the fetch path/body for an action call. Kept as a
-   * protected method so workerd and Node providers share the wire
-   * shape — `POST /api/<action>` with the JSON body, query params on
-   * the URL, and the request headers merged in.
-   */
-  protected buildRequest(action: string, config: ContainerInvokeConfig): {
-    path: string;
-    init: RequestInit;
-  };
-}
-//#endregion
-//#region ../../src/container/core/primitives/$container.d.ts
-/**
- * `$container` — typed RPC client to a containerized Alepha app.
- *
- * Returns a typed Proxy whose method calls map 1:1 to the target
- * controller's `$action` endpoints. The wire format mirrors what a
- * normal Alepha server exposes (`POST /api/<method>` with a JSON body),
- * so the container is literally a tiny Alepha worker.
- *
- * Transport is owned by the active {@link ContainerProvider}:
- * - `target=cloudflare` → `CloudflareContainerProvider` routes through
- *   the Containers binding (`env.<NAME>.getContainer(...).fetch()`).
- * - Node (with `url` set) → `NodeContainerProvider` uses plain
- *   `fetch()` against the configured URL.
- *
- * Build-time, `BuildCloudflareTask.enhanceContainers` walks
- * `alepha.primitives($container)` to emit the matching `wrangler.jsonc`
- * entries and Durable Object class declarations into
- * `main.cloudflare.js`.
- *
- * @example
- * ```ts
- * import { $container } from "alepha/container";
- * import type { RocketController } from "@alepha/rocket";
- *
- * class DeployService {
- *   rocket = $container<RocketController>({
- *     image: "alepha/rocket:latest",
- *     port: 3000,
- *     sleepAfter: "15m",
- *   });
- *
- *   async deploy() {
- *     return this.rocket.createJob({ body: { op: "up" } });
- *   }
- * }
- * ```
- */
-declare const $container: {
-  <T extends object = any>(options: ContainerPrimitiveOptions): ContainerProxy<T>;
-  [KIND]: typeof ContainerPrimitive;
-};
-/**
- * Typed proxy returned by `$container<T>()`. Each `$action` member of
- * `T` becomes a callable returning the action's response body.
- *
- * The runtime shape is a `Proxy(primitive)` — own-property reads hit the
- * underlying `ContainerPrimitive` (so `alepha.primitives($container)`
- * still finds it via the `instanceof Primitive` check inside
- * `Alepha.new()`), and anything else is treated as an action name and
- * routed through the active `ContainerProvider`.
- */
-type ContainerProxy<T extends object> = { [K in keyof T]: T[K] extends ((...args: infer A) => infer R) ? (...args: A) => Promise<Awaited<R>> : (config?: {
-  body?: unknown;
-  query?: unknown;
-  params?: unknown;
-}) => Promise<any> };
-declare class ContainerPrimitive extends Primitive<ContainerPrimitiveOptions> {
-  protected readonly provider: ContainerProvider;
-  get name(): string;
-  /**
-   * Build the typed Proxy. The target is the primitive itself so
-   * `instanceof Primitive` keeps working (required by Alepha's
-   * primitive registration in `Alepha.new`). Property reads that match
-   * an own/inherited member return that member; anything else is
-   * treated as an action name and routed through the provider.
-   */
-  proxy<T extends object = any>(): ContainerProxy<T>;
-}
-//#endregion
-//#region ../../src/container/core/providers/MockContainerProvider.d.ts
-/**
- * In-process test provider.
- *
- * Resolves the action name against `LinkProvider`'s registered links in
- * the SAME Alepha instance — effectively calling the "containerized"
- * controller as if it were local. Use it in tests: register the
- * controller class on the test container alongside the consumer and
- * substitute `ContainerProvider` with `MockContainerProvider`.
- *
- * @example
- * ```ts
- * const alepha = Alepha.create()
- *   .with(AlephaContainer)
- *   .with(RocketController)
- *   .with(MyApp)
- *   .with({ provide: ContainerProvider, use: MockContainerProvider });
- * ```
- */
-declare class MockContainerProvider extends ContainerProvider {
-  protected readonly alepha: Alepha;
-  invoke(container: ContainerPrimitive, action: string, config: ContainerInvokeConfig): Promise<unknown>;
-  protected loadLinkProvider(): Promise<any>;
-}
-//#endregion
-//#region ../../src/container/core/providers/NodeContainerProvider.d.ts
-/**
- * Node (dev / test / non-Cloudflare) container provider.
- *
- * Routes proxy calls through plain `fetch()` against the URL given on
- * the `$container` primitive. If no `url` is supplied, calls throw —
- * v1 deliberately has no Docker spawning. This is the "temporary, not
- * perfect" Node path documented in the spec; the longer-term plan is
- * to plug in a `target=docker` adapter once that lands.
- */
-declare class NodeContainerProvider extends ContainerProvider {
-  invoke(container: ContainerPrimitive, action: string, config: ContainerInvokeConfig): Promise<unknown>;
-  protected resolveUrl(container: ContainerPrimitive): string | undefined;
-}
-//#endregion
-//#region ../../src/container/core/index.d.ts
-/**
- * Type-safe RPC clients for ephemeral containerized Alepha apps.
- *
- * **Features:**
- * - `$container<T>()` directive returns a typed Proxy onto a remote
- *   Alepha controller's `$action` endpoints — the wire format is the
- *   same `POST /api/<method>` shape served by every Alepha server.
- * - Pluggable transport: Node (plain `fetch` against a configured URL),
- *   Mock (in-process call via `LinkProvider.follow` for tests),
- *   Cloudflare workerd (`getContainer().fetch()` through the Containers
- *   binding — see `alepha/container` workerd entry).
- * - Build-time integration: `BuildCloudflareTask.enhanceContainers`
- *   emits the matching wrangler bindings and Durable Object class
- *   declarations.
- *
- * The Node binding is the "temporary, not perfect" path documented in
- * the spec — apps need to provide an explicit `url` per primitive
- * until a `target=docker` adapter ships.
- *
- * @module alepha.container
- */
-declare const AlephaContainer: import("alepha").Service<import("alepha").Module>;
-//#endregion
-export { $container, AlephaContainer, ContainerInvokeConfig, ContainerPrimitive, ContainerPrimitiveOptions, ContainerProvider, ContainerProxy, MockContainerProvider, NodeContainerProvider };
-//# sourceMappingURL=index.d.ts.map

package/dist/container/core/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/container/core/interfaces/ContainerOptions.ts","../../../src/container/core/providers/ContainerProvider.ts","../../../src/container/core/primitives/$container.ts","../../../src/container/core/providers/MockContainerProvider.ts","../../../src/container/core/providers/NodeContainerProvider.ts","../../../src/container/core/index.ts"],"mappings":";;;;;;;AAWA;;;;;;UAAiB,yBAAA;EA8Bf;;;;;;EAvBA,IAAA;EAiDY;AAAA;;;;AC/Dd;EDsBE,KAAA;;;;;;;;EASA,GAAA;EC7BQ;;;;EDmCR,IAAA;ECjCgB;AAAA;AAYlB;;;ED4BE,UAAA,GAAa,YAAA;EClBH;;;EDuBV,OAAA,GAAU,MAAM;ECLoB;;;;;EDYpC,YAAA;EChCE;;;;;EDuCF,YAAA;AAAA;;;UC/De,qBAAA;EACf,IAAA;EACA,KAAA,GAAQ,MAAA;EACR,MAAA,GAAS,MAAA;EACT,OAAA,GAAU,MAAA;AAAA;;;;;;;;;;uBAYU,iBAAA;EAAA,mBACD,GAAA,0BAAG,MAAA;ED8CV;AAAA;;;ECxCC,MAAA,CACX,SAAA,EAAW,kBAAA,EACX,MAAA,UACA,MAAA,EAAQ,qBAAA,GACP,OAAA;EA3BY;;;;;;EAAA,UAyCL,YAAA,CACR,MAAA,UACA,MAAA,EAAQ,qBAAA;IACL,IAAA;IAAc,IAAA,EAAM,WAAA;EAAA;AAAA;;;;ADrC3B;;;;;;;;;;;;;;;AAwDc;;;;AC/Dd;;;;;;;;;;;;;;;;AAIkB;cCiCL,UAAA;EAAA,yBAA8B,OAAA,EAChC,yBAAA,GACR,cAAA,CAAe,CAAA;EAAA;;;;;;;;;;;;KAkBN,cAAA,mCACE,CAAA,GAAI,CAAA,CAAE,CAAA,eAAe,IAAA,6BACzB,IAAA,EAAM,CAAA,KAAM,OAAA,CAAQ,OAAA,CAAQ,CAAA,MAC/B,MAAA;EACC,IAAA;EACA,KAAA;EACA,MAAA;AAAA,MACI,OAAA;AAAA,cAGC,kBAAA,SAA2B,SAAA,CAAU,yBAAA;EAAA,mBAC7B,QAAA,EAAQ,iBAAA;EAAA,IAEhB,IAAA;ED1BQ;;;AAAiB;;;;ECqC7B,KAAA,4BAAiC,cAAA,CAAe,CAAA;AAAA;;;;AF1EzD;;;;;;;;;;;;;;;AAwDc;;cG1CD,qBAAA,SAA8B,iBAAA;EAAA,mBACtB,MAAA,EAAM,MAAA;EAEH,MAAA,CACpB,SAAA,EAAW,kBAAA,EACX,MAAA,UACA,MAAA,EAAQ,qBAAA,GACP,OAAA;EAAA,UAmBa,gBAAA,IAAoB,OAAA;AAAA;;;;;AHxCtC;;;;;;;cIKa,qBAAA,SAA8B,iBAAA;EACnB,MAAA,CACpB,SAAA,EAAW,kBAAA,EACX,MAAA,UACA,MAAA,EAAQ,qBAAA,GACP,OAAA;EAAA,UA2BO,UAAA,CAAW,SAAA,EAAW,kBAAA;AAAA;;;;;;;;;;;;;;;;;AJmBpB;;;;AC/Dd;;;cIiCa,eAAA,mBAAe,OAAA,kBAAA,MAAA"}