@elaraai/e3-types 0.0.2-beta.4 → 0.0.2-beta.40

package/README.md

@@ -11,11 +11,14 @@ npm install @elaraai/e3-types
 ## Types
 
 - **Repository** - Repository configuration and paths
-- **Commit** - Task commit types (new, done, error)
-- **Task** - Task definition and state
 - **Package** - Package manifest and metadata
 - **Dataset** - Dataset schemas and paths
-- **Dataflow** - Dataflow definitions
+- **Task** - Task definition and configuration
+- **Dataflow** - Dataflow graph and execution state
+  - `TaskStateType` - Individual task execution state
+  - `DataflowGraphType` - Task dependency graph
+  - `ExecutionEventType` - Execution progress events
+  - `DataflowExecutionStateType` - Full execution state
 - **Runner** - Runner configuration
 
 
@@ -41,7 +44,7 @@ Dual AGPL-3.0 / Commercial. See [LICENSE.md](./LICENSE.md).
   - [@elaraai/e3](https://www.npmjs.com/package/@elaraai/e3): SDK for authoring e3 packages with typed tasks and pipelines
   - [@elaraai/e3-core](https://www.npmjs.com/package/@elaraai/e3-core): Git-like object store, task queue, result caching
   - [@elaraai/e3-types](https://www.npmjs.com/package/@elaraai/e3-types): Shared type definitions for e3 packages
-  - [@elaraai/e3-cli](https://www.npmjs.com/package/@elaraai/e3-cli): `e3 init`, `e3 run`, `e3 logs` commands for managing and monitoring tasks
+  - [@elaraai/e3-cli](https://www.npmjs.com/package/@elaraai/e3-cli): `e3 repo`, `e3 workspace`, `e3 start`, `e3 logs` commands for managing repositories, workspaces, and tasks
   - [@elaraai/e3-api-client](https://www.npmjs.com/package/@elaraai/e3-api-client): HTTP client for remote e3 servers
   - [@elaraai/e3-api-server](https://www.npmjs.com/package/@elaraai/e3-api-server): REST API server for e3 repositories
 

package/dist/src/dataflow.d.ts

@@ -0,0 +1,574 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Dataflow execution state type definitions.
+ *
+ * These types define the persistent state for dataflow execution,
+ * stored in workspaces/<ws>/execution.beast2
+ *
+ * Key design decisions:
+ * - Dates are Date objects (via DateTimeType), not strings
+ * - Events stored inline as array (single file, not separate JSONL)
+ * - Tasks stored as Dict (not Map) for beast2 compatibility
+ */
+import { StructType, VariantType, ArrayType, DictType, StringType, IntegerType, BooleanType, DateTimeType, OptionType, ValueTypeOf } from '@elaraai/east';
+/**
+ * Status of a dataflow execution.
+ */
+export type DataflowExecutionStatus = 'running' | 'completed' | 'failed' | 'cancelled';
+/**
+ * Status of an individual task within an execution.
+ */
+export type TaskStatus = 'pending' | 'ready' | 'in_progress' | 'completed' | 'failed' | 'skipped' | 'deferred';
+/**
+ * Information about a task's execution state.
+ *
+ * Stored in the tasks Dict of DataflowExecutionStateType.
+ */
+export declare const TaskStateType: StructType<{
+    /** Task name */
+    readonly name: StringType;
+    /** Current status (TaskStatus as string) */
+    readonly status: StringType;
+    /** Whether the result was served from cache */
+    readonly cached: OptionType<BooleanType>;
+    /** Output hash if completed successfully */
+    readonly outputHash: OptionType<StringType>;
+    /** Error message if failed */
+    readonly error: OptionType<StringType>;
+    /** Exit code if task process failed */
+    readonly exitCode: OptionType<IntegerType>;
+    /** When the task started */
+    readonly startedAt: OptionType<DateTimeType>;
+    /** When the task completed */
+    readonly completedAt: OptionType<DateTimeType>;
+    /** Duration in milliseconds */
+    readonly duration: OptionType<IntegerType>;
+}>;
+export type TaskState = ValueTypeOf<typeof TaskStateType>;
+/**
+ * A task within the dataflow graph.
+ */
+export declare const DataflowGraphTaskType: StructType<{
+    /** Task name */
+    readonly name: StringType;
+    /** Task object hash */
+    readonly hash: StringType;
+    /** Input dataset paths */
+    readonly inputs: ArrayType<StringType>;
+    /** Output dataset path */
+    readonly output: StringType;
+    /** Names of tasks this depends on */
+    readonly dependsOn: ArrayType<StringType>;
+}>;
+export type DataflowGraphTask = ValueTypeOf<typeof DataflowGraphTaskType>;
+/**
+ * The complete dataflow dependency graph.
+ */
+export declare const DataflowGraphType: StructType<{
+    /** All tasks in the graph */
+    readonly tasks: ArrayType<StructType<{
+        /** Task name */
+        readonly name: StringType;
+        /** Task object hash */
+        readonly hash: StringType;
+        /** Input dataset paths */
+        readonly inputs: ArrayType<StringType>;
+        /** Output dataset path */
+        readonly output: StringType;
+        /** Names of tasks this depends on */
+        readonly dependsOn: ArrayType<StringType>;
+    }>>;
+}>;
+export type DataflowGraph = ValueTypeOf<typeof DataflowGraphType>;
+/**
+ * Execution events (VariantType for discriminated union).
+ *
+ * Events track the progress of a dataflow execution and are stored
+ * inline in the execution state (not as a separate JSONL file).
+ */
+export declare const ExecutionEventType: VariantType<{
+    /** Execution started */
+    readonly execution_started: StructType<{
+        /** Event sequence number */
+        readonly seq: IntegerType;
+        /** When the event occurred */
+        readonly timestamp: DateTimeType;
+        /** Execution ID */
+        readonly executionId: StringType;
+        /** Total number of tasks in the graph */
+        readonly totalTasks: IntegerType;
+    }>;
+    /** Task became ready to execute */
+    readonly task_ready: StructType<{
+        /** Event sequence number */
+        readonly seq: IntegerType;
+        /** When the event occurred */
+        readonly timestamp: DateTimeType;
+        /** Task name */
+        readonly task: StringType;
+    }>;
+    /** Task execution started */
+    readonly task_started: StructType<{
+        /** Event sequence number */
+        readonly seq: IntegerType;
+        /** When the event occurred */
+        readonly timestamp: DateTimeType;
+        /** Task name */
+        readonly task: StringType;
+    }>;
+    /** Task completed successfully */
+    readonly task_completed: StructType<{
+        /** Event sequence number */
+        readonly seq: IntegerType;
+        /** When the event occurred */
+        readonly timestamp: DateTimeType;
+        /** Task name */
+        readonly task: StringType;
+        /** Whether the result was served from cache */
+        readonly cached: BooleanType;
+        /** Output hash */
+        readonly outputHash: StringType;
+        /** Duration in milliseconds */
+        readonly duration: IntegerType;
+    }>;
+    /** Task failed */
+    readonly task_failed: StructType<{
+        /** Event sequence number */
+        readonly seq: IntegerType;
+        /** When the event occurred */
+        readonly timestamp: DateTimeType;
+        /** Task name */
+        readonly task: StringType;
+        /** Error message */
+        readonly error: OptionType<StringType>;
+        /** Exit code if task process failed */
+        readonly exitCode: OptionType<IntegerType>;
+        /** Duration in milliseconds */
+        readonly duration: IntegerType;
+    }>;
+    /** Task was skipped due to upstream failure */
+    readonly task_skipped: StructType<{
+        /** Event sequence number */
+        readonly seq: IntegerType;
+        /** When the event occurred */
+        readonly timestamp: DateTimeType;
+        /** Task name */
+        readonly task: StringType;
+        /** Name of the upstream task that caused the skip */
+        readonly cause: StringType;
+    }>;
+    /** Execution completed */
+    readonly execution_completed: StructType<{
+        /** Event sequence number */
+        readonly seq: IntegerType;
+        /** When the event occurred */
+        readonly timestamp: DateTimeType;
+        /** Whether all tasks succeeded */
+        readonly success: BooleanType;
+        /** Number of tasks executed (not from cache) */
+        readonly executed: IntegerType;
+        /** Number of tasks served from cache */
+        readonly cached: IntegerType;
+        /** Number of tasks that failed */
+        readonly failed: IntegerType;
+        /** Number of tasks skipped */
+        readonly skipped: IntegerType;
+        /** Total duration in milliseconds */
+        readonly duration: IntegerType;
+    }>;
+    /** Execution was cancelled */
+    readonly execution_cancelled: StructType<{
+        /** Event sequence number */
+        readonly seq: IntegerType;
+        /** When the event occurred */
+        readonly timestamp: DateTimeType;
+        /** Reason for cancellation */
+        readonly reason: OptionType<StringType>;
+    }>;
+    /** An input dataset changed during execution (reactive dataflow) */
+    readonly input_changed: StructType<{
+        /** Event sequence number */
+        readonly seq: IntegerType;
+        /** When the event occurred */
+        readonly timestamp: DateTimeType;
+        /** Path of the changed input dataset */
+        readonly path: StringType;
+        /** Previous hash (empty string if was unassigned) */
+        readonly previousHash: StringType;
+        /** New hash */
+        readonly newHash: StringType;
+    }>;
+    /** A task was invalidated due to upstream input change */
+    readonly task_invalidated: StructType<{
+        /** Event sequence number */
+        readonly seq: IntegerType;
+        /** When the event occurred */
+        readonly timestamp: DateTimeType;
+        /** Task name */
+        readonly task: StringType;
+        /** Reason for invalidation */
+        readonly reason: StringType;
+    }>;
+    /** A task was deferred due to inconsistent input versions */
+    readonly task_deferred: StructType<{
+        /** Event sequence number */
+        readonly seq: IntegerType;
+        /** When the event occurred */
+        readonly timestamp: DateTimeType;
+        /** Task name */
+        readonly task: StringType;
+        /** Path where version conflict was detected */
+        readonly conflictPath: StringType;
+    }>;
+}>;
+export type ExecutionEvent = ValueTypeOf<typeof ExecutionEventType>;
+/**
+ * Persistent state for a dataflow execution.
+ *
+ * Stored in workspaces/<ws>/execution.beast2
+ *
+ * @remarks
+ * - Tasks are stored as a Dict (serializes as object, not array of tuples)
+ * - Events are stored inline (not as separate JSONL file)
+ * - Dates are Date objects (via DateTimeType)
+ */
+export declare const DataflowExecutionStateType: StructType<{
+    /** Unique execution ID (local: auto-increment, cloud: UUID) */
+    readonly id: StringType;
+    /** Repository identifier */
+    readonly repo: StringType;
+    /** Workspace name */
+    readonly workspace: StringType;
+    /** When the execution started */
+    readonly startedAt: DateTimeType;
+    /** Maximum concurrent task executions */
+    readonly concurrency: IntegerType;
+    /** Force re-execution even if cached */
+    readonly force: BooleanType;
+    /** Filter to run only specific task(s) by exact name */
+    readonly filter: OptionType<StringType>;
+    /** The dependency graph (for local execution) */
+    readonly graph: OptionType<StructType<{
+        /** All tasks in the graph */
+        readonly tasks: ArrayType<StructType<{
+            /** Task name */
+            readonly name: StringType;
+            /** Task object hash */
+            readonly hash: StringType;
+            /** Input dataset paths */
+            readonly inputs: ArrayType<StringType>;
+            /** Output dataset path */
+            readonly output: StringType;
+            /** Names of tasks this depends on */
+            readonly dependsOn: ArrayType<StringType>;
+        }>>;
+    }>>;
+    /** Hash/key referencing a separately stored graph (for cloud) */
+    readonly graphHash: OptionType<StringType>;
+    /** Map of task name -> task state */
+    readonly tasks: DictType<StringType, StructType<{
+        /** Task name */
+        readonly name: StringType;
+        /** Current status (TaskStatus as string) */
+        readonly status: StringType;
+        /** Whether the result was served from cache */
+        readonly cached: OptionType<BooleanType>;
+        /** Output hash if completed successfully */
+        readonly outputHash: OptionType<StringType>;
+        /** Error message if failed */
+        readonly error: OptionType<StringType>;
+        /** Exit code if task process failed */
+        readonly exitCode: OptionType<IntegerType>;
+        /** When the task started */
+        readonly startedAt: OptionType<DateTimeType>;
+        /** When the task completed */
+        readonly completedAt: OptionType<DateTimeType>;
+        /** Duration in milliseconds */
+        readonly duration: OptionType<IntegerType>;
+    }>>;
+    /** Number of tasks executed (not from cache) */
+    readonly executed: IntegerType;
+    /** Number of tasks served from cache */
+    readonly cached: IntegerType;
+    /** Number of tasks that failed */
+    readonly failed: IntegerType;
+    /** Number of tasks skipped due to upstream failure */
+    readonly skipped: IntegerType;
+    /** Current execution status */
+    readonly status: StringType;
+    /** When the execution completed */
+    readonly completedAt: OptionType<DateTimeType>;
+    /** Error message if status is 'failed' */
+    readonly error: OptionType<StringType>;
+    /** Version vectors: dataset keypath -> VersionVector (root input path -> hash) */
+    readonly versionVectors: DictType<StringType, DictType<StringType, StringType>>;
+    /** Input snapshot: root input keypath -> hash at time of last check */
+    readonly inputSnapshot: DictType<StringType, StringType>;
+    /** Set of dataset keypaths that are task outputs */
+    readonly taskOutputPaths: ArrayType<StringType>;
+    /** Number of tasks re-executed due to input changes */
+    readonly reexecuted: IntegerType;
+    /** All events for this execution */
+    readonly events: ArrayType<VariantType<{
+        /** Execution started */
+        readonly execution_started: StructType<{
+            /** Event sequence number */
+            readonly seq: IntegerType;
+            /** When the event occurred */
+            readonly timestamp: DateTimeType;
+            /** Execution ID */
+            readonly executionId: StringType;
+            /** Total number of tasks in the graph */
+            readonly totalTasks: IntegerType;
+        }>;
+        /** Task became ready to execute */
+        readonly task_ready: StructType<{
+            /** Event sequence number */
+            readonly seq: IntegerType;
+            /** When the event occurred */
+            readonly timestamp: DateTimeType;
+            /** Task name */
+            readonly task: StringType;
+        }>;
+        /** Task execution started */
+        readonly task_started: StructType<{
+            /** Event sequence number */
+            readonly seq: IntegerType;
+            /** When the event occurred */
+            readonly timestamp: DateTimeType;
+            /** Task name */
+            readonly task: StringType;
+        }>;
+        /** Task completed successfully */
+        readonly task_completed: StructType<{
+            /** Event sequence number */
+            readonly seq: IntegerType;
+            /** When the event occurred */
+            readonly timestamp: DateTimeType;
+            /** Task name */
+            readonly task: StringType;
+            /** Whether the result was served from cache */
+            readonly cached: BooleanType;
+            /** Output hash */
+            readonly outputHash: StringType;
+            /** Duration in milliseconds */
+            readonly duration: IntegerType;
+        }>;
+        /** Task failed */
+        readonly task_failed: StructType<{
+            /** Event sequence number */
+            readonly seq: IntegerType;
+            /** When the event occurred */
+            readonly timestamp: DateTimeType;
+            /** Task name */
+            readonly task: StringType;
+            /** Error message */
+            readonly error: OptionType<StringType>;
+            /** Exit code if task process failed */
+            readonly exitCode: OptionType<IntegerType>;
+            /** Duration in milliseconds */
+            readonly duration: IntegerType;
+        }>;
+        /** Task was skipped due to upstream failure */
+        readonly task_skipped: StructType<{
+            /** Event sequence number */
+            readonly seq: IntegerType;
+            /** When the event occurred */
+            readonly timestamp: DateTimeType;
+            /** Task name */
+            readonly task: StringType;
+            /** Name of the upstream task that caused the skip */
+            readonly cause: StringType;
+        }>;
+        /** Execution completed */
+        readonly execution_completed: StructType<{
+            /** Event sequence number */
+            readonly seq: IntegerType;
+            /** When the event occurred */
+            readonly timestamp: DateTimeType;
+            /** Whether all tasks succeeded */
+            readonly success: BooleanType;
+            /** Number of tasks executed (not from cache) */
+            readonly executed: IntegerType;
+            /** Number of tasks served from cache */
+            readonly cached: IntegerType;
+            /** Number of tasks that failed */
+            readonly failed: IntegerType;
+            /** Number of tasks skipped */
+            readonly skipped: IntegerType;
+            /** Total duration in milliseconds */
+            readonly duration: IntegerType;
+        }>;
+        /** Execution was cancelled */
+        readonly execution_cancelled: StructType<{
+            /** Event sequence number */
+            readonly seq: IntegerType;
+            /** When the event occurred */
+            readonly timestamp: DateTimeType;
+            /** Reason for cancellation */
+            readonly reason: OptionType<StringType>;
+        }>;
+        /** An input dataset changed during execution (reactive dataflow) */
+        readonly input_changed: StructType<{
+            /** Event sequence number */
+            readonly seq: IntegerType;
+            /** When the event occurred */
+            readonly timestamp: DateTimeType;
+            /** Path of the changed input dataset */
+            readonly path: StringType;
+            /** Previous hash (empty string if was unassigned) */
+            readonly previousHash: StringType;
+            /** New hash */
+            readonly newHash: StringType;
+        }>;
+        /** A task was invalidated due to upstream input change */
+        readonly task_invalidated: StructType<{
+            /** Event sequence number */
+            readonly seq: IntegerType;
+            /** When the event occurred */
+            readonly timestamp: DateTimeType;
+            /** Task name */
+            readonly task: StringType;
+            /** Reason for invalidation */
+            readonly reason: StringType;
+        }>;
+        /** A task was deferred due to inconsistent input versions */
+        readonly task_deferred: StructType<{
+            /** Event sequence number */
+            readonly seq: IntegerType;
+            /** When the event occurred */
+            readonly timestamp: DateTimeType;
+            /** Task name */
+            readonly task: StringType;
+            /** Path where version conflict was detected */
+            readonly conflictPath: StringType;
+        }>;
+    }>>;
+    /** Sequence number for next event (auto-increment) */
+    readonly eventSeq: IntegerType;
+}>;
+export type DataflowExecutionState = ValueTypeOf<typeof DataflowExecutionStateType>;
+/**
+ * Status of a dataflow run.
+ */
+export declare const DataflowRunStatusType: VariantType<{
+    /** Run is currently executing */
+    readonly running: StructType<{}>;
+    /** Run completed successfully */
+    readonly completed: StructType<{}>;
+    /** Run failed with a task error */
+    readonly failed: StructType<{
+        /** Name of the task that failed */
+        readonly failedTask: StringType;
+        /** Error message */
+        readonly error: StringType;
+    }>;
+    /** Run was cancelled */
+    readonly cancelled: StructType<{}>;
+}>;
+export type DataflowRunStatus = ValueTypeOf<typeof DataflowRunStatusType>;
+/**
+ * Record of a task execution within a dataflow run.
+ */
+export declare const TaskExecutionRecordType: StructType<{
+    /** Execution ID (UUIDv7) */
+    readonly executionId: StringType;
+    /** Whether this was a cache hit */
+    readonly cached: BooleanType;
+    /** Output version vector (which root input versions produced this output) */
+    readonly outputVersions: DictType<StringType, StringType>;
+    /** Number of times this task was executed (including re-executions due to input changes) */
+    readonly executionCount: IntegerType;
+}>;
+export type TaskExecutionRecord = ValueTypeOf<typeof TaskExecutionRecordType>;
+/**
+ * Summary statistics for a dataflow run.
+ */
+export declare const DataflowRunSummaryType: StructType<{
+    /** Total number of tasks */
+    readonly total: IntegerType;
+    /** Number of completed tasks */
+    readonly completed: IntegerType;
+    /** Number of cached tasks */
+    readonly cached: IntegerType;
+    /** Number of failed tasks */
+    readonly failed: IntegerType;
+    /** Number of skipped tasks */
+    readonly skipped: IntegerType;
+    /** Number of tasks re-executed due to input changes */
+    readonly reexecuted: IntegerType;
+}>;
+export type DataflowRunSummary = ValueTypeOf<typeof DataflowRunSummaryType>;
+/**
+ * A dataflow run record, tracking one execution of a workspace's dataflow.
+ *
+ * Stored in: dataflows/<workspace>/<runId>.beast2
+ *
+ * This provides execution history and provenance tracking:
+ * - Which tasks ran and which were cached
+ * - Input/output snapshots for reproducibility
+ * - Timing information for performance analysis
+ */
+export declare const DataflowRunType: StructType<{
+    /** Run ID (UUIDv7) */
+    readonly runId: StringType;
+    /** Workspace name */
+    readonly workspaceName: StringType;
+    /** Package reference at run time (name@version) */
+    readonly packageRef: StringType;
+    /** When the run started */
+    readonly startedAt: DateTimeType;
+    /** When the run completed (null if still running) */
+    readonly completedAt: OptionType<DateTimeType>;
+    /** Current status of the run */
+    readonly status: VariantType<{
+        /** Run is currently executing */
+        readonly running: StructType<{}>;
+        /** Run completed successfully */
+        readonly completed: StructType<{}>;
+        /** Run failed with a task error */
+        readonly failed: StructType<{
+            /** Name of the task that failed */
+            readonly failedTask: StringType;
+            /** Error message */
+            readonly error: StringType;
+        }>;
+        /** Run was cancelled */
+        readonly cancelled: StructType<{}>;
+    }>;
+    /** Input version snapshot at start (root input path -> hash) */
+    readonly inputVersions: DictType<StringType, StringType>;
+    /** Output version snapshot at end (null if still running) */
+    readonly outputVersions: OptionType<DictType<StringType, StringType>>;
+    /** Map of task name -> execution record */
+    readonly taskExecutions: DictType<StringType, StructType<{
+        /** Execution ID (UUIDv7) */
+        readonly executionId: StringType;
+        /** Whether this was a cache hit */
+        readonly cached: BooleanType;
+        /** Output version vector (which root input versions produced this output) */
+        readonly outputVersions: DictType<StringType, StringType>;
+        /** Number of times this task was executed (including re-executions due to input changes) */
+        readonly executionCount: IntegerType;
+    }>>;
+    /** Summary statistics */
+    readonly summary: StructType<{
+        /** Total number of tasks */
+        readonly total: IntegerType;
+        /** Number of completed tasks */
+        readonly completed: IntegerType;
+        /** Number of cached tasks */
+        readonly cached: IntegerType;
+        /** Number of failed tasks */
+        readonly failed: IntegerType;
+        /** Number of skipped tasks */
+        readonly skipped: IntegerType;
+        /** Number of tasks re-executed due to input changes */
+        readonly reexecuted: IntegerType;
+    }>;
+}>;
+export type DataflowRun = ValueTypeOf<typeof DataflowRunType>;
+//# sourceMappingURL=dataflow.d.ts.map

package/dist/src/dataflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataflow.d.ts","sourceRoot":"","sources":["../../src/dataflow.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;GAUG;AAEH,OAAO,EACL,UAAU,EACV,WAAW,EACX,SAAS,EACT,QAAQ,EACR,UAAU,EACV,WAAW,EACX,WAAW,EACX,YAAY,EACZ,UAAU,EACV,WAAW,EACZ,MAAM,eAAe,CAAC;AAMvB;;GAEG;AACH,MAAM,MAAM,uBAAuB,GAAG,SAAS,GAAG,WAAW,GAAG,QAAQ,GAAG,WAAW,CAAC;AAEvF;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,OAAO,GAAG,aAAa,GAAG,WAAW,GAAG,QAAQ,GAAG,SAAS,GAAG,UAAU,CAAC;AAM/G;;;;GAIG;AACH,eAAO,MAAM,aAAa;IACxB,gBAAgB;;IAEhB,4CAA4C;;IAE5C,+CAA+C;;IAE/C,4CAA4C;;IAE5C,8BAA8B;;IAE9B,uCAAuC;;IAEvC,4BAA4B;;IAE5B,8BAA8B;;IAE9B,+BAA+B;;EAE/B,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,WAAW,CAAC,OAAO,aAAa,CAAC,CAAC;AAM1D;;GAEG;AACH,eAAO,MAAM,qBAAqB;IAChC,gBAAgB;;IAEhB,uBAAuB;;IAEvB,0BAA0B;;IAE1B,0BAA0B;;IAE1B,qCAAqC;;EAErC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,WAAW,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE1E;;GAEG;AACH,eAAO,MAAM,iBAAiB;IAC5B,6BAA6B;;QAjB7B,gBAAgB;;QAEhB,uBAAuB;;QAEvB,0BAA0B;;QAE1B,0BAA0B;;QAE1B,qCAAqC;;;EAWrC,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,WAAW,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAMlE;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB;IAC7B,wBAAwB;;QAEtB,4BAA4B;;QAE5B,8BAA8B;;QAE9B,mBAAmB;;QAEnB,yCAAyC;;;IAG3C,mCAAmC;;QAEjC,4BAA4B;;QAE5B,8BAA8B;;QAE9B,gBAAgB;;;IAGlB,6BAA6B;;QAE3B,4BAA4B;;QAE5B,8BAA8B;;QAE9B,gBAAgB;;;IAGlB,kCAAkC;;QAEhC,4BAA4B;;QAE5B,8BAA8B;;QAE9B,gBAAgB;;QAEhB,+CAA+C;;QAE/C,kBAAkB;;QAElB,+BAA+B;;;IAGjC,kBAAkB;;QAEhB,4BAA4B;;QAE5B,8BAA8B;;QAE9B,gBAAgB;;QAEhB,oBAAoB;;QAEpB,uCAAuC;;QAEvC,+BAA+B;;;IAGjC,+CAA+C;;QAE7C,4BAA4B;;QAE5B,8BAA8B;;QAE9B,gBAAgB;;QAEhB,qDAAqD;;;IAGvD,0BAA0B;;QAExB,4BAA4B;;QAE5B,8BAA8B;;QAE9B,kCAAkC;;QAElC,gDAAgD;;QAEhD,wCAAwC;;QAExC,kCAAkC;;QAElC,8BAA8B;;QAE9B,qCAAqC;;;IAGvC,8BAA8B;;QAE5B,4BAA4B;;QAE5B,8BAA8B;;QAE9B,8BAA8B;;;IAGhC,oEAAoE;;QAElE,4BAA4B;;QAE5B,8BAA8B;;QAE9B,wCAAwC;;QAExC,qDAAqD;;QAErD,eAAe;;;IAGjB,0DAA0D;;QAExD,4BAA4B;;QAE5B,8BAA8B;;QAE9B,gBAAgB;;QAEhB,8BAA8B;;;IAGhC,6DAA6D;;QAE3D,4BAA4B;;QAE5B,8BAA8B;;QAE9B,gBAAgB;;QAEhB,+CAA+C;;;EAGjD,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,WAAW,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAMpE;;;;;;;;;GASG;AACH,eAAO,MAAM,0BAA0B;IAErC,+DAA+D;;IAE/D,4BAA4B;;IAE5B,qBAAqB;;IAErB,iCAAiC;;IAIjC,yCAAyC;;IAEzC,wCAAwC;;IAExC,wDAAwD;;IAIxD,iDAAiD;;QA1LjD,6BAA6B;;YAjB7B,gBAAgB;;YAEhB,uBAAuB;;YAEvB,0BAA0B;;YAE1B,0BAA0B;;YAE1B,qCAAqC;;;;IAqMrC,iEAAiE;;IAIjE,qCAAqC;;QA9OrC,gBAAgB;;QAEhB,4CAA4C;;QAE5C,+CAA+C;;QAE/C,4CAA4C;;QAE5C,8BAA8B;;QAE9B,uCAAuC;;QAEvC,4BAA4B;;QAE5B,8BAA8B;;QAE9B,+BAA+B;;;IAkO/B,gDAAgD;;IAEhD,wCAAwC;;IAExC,kCAAkC;;IAElC,sDAAsD;;IAItD,+BAA+B;;IAE/B,mCAAmC;;IAEnC,0CAA0C;;IAI1C,kFAAkF;;IAElF,uEAAuE;;IAEvE,oDAAoD;;IAEpD,uDAAuD;;IAIvD,oCAAoC;;QAhNpC,wBAAwB;;YAEtB,4BAA4B;;YAE5B,8BAA8B;;YAE9B,mBAAmB;;YAEnB,yCAAyC;;;QAG3C,mCAAmC;;YAEjC,4BAA4B;;YAE5B,8BAA8B;;YAE9B,gBAAgB;;;QAGlB,6BAA6B;;YAE3B,4BAA4B;;YAE5B,8BAA8B;;YAE9B,gBAAgB;;;QAGlB,kCAAkC;;YAEhC,4BAA4B;;YAE5B,8BAA8B;;YAE9B,gBAAgB;;YAEhB,+CAA+C;;YAE/C,kBAAkB;;YAElB,+BAA+B;;;QAGjC,kBAAkB;;YAEhB,4BAA4B;;YAE5B,8BAA8B;;YAE9B,gBAAgB;;YAEhB,oBAAoB;;YAEpB,uCAAuC;;YAEvC,+BAA+B;;;QAGjC,+CAA+C;;YAE7C,4BAA4B;;YAE5B,8BAA8B;;YAE9B,gBAAgB;;YAEhB,qDAAqD;;;QAGvD,0BAA0B;;YAExB,4BAA4B;;YAE5B,8BAA8B;;YAE9B,kCAAkC;;YAElC,gDAAgD;;YAEhD,wCAAwC;;YAExC,kCAAkC;;YAElC,8BAA8B;;YAE9B,qCAAqC;;;QAGvC,8BAA8B;;YAE5B,4BAA4B;;YAE5B,8BAA8B;;YAE9B,8BAA8B;;;QAGhC,oEAAoE;;YAElE,4BAA4B;;YAE5B,8BAA8B;;YAE9B,wCAAwC;;YAExC,qDAAqD;;YAErD,eAAe;;;QAGjB,0DAA0D;;YAExD,4BAA4B;;YAE5B,8BAA8B;;YAE9B,gBAAgB;;YAEhB,8BAA8B;;;QAGhC,6DAA6D;;YAE3D,4BAA4B;;YAE5B,8BAA8B;;YAE9B,gBAAgB;;YAEhB,+CAA+C;;;;IAgFjD,sDAAsD;;EAEtD,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,WAAW,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAMpF;;GAEG;AACH,eAAO,MAAM,qBAAqB;IAChC,iCAAiC;;IAEjC,iCAAiC;;IAEjC,mCAAmC;;QAEjC,mCAAmC;;QAEnC,oBAAoB;;;IAGtB,wBAAwB;;EAExB,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,WAAW,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE1E;;GAEG;AACH,eAAO,MAAM,uBAAuB;IAClC,4BAA4B;;IAE5B,mCAAmC;;IAEnC,6EAA6E;;IAE7E,4FAA4F;;EAE5F,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,WAAW,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE9E;;GAEG;AACH,eAAO,MAAM,sBAAsB;IACjC,4BAA4B;;IAE5B,gCAAgC;;IAEhC,6BAA6B;;IAE7B,6BAA6B;;IAE7B,8BAA8B;;IAE9B,uDAAuD;;EAEvD,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,WAAW,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE5E;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe;IAC1B,sBAAsB;;IAEtB,qBAAqB;;IAErB,mDAAmD;;IAGnD,2BAA2B;;IAE3B,qDAAqD;;IAGrD,gCAAgC;;QAzEhC,iCAAiC;;QAEjC,iCAAiC;;QAEjC,mCAAmC;;YAEjC,mCAAmC;;YAEnC,oBAAoB;;;QAGtB,wBAAwB;;;IAiExB,gEAAgE;;IAEhE,6DAA6D;;IAG7D,2CAA2C;;QA7D3C,4BAA4B;;QAE5B,mCAAmC;;QAEnC,6EAA6E;;QAE7E,4FAA4F;;;IA0D5F,yBAAyB;;QAjDzB,4BAA4B;;QAE5B,gCAAgC;;QAEhC,6BAA6B;;QAE7B,6BAA6B;;QAE7B,8BAA8B;;QAE9B,uDAAuD;;;EAyCvD,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,WAAW,CAAC,OAAO,eAAe,CAAC,CAAC"}