@memberjunction/ng-task-graph-editor 0.0.0 → 6.1.0-edge.2

package/dist/lib/task-graph-editor.component.d.ts

@@ -0,0 +1,230 @@
+/**
+ * @fileoverview View and edit a `TaskGraphSpec` on a canvas.
+ *
+ * **What makes this reusable is its subject.** It edits `TaskGraphSpec` — the one fully-qualified
+ * graph contract every producer in the program already authors against (D16) — rather than any
+ * particular persistence. A design-time flow, a graph an agent emitted at runtime, a stored workflow
+ * definition and a graph a person is drawing from scratch are all the same type here, so one
+ * component serves the Flow Agent editor, the Agent Run admin view, conversation plan cards, the
+ * Tasks view, and anything downstream.
+ *
+ * The alternative — teaching the existing agent editor a second dialect — is precisely how the two
+ * graph models drifted apart before Phase 4 pulled them onto one traversal engine.
+ *
+ * **Layer: `widgets` (L1/L2).** No `@angular/router`, no `@memberjunction/ng-shared`, no
+ * `NavigationService`. Route-derived state arrives as `@Input()`; navigation *intent* leaves as an
+ * `@Output()` the host acts on, because a widget cannot know whether it is inside Explorer, a
+ * downstream app, or an embedded panel. See `guides/UI_LAYERING_GUIDE.md`.
+ *
+ * **Validation is the engine's.** Cycles, unknown dependency refs and assignment conflicts are
+ * reported by calling `ValidateTaskGraphSpec` from `@memberjunction/ai-core-plus` — the same
+ * function `LoopAgentType` and `TaskGraphService.Submit` call. A second implementation here would be
+ * a second definition of "valid", and the graph that passes on the canvas would be free to fail at
+ * submission.
+ *
+ * @module @memberjunction/ng-task-graph-editor
+ */
+import { EventEmitter, OnDestroy } from '@angular/core';
+import { BaseAngularComponent } from '@memberjunction/ng-base-types';
+import { type TaskGraphSpec, type TaskGraphSpecNode, type TaskGraphValidationError } from '@memberjunction/ai-core-plus';
+import { FlowEditorComponent } from '@memberjunction/ng-flow-editor';
+import type { FlowConnection, FlowConnectionCreatedEvent, FlowLayoutDirection, FlowNode, FlowNodeAddedEvent, FlowNodeMovedEvent, FlowNodeTypeConfig, FlowPosition } from '@memberjunction/ng-flow-editor';
+import { type TaskGraphRuntimeStatus } from './task-graph-canvas-adapter';
+import type { DependencyConditionChangeRequestedEventArgs, TaskPropertyChangeRequestedEventArgs } from './task-graph-properties-panel.component';
+import { AfterDependencyAddedEventArgs, AfterDependencyRemovedEventArgs, AfterTaskAddedEventArgs, AfterTaskRemovedEventArgs, AfterTaskUpdatedEventArgs, AgentOpenRequestedEventArgs, BeforeDependencyAddedEventArgs, BeforeDependencyRemovedEventArgs, BeforeTaskAddedEventArgs, BeforeTaskRemovedEventArgs, BeforeTaskUpdatedEventArgs, RecordOpenRequestedEventArgs, TaskGraphSelectionChangedEventArgs, TaskGraphSpecChangedEventArgs, TaskGraphValidationChangedEventArgs } from './task-graph-editor-events';
+import * as i0 from "@angular/core";
+export declare class TaskGraphEditorComponent extends BaseAngularComponent implements OnDestroy {
+    /**
+     * The graph to show. Setter-based rather than `ngOnChanges` (repo convention): the reaction is
+     * explicit, runs only when this property changes, and costs nothing on other change-detection
+     * passes.
+     */
+    set Spec(value: TaskGraphSpec | null);
+    get Spec(): TaskGraphSpec | null;
+    /**
+     * Live per-task state, keyed by `tempId`. Supplying it turns the canvas into a runtime view of
+     * the same graph — the convergence point the program was aiming at: one renderer for design time
+     * and run time, rather than an editor and a separate Gantt that can disagree.
+     */
+    set RuntimeStatus(value: TaskGraphRuntimeStatus | null);
+    get RuntimeStatus(): TaskGraphRuntimeStatus | null;
+    /**
+     * Geometry for the nodes, keyed by `tempId`. Supplying it places the graph instead of laying it
+     * out.
+     *
+     * **Why a host must be able to supply this.** The spec has no layout field, so without it every
+     * node projects to the origin — all of them, stacked in one place — and the canvas is left to
+     * rescue the situation with a deferred Dagre pass. That pass is fine in the editor, where the
+     * author is present and can rearrange. It was not fine in the RUN views, which held the real
+     * geometry (a workflow's authored positions, or a computed layout) and had no way to hand it
+     * over: every run rendered its steps piled on the origin, and the zoom-to-fit that followed
+     * fitted a bounding box one node wide and blew the viewport up past 250%.
+     *
+     * Applied as the starting geometry only. Once the canvas reports positions of its own — a drag,
+     * an arrange — those win, because the person moving a node is the authority on where it goes.
+     */
+    set NodePositions(value: ReadonlyMap<string, FlowPosition> | null);
+    /** Read-only mode. The same component is the viewer — there is no second, weaker renderer. */
+    ReadOnly: boolean;
+    ShowToolbar: boolean;
+    ShowPalette: boolean;
+    ShowMinimap: boolean;
+    ShowStatusBar: boolean;
+    AutoLayoutDirection: FlowLayoutDirection;
+    /**
+     * Whether the properties panel rides alongside the canvas.
+     *
+     * On by default, because without it a step added from the palette can never be named or
+     * assigned — the canvas draws structure, the panel supplies content, and one without the other
+     * is a graph the author can build but not finish. Hosts embedding the read-only viewer in a chat
+     * card turn it off.
+     */
+    ShowProperties: boolean;
+    /**
+     * Agent names offered when assigning a step. Supplied by the host, which owns data access —
+     * this is a widgets-layer component and does not query.
+     */
+    AvailableAgentNames: readonly string[];
+    /** Action names offered when assigning a step. Same ownership rule as `AvailableAgentNames`. */
+    AvailableActionNames: readonly string[];
+    /** Shown when there is nothing to draw yet. */
+    EmptyStateMessage: string;
+    BeforeTaskAdded: EventEmitter<BeforeTaskAddedEventArgs>;
+    AfterTaskAdded: EventEmitter<AfterTaskAddedEventArgs>;
+    BeforeTaskRemoved: EventEmitter<BeforeTaskRemovedEventArgs>;
+    AfterTaskRemoved: EventEmitter<AfterTaskRemovedEventArgs>;
+    BeforeTaskUpdated: EventEmitter<BeforeTaskUpdatedEventArgs>;
+    AfterTaskUpdated: EventEmitter<AfterTaskUpdatedEventArgs>;
+    BeforeDependencyAdded: EventEmitter<BeforeDependencyAddedEventArgs>;
+    AfterDependencyAdded: EventEmitter<AfterDependencyAddedEventArgs>;
+    BeforeDependencyRemoved: EventEmitter<BeforeDependencyRemovedEventArgs>;
+    AfterDependencyRemoved: EventEmitter<AfterDependencyRemovedEventArgs>;
+    /** Informational — no `Before` pair, because these report what already happened. */
+    SpecChanged: EventEmitter<TaskGraphSpecChangedEventArgs>;
+    SelectionChanged: EventEmitter<TaskGraphSelectionChangedEventArgs>;
+    ValidationChanged: EventEmitter<TaskGraphValidationChangedEventArgs>;
+    /** Intent-only — the host navigates; this widget has no Router and must not acquire one. */
+    AgentOpenRequested: EventEmitter<AgentOpenRequestedEventArgs>;
+    RecordOpenRequested: EventEmitter<RecordOpenRequestedEventArgs>;
+    Nodes: FlowNode[];
+    Connections: FlowConnection[];
+    NodeTypes: FlowNodeTypeConfig[];
+    SelectedTask: TaskGraphSpecNode | null;
+    ValidationErrors: readonly TaskGraphValidationError[];
+    IsValid: boolean;
+    protected canvas: FlowEditorComponent | undefined;
+    private currentSpec;
+    private currentRuntime;
+    get IsEmpty(): boolean;
+    /** Re-runs validation and emits the result. Idempotent. */
+    Validate(): TaskGraphValidationChangedEventArgs;
+    /** Adds a task. Returns the new task, or null when a host vetoed it. */
+    AddTask(partial?: Partial<TaskGraphSpecNode>): TaskGraphSpecNode | null;
+    /** Removes a task and every edge into it. Returns false when a host vetoed it. */
+    RemoveTask(tempId: string): boolean;
+    /** Replaces a task's properties. Returns false when a host vetoed it. */
+    UpdateTask(tempId: string, next: TaskGraphSpecNode): boolean;
+    /**
+     * Adds a dependency edge. Returns false when it was vetoed **or would create a cycle**.
+     *
+     * The cycle is refused unconditionally, not merely reported: a cyclic graph can never execute —
+     * nothing would ever become eligible — so allowing the canvas to draw one would let a user build
+     * something the engine must then reject. Better to refuse the stroke than to accept a graph that
+     * cannot run.
+     */
+    AddDependency(fromTempId: string, toTempId: string, condition?: string): boolean;
+    /** Removes a dependency edge. Returns false when a host vetoed it. */
+    RemoveDependency(fromTempId: string, toTempId: string): boolean;
+    /**
+     * Sets — or with an empty string, clears — a dependency edge's condition.
+     *
+     * Implemented as remove-then-add so it travels the same `Before*`/`After*` path as any other
+     * edge change. A separate silent mutation would be a second write path into the spec, and the
+     * veto contract would then be right in one place and wrong in the other.
+     */
+    SetDependencyCondition(fromTempId: string, toTempId: string, condition: string): boolean;
+    /** Asks the host to open the agent behind a task. */
+    RequestAgentOpen(task: TaskGraphSpecNode): void;
+    /** Asks the host to open a record the graph references. */
+    RequestRecordOpen(entityName: string, recordID: string): void;
+    OnNodeSelected(node: FlowNode | null): void;
+    /**
+     * A palette entry was clicked or dragged onto the canvas.
+     *
+     * **This binding is the bug.** The canvas has always emitted `NodeAdded` for a palette drop, and
+     * this component simply never listened — so the node the canvas announced was thrown away, the
+     * spec never gained a task, and the author was told "a task graph must contain at least one
+     * task" no matter how many times they tried to add one. The canvas does not mutate its own
+     * `Nodes` on purpose (the host owns the model); an unheard event is therefore a silent no-op
+     * rather than a visible failure, which is why it survived.
+     *
+     * The new step is selected immediately: it lands unnamed and, for an agent or action step with
+     * nothing available to default to, unassigned — so the properties panel is where the author has
+     * to go next, and putting them there beats making them find it.
+     */
+    OnNodeAdded(event: FlowNodeAddedEvent): void;
+    /** Applies a properties-panel edit through the same vetoable path a canvas edit takes. */
+    OnTaskPropertyChangeRequested(args: TaskPropertyChangeRequestedEventArgs): void;
+    /** Applies a properties-panel edge-condition edit. */
+    OnDependencyConditionChangeRequested(args: DependencyConditionChangeRequestedEventArgs): void;
+    OnConnectionCreated(event: FlowConnectionCreatedEvent): void;
+    OnConnectionRemoved(connection: FlowConnection): void;
+    OnNodeRemoved(node: FlowNode): void;
+    private findTask;
+    private selectTask;
+    /** Applies a new spec, re-projects, re-validates, and tells the host — in that order. */
+    private commit;
+    /** Re-derives the canvas from the spec. Validation rides along so the two never disagree. */
+    private project;
+    /**
+     * Lays the graph out ONCE — when it arrives with no geometry of its own.
+     *
+     * A `TaskGraphSpec` carries no positions, so a spec opened for the first time projects with
+     * every node at the origin and needs Dagre to make it readable. After that the author's layout
+     * is the layout: `knownPositions` carries it across re-projections, and re-arranging again would
+     * throw away the arrangement they just made.
+     *
+     * It must also not run on every edit, because `AutoArrange` ends in `ZoomToFit` — so arranging
+     * per change meant the viewport snapped to fit after every added step and every drawn
+     * connection, which on a one-node graph zooms to maximum. That is the behaviour being fixed
+     * here; the rule mirrors the Flow Agent editor's (`flow-agent-editor.component.ts`), which has
+     * always arranged only when every node sits at the origin.
+     */
+    private arrangeIfNeverLaidOut;
+    /**
+     * Fits the viewport to the graph, once the canvas has drawn it.
+     *
+     * Deferred for the same reason the layout pass is: `fitToScreen` measures the rendered nodes, so
+     * calling it in the same turn as the projection fits whatever was on screen a moment ago. With
+     * every node still at the origin that bounding box is a single node wide, and "fit" means zoom
+     * to ~265% — the symptom that made a four-step workflow look like one enormous box.
+     */
+    private zoomToFitSoon;
+    /**
+     * The canvas is the authority on geometry, so remember what it reports.
+     *
+     * Without this the spec — which has no geometry field — is the only survivor of a re-projection,
+     * and every edit silently moved every node back to the origin. That is what forced a re-arrange
+     * (and therefore a re-zoom) on each change.
+     */
+    OnNodesChanged(nodes: FlowNode[]): void;
+    /** A single node was dragged. Same authority, narrower event. */
+    OnNodeMoved(event: FlowNodeMovedEvent): void;
+    ngOnDestroy(): void;
+    /** The topology the current layout was computed for; '' when nothing has been laid out. */
+    /**
+     * Node geometry, which the spec cannot hold.
+     *
+     * `TaskGraphSpec` is an execution contract with no layout field, so a re-projection would
+     * otherwise return every node to the origin. Keyed by `tempId`; written from the canvas
+     * (`NodesChanged` / `NodeMoved`) and from the drop position of a newly added node, and read back
+     * by `SpecToNodes` on every projection.
+     */
+    private readonly knownPositions;
+    /** Whether the one-time Dagre pass has run (or been made unnecessary by a hand-placed node). */
+    private hasLaidOut;
+    private pendingLayout;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaskGraphEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TaskGraphEditorComponent, "mj-task-graph-editor", never, { "Spec": { "alias": "Spec"; "required": false; }; "RuntimeStatus": { "alias": "RuntimeStatus"; "required": false; }; "NodePositions": { "alias": "NodePositions"; "required": false; }; "ReadOnly": { "alias": "ReadOnly"; "required": false; }; "ShowToolbar": { "alias": "ShowToolbar"; "required": false; }; "ShowPalette": { "alias": "ShowPalette"; "required": false; }; "ShowMinimap": { "alias": "ShowMinimap"; "required": false; }; "ShowStatusBar": { "alias": "ShowStatusBar"; "required": false; }; "AutoLayoutDirection": { "alias": "AutoLayoutDirection"; "required": false; }; "ShowProperties": { "alias": "ShowProperties"; "required": false; }; "AvailableAgentNames": { "alias": "AvailableAgentNames"; "required": false; }; "AvailableActionNames": { "alias": "AvailableActionNames"; "required": false; }; "EmptyStateMessage": { "alias": "EmptyStateMessage"; "required": false; }; }, { "BeforeTaskAdded": "BeforeTaskAdded"; "AfterTaskAdded": "AfterTaskAdded"; "BeforeTaskRemoved": "BeforeTaskRemoved"; "AfterTaskRemoved": "AfterTaskRemoved"; "BeforeTaskUpdated": "BeforeTaskUpdated"; "AfterTaskUpdated": "AfterTaskUpdated"; "BeforeDependencyAdded": "BeforeDependencyAdded"; "AfterDependencyAdded": "AfterDependencyAdded"; "BeforeDependencyRemoved": "BeforeDependencyRemoved"; "AfterDependencyRemoved": "AfterDependencyRemoved"; "SpecChanged": "SpecChanged"; "SelectionChanged": "SelectionChanged"; "ValidationChanged": "ValidationChanged"; "AgentOpenRequested": "AgentOpenRequested"; "RecordOpenRequested": "RecordOpenRequested"; }, never, never, false, never>;
+}
+//# sourceMappingURL=task-graph-editor.component.d.ts.map

package/dist/lib/task-graph-editor.component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-graph-editor.component.d.ts","sourceRoot":"","sources":["../../src/lib/task-graph-editor.component.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,EAAa,YAAY,EAAS,SAAS,EAAqB,MAAM,eAAe,CAAC;AAC7F,OAAO,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,EAGH,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACtB,KAAK,wBAAwB,EAChC,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,KAAK,EACR,cAAc,EACd,0BAA0B,EAC1B,mBAAmB,EACnB,QAAQ,EACR,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,EAClB,YAAY,EACf,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAeH,KAAK,sBAAsB,EAC9B,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EACR,2CAA2C,EAC3C,oCAAoC,EACvC,MAAM,yCAAyC,CAAC;AACjD,OAAO,EACH,6BAA6B,EAC7B,+BAA+B,EAC/B,uBAAuB,EACvB,yBAAyB,EACzB,yBAAyB,EACzB,2BAA2B,EAC3B,8BAA8B,EAC9B,gCAAgC,EAChC,wBAAwB,EACxB,0BAA0B,EAC1B,0BAA0B,EAC1B,4BAA4B,EAC5B,kCAAkC,EAClC,6BAA6B,EAC7B,mCAAmC,EACtC,MAAM,4BAA4B,CAAC;;AAEpC,qBAMa,wBAAyB,SAAQ,oBAAqB,YAAW,SAAS;IAGnF;;;;OAIG;IACH,IACW,IAAI,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI,EAG1C;IACD,IAAW,IAAI,IAAI,aAAa,GAAG,IAAI,CAEtC;IAED;;;;OAIG;IACH,IACW,aAAa,CAAC,KAAK,EAAE,sBAAsB,GAAG,IAAI,EAG5D;IACD,IAAW,aAAa,IAAI,sBAAsB,GAAG,IAAI,CAExD;IAED;;;;;;;;;;;;;;OAcG;IACH,IACW,aAAa,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,IAAI,EAOvE;IAED,8FAA8F;IAC9E,QAAQ,EAAE,OAAO,CAAS;IAE1B,WAAW,EAAE,OAAO,CAAQ;IAC5B,WAAW,EAAE,OAAO,CAAQ;IAC5B,WAAW,EAAE,OAAO,CAAQ;IAC5B,aAAa,EAAE,OAAO,CAAQ;IAC9B,mBAAmB,EAAE,mBAAmB,CAAc;IAEtE;;;;;;;OAOG;IACa,cAAc,EAAE,OAAO,CAAQ;IAE/C;;;OAGG;IACa,mBAAmB,EAAE,SAAS,MAAM,EAAE,CAAM;IAE5D,gGAAgG;IAChF,oBAAoB,EAAE,SAAS,MAAM,EAAE,CAAM;IAE7D,+CAA+C;IAC/B,iBAAiB,EAAE,MAAM,CAA4D;IAIpF,eAAe,yCAAgD;IAC/D,cAAc,wCAA+C;IAC7D,iBAAiB,2CAAkD;IACnE,gBAAgB,0CAAiD;IACjE,iBAAiB,2CAAkD;IACnE,gBAAgB,0CAAiD;IACjE,qBAAqB,+CAAsD;IAC3E,oBAAoB,8CAAqD;IACzE,uBAAuB,iDAAwD;IAC/E,sBAAsB,gDAAuD;IAE9F,oFAAoF;IACnE,WAAW,8CAAqD;IAChE,gBAAgB,mDAA0D;IAC1E,iBAAiB,oDAA2D;IAE7F,4FAA4F;IAC3E,kBAAkB,4CAAmD;IACrE,mBAAmB,6CAAoD;IAIjF,KAAK,EAAE,QAAQ,EAAE,CAAM;IACvB,WAAW,EAAE,cAAc,EAAE,CAAM;IACnC,SAAS,EAAE,kBAAkB,EAAE,CAA8B;IAC7D,YAAY,EAAE,iBAAiB,GAAG,IAAI,CAAQ;IAC9C,gBAAgB,EAAE,SAAS,wBAAwB,EAAE,CAAM;IAC3D,OAAO,EAAE,OAAO,CAAQ;IAEC,SAAS,CAAC,MAAM,EAAE,mBAAmB,GAAG,SAAS,CAAC;IAElF,OAAO,CAAC,WAAW,CAA8B;IACjD,OAAO,CAAC,cAAc,CAAuC;IAE7D,IAAW,OAAO,IAAI,OAAO,CAE5B;IASD,2DAA2D;IACpD,QAAQ,IAAI,mCAAmC;IAatD,wEAAwE;IACjE,OAAO,CAAC,OAAO,GAAE,OAAO,CAAC,iBAAiB,CAAM,GAAG,iBAAiB,GAAG,IAAI;IA2BlF,kFAAkF;IAC3E,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAiB1C,yEAAyE;IAClE,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,iBAAiB,GAAG,OAAO;IAenE;;;;;;;OAOG;IACI,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO;IAavF,sEAAsE;IAC/D,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO;IAYtE;;;;;;OAMG;IACI,sBAAsB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO;IAM/F,qDAAqD;IAC9C,gBAAgB,CAAC,IAAI,EAAE,iBAAiB,GAAG,IAAI;IAOtD,2DAA2D;IACpD,iBAAiB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAM7D,cAAc,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,GAAG,IAAI;IAIlD;;;;;;;;;;;;;OAaG;IACI,WAAW,CAAC,KAAK,EAAE,kBAAkB,GAAG,IAAI;IAyBnD,0FAA0F;IACnF,6BAA6B,CAAC,IAAI,EAAE,oCAAoC,GAAG,IAAI;IAItF,sDAAsD;IAC/C,oCAAoC,CAAC,IAAI,EAAE,2CAA2C,GAAG,IAAI;IAI7F,mBAAmB,CAAC,KAAK,EAAE,0BAA0B,GAAG,IAAI;IAI5D,mBAAmB,CAAC,UAAU,EAAE,cAAc,GAAG,IAAI;IAIrD,aAAa,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI;IAM1C,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,UAAU;IAKlB,yFAAyF;IACzF,OAAO,CAAC,MAAM;IAMd,6FAA6F;IAC7F,OAAO,CAAC,OAAO;IAgBf;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,qBAAqB;IAmB7B;;;;;;;OAOG;IACH,OAAO,CAAC,aAAa;IAQrB;;;;;;OAMG;IACI,cAAc,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,IAAI;IAI9C,iEAAiE;IAC1D,WAAW,CAAC,KAAK,EAAE,kBAAkB,GAAG,IAAI;IAI5C,WAAW,IAAI,IAAI;IAO1B,2FAA2F;IAC3F;;;;;;;OAOG;IACH,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAmC;IAElE,gGAAgG;IAChG,OAAO,CAAC,UAAU,CAAkB;IACpC,OAAO,CAAC,aAAa,CAA8C;yCAzc1D,wBAAwB;2CAAxB,wBAAwB;CA0cpC"}