@gravito/flux 1.0.0-beta.2 → 1.0.0-beta.4

package/dist/{types.d.ts → types-DvVHBmP6.d.cts}

@@ -8,11 +8,11 @@
 /**
  * Workflow execution status
  */
-export type WorkflowStatus = 'pending' | 'running' | 'paused' | 'completed' | 'failed';
+type WorkflowStatus = 'pending' | 'running' | 'paused' | 'completed' | 'failed';
 /**
  * Step execution result
  */
-export interface StepResult<T = unknown> {
+interface StepResult<T = unknown> {
     success: boolean;
     data?: T;
     error?: Error;
@@ -21,7 +21,7 @@ export interface StepResult<T = unknown> {
 /**
  * Step execution history entry
  */
-export interface StepExecution {
+interface StepExecution {
     name: string;
     status: 'pending' | 'running' | 'completed' | 'failed' | 'skipped';
     startedAt?: Date;
@@ -33,17 +33,17 @@ export interface StepExecution {
 /**
  * Step definition
  */
-export interface StepDefinition<TContext = WorkflowContext> {
+interface StepDefinition<TInput = any, TData = any> {
     /** Step name (unique within workflow) */
     name: string;
     /** Step handler function */
-    handler: (ctx: TContext) => Promise<void> | void;
+    handler: (ctx: WorkflowContext<TInput, TData>) => Promise<void> | void;
     /** Number of retries on failure */
     retries?: number;
     /** Timeout in milliseconds */
     timeout?: number;
     /** Condition to skip this step */
-    when?: (ctx: TContext) => boolean;
+    when?: (ctx: WorkflowContext<TInput, TData>) => boolean;
     /** Mark as commit step (always executes even on replay) */
     commit?: boolean;
 }
@@ -52,7 +52,7 @@ export interface StepDefinition<TContext = WorkflowContext> {
  *
  * Passed to each step handler with accumulated data.
  */
-export interface WorkflowContext<TInput = unknown, TData = Record<string, unknown>> {
+interface WorkflowContext<TInput = unknown, TData = Record<string, unknown>> {
     /** Unique workflow instance ID */
     readonly id: string;
     /** Workflow definition name */
@@ -71,12 +71,12 @@ export interface WorkflowContext<TInput = unknown, TData = Record<string, unknow
 /**
  * Serializable workflow state for persistence
  */
-export interface WorkflowState {
+interface WorkflowState<TInput = any, TData = any> {
     id: string;
     name: string;
     status: WorkflowStatus;
-    input: unknown;
-    data: Record<string, unknown>;
+    input: TInput;
+    data: TData;
     currentStep: number;
     history: StepExecution[];
     createdAt: Date;
@@ -87,18 +87,35 @@ export interface WorkflowState {
 /**
  * Workflow definition (immutable blueprint)
  */
-export interface WorkflowDefinition<TInput = unknown> {
+interface WorkflowDefinition<TInput = unknown, TData = Record<string, unknown>> {
     /** Workflow name */
     name: string;
     /** Step definitions in order */
-    steps: StepDefinition[];
+    steps: StepDefinition<TInput, TData>[];
     /** Input schema validator (optional) */
     validateInput?: (input: unknown) => input is TInput;
 }
+/**
+ * Workflow descriptor (serializable metadata)
+ */
+interface WorkflowDescriptor {
+    name: string;
+    steps: StepDescriptor[];
+}
+/**
+ * Step descriptor (serializable metadata)
+ */
+interface StepDescriptor {
+    name: string;
+    commit: boolean;
+    retries?: number;
+    timeout?: number;
+    hasCondition: boolean;
+}
 /**
  * Workflow storage adapter interface
  */
-export interface WorkflowStorage {
+interface WorkflowStorage {
     /**
      * Save workflow state
      */
@@ -127,7 +144,7 @@ export interface WorkflowStorage {
 /**
  * Workflow filter options
  */
-export interface WorkflowFilter {
+interface WorkflowFilter {
     name?: string;
     status?: WorkflowStatus | WorkflowStatus[];
     limit?: number;
@@ -145,20 +162,43 @@ export interface WorkflowFilter {
  * })
  * ```
  */
-export interface FluxLogger {
+interface FluxLogger {
     debug(message: string, ...args: unknown[]): void;
     info(message: string, ...args: unknown[]): void;
     warn(message: string, ...args: unknown[]): void;
     error(message: string, ...args: unknown[]): void;
 }
+type FluxTraceEventType = 'workflow:start' | 'workflow:complete' | 'workflow:error' | 'step:start' | 'step:complete' | 'step:error' | 'step:skipped' | 'step:retry';
+interface FluxTraceEvent {
+    type: FluxTraceEventType;
+    timestamp: number;
+    workflowId: string;
+    workflowName: string;
+    stepName?: string;
+    stepIndex?: number;
+    commit?: boolean;
+    retries?: number;
+    maxRetries?: number;
+    duration?: number;
+    error?: string;
+    status?: WorkflowStatus | StepExecution['status'];
+    input?: unknown;
+    data?: Record<string, unknown>;
+    meta?: Record<string, unknown>;
+}
+interface FluxTraceSink {
+    emit(event: FluxTraceEvent): void | Promise<void>;
+}
 /**
  * Workflow engine configuration
  */
-export interface FluxConfig {
+interface FluxConfig {
     /** Storage adapter */
     storage?: WorkflowStorage;
     /** Logger instance */
     logger?: FluxLogger;
+    /** Trace sink for workflow events */
+    trace?: FluxTraceSink;
     /** Default retry count for steps */
     defaultRetries?: number;
     /** Default timeout for steps (ms) */
@@ -177,7 +217,7 @@ export interface FluxConfig {
 /**
  * Workflow execution result
  */
-export interface FluxResult<TData = Record<string, unknown>> {
+interface FluxResult<TData = Record<string, unknown>> {
     /** Workflow instance ID */
     id: string;
     /** Final status */
@@ -191,4 +231,5 @@ export interface FluxResult<TData = Record<string, unknown>> {
     /** Error if failed */
     error?: Error;
 }
-//# sourceMappingURL=types.d.ts.map
+
+export type { FluxConfig as F, StepDefinition as S, WorkflowDefinition as W, FluxLogger as a, FluxResult as b, FluxTraceEvent as c, FluxTraceEventType as d, FluxTraceSink as e, StepDescriptor as f, StepExecution as g, StepResult as h, WorkflowContext as i, WorkflowDescriptor as j, WorkflowFilter as k, WorkflowState as l, WorkflowStatus as m, WorkflowStorage as n };

package/dist/types-DvVHBmP6.d.ts

@@ -0,0 +1,235 @@
+/**
+ * @fileoverview Core type definitions for @gravito/flux
+ *
+ * Platform-agnostic workflow engine types.
+ *
+ * @module @gravito/flux
+ */
+/**
+ * Workflow execution status
+ */
+type WorkflowStatus = 'pending' | 'running' | 'paused' | 'completed' | 'failed';
+/**
+ * Step execution result
+ */
+interface StepResult<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: Error;
+    duration: number;
+}
+/**
+ * Step execution history entry
+ */
+interface StepExecution {
+    name: string;
+    status: 'pending' | 'running' | 'completed' | 'failed' | 'skipped';
+    startedAt?: Date;
+    completedAt?: Date;
+    duration?: number;
+    error?: string;
+    retries: number;
+}
+/**
+ * Step definition
+ */
+interface StepDefinition<TInput = any, TData = any> {
+    /** Step name (unique within workflow) */
+    name: string;
+    /** Step handler function */
+    handler: (ctx: WorkflowContext<TInput, TData>) => Promise<void> | void;
+    /** Number of retries on failure */
+    retries?: number;
+    /** Timeout in milliseconds */
+    timeout?: number;
+    /** Condition to skip this step */
+    when?: (ctx: WorkflowContext<TInput, TData>) => boolean;
+    /** Mark as commit step (always executes even on replay) */
+    commit?: boolean;
+}
+/**
+ * Workflow execution context
+ *
+ * Passed to each step handler with accumulated data.
+ */
+interface WorkflowContext<TInput = unknown, TData = Record<string, unknown>> {
+    /** Unique workflow instance ID */
+    readonly id: string;
+    /** Workflow definition name */
+    readonly name: string;
+    /** Original input data */
+    readonly input: TInput;
+    /** Accumulated step data (mutable) */
+    data: TData;
+    /** Current workflow status */
+    readonly status: WorkflowStatus;
+    /** Current step index */
+    readonly currentStep: number;
+    /** Step execution history */
+    readonly history: StepExecution[];
+}
+/**
+ * Serializable workflow state for persistence
+ */
+interface WorkflowState<TInput = any, TData = any> {
+    id: string;
+    name: string;
+    status: WorkflowStatus;
+    input: TInput;
+    data: TData;
+    currentStep: number;
+    history: StepExecution[];
+    createdAt: Date;
+    updatedAt: Date;
+    completedAt?: Date;
+    error?: string;
+}
+/**
+ * Workflow definition (immutable blueprint)
+ */
+interface WorkflowDefinition<TInput = unknown, TData = Record<string, unknown>> {
+    /** Workflow name */
+    name: string;
+    /** Step definitions in order */
+    steps: StepDefinition<TInput, TData>[];
+    /** Input schema validator (optional) */
+    validateInput?: (input: unknown) => input is TInput;
+}
+/**
+ * Workflow descriptor (serializable metadata)
+ */
+interface WorkflowDescriptor {
+    name: string;
+    steps: StepDescriptor[];
+}
+/**
+ * Step descriptor (serializable metadata)
+ */
+interface StepDescriptor {
+    name: string;
+    commit: boolean;
+    retries?: number;
+    timeout?: number;
+    hasCondition: boolean;
+}
+/**
+ * Workflow storage adapter interface
+ */
+interface WorkflowStorage {
+    /**
+     * Save workflow state
+     */
+    save(state: WorkflowState): Promise<void>;
+    /**
+     * Load workflow state by ID
+     */
+    load(id: string): Promise<WorkflowState | null>;
+    /**
+     * List workflow states with optional filter
+     */
+    list(filter?: WorkflowFilter): Promise<WorkflowState[]>;
+    /**
+     * Delete workflow state
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Initialize storage (create tables, etc.)
+     */
+    init?(): Promise<void>;
+    /**
+     * Cleanup storage resources
+     */
+    close?(): Promise<void>;
+}
+/**
+ * Workflow filter options
+ */
+interface WorkflowFilter {
+    name?: string;
+    status?: WorkflowStatus | WorkflowStatus[];
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Logger interface for FluxEngine
+ *
+ * Implement this to create custom loggers.
+ *
+ * @example
+ * ```typescript
+ * const engine = new FluxEngine({
+ *   logger: new FluxConsoleLogger()
+ * })
+ * ```
+ */
+interface FluxLogger {
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+}
+type FluxTraceEventType = 'workflow:start' | 'workflow:complete' | 'workflow:error' | 'step:start' | 'step:complete' | 'step:error' | 'step:skipped' | 'step:retry';
+interface FluxTraceEvent {
+    type: FluxTraceEventType;
+    timestamp: number;
+    workflowId: string;
+    workflowName: string;
+    stepName?: string;
+    stepIndex?: number;
+    commit?: boolean;
+    retries?: number;
+    maxRetries?: number;
+    duration?: number;
+    error?: string;
+    status?: WorkflowStatus | StepExecution['status'];
+    input?: unknown;
+    data?: Record<string, unknown>;
+    meta?: Record<string, unknown>;
+}
+interface FluxTraceSink {
+    emit(event: FluxTraceEvent): void | Promise<void>;
+}
+/**
+ * Workflow engine configuration
+ */
+interface FluxConfig {
+    /** Storage adapter */
+    storage?: WorkflowStorage;
+    /** Logger instance */
+    logger?: FluxLogger;
+    /** Trace sink for workflow events */
+    trace?: FluxTraceSink;
+    /** Default retry count for steps */
+    defaultRetries?: number;
+    /** Default timeout for steps (ms) */
+    defaultTimeout?: number;
+    /** Enable parallel execution for independent steps */
+    parallel?: boolean;
+    /** Event handlers */
+    on?: {
+        stepStart?: (step: string, ctx: WorkflowContext) => void;
+        stepComplete?: (step: string, ctx: WorkflowContext, result: StepResult) => void;
+        stepError?: (step: string, ctx: WorkflowContext, error: Error) => void;
+        workflowComplete?: (ctx: WorkflowContext) => void;
+        workflowError?: (ctx: WorkflowContext, error: Error) => void;
+    };
+}
+/**
+ * Workflow execution result
+ */
+interface FluxResult<TData = Record<string, unknown>> {
+    /** Workflow instance ID */
+    id: string;
+    /** Final status */
+    status: WorkflowStatus;
+    /** Accumulated data from all steps */
+    data: TData;
+    /** Step execution history */
+    history: StepExecution[];
+    /** Total execution duration (ms) */
+    duration: number;
+    /** Error if failed */
+    error?: Error;
+}
+
+export type { FluxConfig as F, StepDefinition as S, WorkflowDefinition as W, FluxLogger as a, FluxResult as b, FluxTraceEvent as c, FluxTraceEventType as d, FluxTraceSink as e, StepDescriptor as f, StepExecution as g, StepResult as h, WorkflowContext as i, WorkflowDescriptor as j, WorkflowFilter as k, WorkflowState as l, WorkflowStatus as m, WorkflowStorage as n };

package/package.json

@@ -1,30 +1,29 @@
 {
   "name": "@gravito/flux",
-  "version": "1.0.0-beta.2",
+  "version": "1.0.0-beta.4",
   "description": "Platform-agnostic workflow engine for Gravito",
   "type": "module",
-  "main": "./dist/node/index.cjs",
-  "module": "./dist/node/index.mjs",
+  "main": "./dist/index.node.cjs",
+  "module": "./dist/index.node.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
       "bun": {
-        "import": "./dist/index.js",
-        "types": "./dist/index.d.ts"
+        "import": "./dist/index.js"
       },
       "node": {
-        "import": "./dist/node/index.mjs",
-        "require": "./dist/node/index.cjs",
+        "import": "./dist/index.node.js",
+        "require": "./dist/index.node.cjs",
         "types": "./dist/index.node.d.ts"
       },
-      "import": "./dist/node/index.mjs",
-      "require": "./dist/node/index.cjs",
-      "types": "./dist/index.d.ts"
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
     },
     "./bun": {
+      "types": "./dist/bun.d.ts",
       "bun": {
-        "import": "./dist/bun.js",
-        "types": "./dist/bun.d.ts"
+        "import": "./dist/bun.js"
       }
     }
   },
@@ -34,29 +33,31 @@
   "files": [
     "dist",
     "README.md",
-    "README.zh-TW.md",
     "bin",
-    "dev"
+    "dev",
+    "assets"
   ],
   "scripts": {
-    "build": "bun run build.ts",
+    "build": "tsup",
     "dev:viewer": "node ./bin/flux.js dev --trace ./.flux/trace.ndjson --port 4280",
-    "typecheck": "tsc --noEmit",
-    "test": "bun test"
+    "typecheck": "bun tsc -p tsconfig.json --noEmit --skipLibCheck",
+    "test": "bun test",
+    "test:coverage": "bun test --coverage --coverage-threshold=80",
+    "test:ci": "bun test --coverage --coverage-threshold=80"
   },
   "peerDependencies": {
-    "gravito-core": "1.0.0-beta.6"
+    "@gravito/core": "workspace:*"
   },
   "peerDependenciesMeta": {
-    "gravito-core": {
+    "@gravito/core": {
       "optional": true
     }
   },
   "devDependencies": {
     "bun-types": "latest",
-    "gravito-core": "1.0.0-beta.6",
+    "@gravito/core": "workspace:*",
     "tsup": "^8.5.1",
-    "typescript": "^5.0.0"
+    "typescript": "^5.9.3"
   },
   "keywords": [
     "gravito",
@@ -72,5 +73,8 @@
     "type": "git",
     "url": "https://github.com/gravito-framework/gravito.git",
     "directory": "packages/flux"
+  },
+  "publishConfig": {
+    "access": "public"
   }
 }

package/dist/builder/WorkflowBuilder.d.ts

@@ -1,96 +0,0 @@
-/**
- * @fileoverview Workflow Builder - Fluent API for defining workflows
- *
- * Type-safe, chainable workflow definition.
- *
- * @module @gravito/flux/builder
- */
-import type { WorkflowContext, WorkflowDefinition } from '../types';
-/**
- * Step options
- */
-interface StepOptions {
-    retries?: number;
-    timeout?: number;
-    when?: (ctx: WorkflowContext) => boolean;
-}
-/**
- * Workflow Builder
- *
- * Provides fluent API for defining workflows with type inference.
- *
- * @example
- * ```typescript
- * const workflow = createWorkflow('order-process')
- *   .input<{ orderId: string }>()
- *   .step('validate', async (ctx) => {
- *     ctx.data.order = await fetchOrder(ctx.input.orderId)
- *   })
- *   .step('process', async (ctx) => {
- *     await processOrder(ctx.data.order)
- *   })
- *   .commit('notify', async (ctx) => {
- *     await sendEmail(ctx.data.order.email)
- *   })
- * ```
- */
-export declare class WorkflowBuilder<TInput = unknown> {
-    private _name;
-    private _steps;
-    private _validateInput?;
-    constructor(name: string);
-    /**
-     * Define input type
-     *
-     * This method is used for TypeScript type inference.
-     */
-    input<T>(): WorkflowBuilder<T>;
-    /**
-     * Add input validator
-     */
-    validate(validator: (input: unknown) => input is TInput): this;
-    /**
-     * Add a step to the workflow
-     */
-    step(name: string, handler: (ctx: WorkflowContext<TInput>) => Promise<void> | void, options?: StepOptions): this;
-    /**
-     * Add a commit step (always executes, even on replay)
-     *
-     * Commit steps are for side effects that should not be skipped,
-     * such as database writes or external API calls.
-     */
-    commit(name: string, handler: (ctx: WorkflowContext<TInput>) => Promise<void> | void, options?: StepOptions): this;
-    /**
-     * Build the workflow definition
-     */
-    build(): WorkflowDefinition<TInput>;
-    /**
-     * Get workflow name
-     */
-    get name(): string;
-    /**
-     * Get step count
-     */
-    get stepCount(): number;
-}
-/**
- * Create a new workflow builder
- *
- * @param name - Unique workflow name
- * @returns WorkflowBuilder instance
- *
- * @example
- * ```typescript
- * const uploadFlow = createWorkflow('image-upload')
- *   .input<{ file: Buffer }>()
- *   .step('resize', async (ctx) => {
- *     ctx.data.resized = await sharp(ctx.input.file).resize(200).toBuffer()
- *   })
- *   .commit('save', async (ctx) => {
- *     await storage.put(ctx.data.resized)
- *   })
- * ```
- */
-export declare function createWorkflow(name: string): WorkflowBuilder;
-export {};
-//# sourceMappingURL=WorkflowBuilder.d.ts.map

package/dist/builder/WorkflowBuilder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"WorkflowBuilder.d.ts","sourceRoot":"","sources":["../../src/builder/WorkflowBuilder.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAkB,eAAe,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAEnF;;GAEG;AACH,UAAU,WAAW;IACnB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,eAAe,KAAK,OAAO,CAAA;CACzC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,eAAe,CAAC,MAAM,GAAG,OAAO;IAC3C,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,cAAc,CAAC,CAAqC;gBAEhD,IAAI,EAAE,MAAM;IAIxB;;;;OAIG;IACH,KAAK,CAAC,CAAC,KAAK,eAAe,CAAC,CAAC,CAAC;IAI9B;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,KAAK,IAAI,MAAM,GAAG,IAAI;IAK9D;;OAEG;IACH,IAAI,CACF,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,CAAC,GAAG,EAAE,eAAe,CAAC,MAAM,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,EAC/D,OAAO,CAAC,EAAE,WAAW,GACpB,IAAI;IAYP;;;;;OAKG;IACH,MAAM,CACJ,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,CAAC,GAAG,EAAE,eAAe,CAAC,MAAM,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,EAC/D,OAAO,CAAC,EAAE,WAAW,GACpB,IAAI;IAYP;;OAEG;IACH,KAAK,IAAI,kBAAkB,CAAC,MAAM,CAAC;IAYnC;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,IAAI,SAAS,IAAI,MAAM,CAEtB;CACF;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,CAE5D"}

package/dist/builder/index.d.ts

@@ -1,2 +0,0 @@
-export { createWorkflow, WorkflowBuilder } from './WorkflowBuilder';
-//# sourceMappingURL=index.d.ts.map

package/dist/builder/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/builder/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA"}

package/dist/bun.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bun.d.ts","sourceRoot":"","sources":["../src/bun.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,gBAAgB,EAAE,KAAK,uBAAuB,EAAE,MAAM,4BAA4B,CAAA"}

package/dist/core/ContextManager.d.ts

@@ -1,40 +0,0 @@
-/**
- * @fileoverview Context Manager for workflow execution
- *
- * Manages workflow context lifecycle and state snapshots.
- *
- * @module @gravito/flux/core
- */
-import type { WorkflowContext, WorkflowState, WorkflowStatus } from '../types';
-/**
- * Context Manager
- *
- * Creates and manages workflow execution contexts.
- */
-export declare class ContextManager {
-    /**
-     * Create a new workflow context
-     */
-    create<TInput>(name: string, input: TInput, stepCount: number): WorkflowContext<TInput>;
-    /**
-     * Restore context from saved state
-     */
-    restore<TInput>(state: WorkflowState): WorkflowContext<TInput>;
-    /**
-     * Convert context to serializable state
-     */
-    toState(ctx: WorkflowContext): WorkflowState;
-    /**
-     * Update context status (returns new context for immutability)
-     */
-    updateStatus(ctx: WorkflowContext, status: WorkflowStatus): WorkflowContext;
-    /**
-     * Advance to next step
-     */
-    advanceStep(ctx: WorkflowContext): WorkflowContext;
-    /**
-     * Update step name in history
-     */
-    setStepName(ctx: WorkflowContext, index: number, name: string): void;
-}
-//# sourceMappingURL=ContextManager.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"ContextManager.d.ts","sourceRoot":"","sources":["../../src/core/ContextManager.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAiB,eAAe,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAS7F;;;;GAIG;AACH,qBAAa,cAAc;IACzB;;OAEG;IACH,MAAM,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,eAAe,CAAC,MAAM,CAAC;IAkBvF;;OAEG;IACH,OAAO,CAAC,MAAM,EAAE,KAAK,EAAE,aAAa,GAAG,eAAe,CAAC,MAAM,CAAC;IAY9D;;OAEG;IACH,OAAO,CAAC,GAAG,EAAE,eAAe,GAAG,aAAa;IAc5C;;OAEG;IACH,YAAY,CAAC,GAAG,EAAE,eAAe,EAAE,MAAM,EAAE,cAAc,GAAG,eAAe;IAO3E;;OAEG;IACH,WAAW,CAAC,GAAG,EAAE,eAAe,GAAG,eAAe;IAOlD;;OAEG;IACH,WAAW,CAAC,GAAG,EAAE,eAAe,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;CAKrE"}