poly-weaver 0.2.5

package/dist/flow/custom/AUTHORING.md

@@ -0,0 +1,558 @@
+# Custom Flow Authoring Guide
+
+This is the reference for creating and editing poly-weaver custom flow templates. A flow template defines the sequence of agent and user steps that poly-weaver executes for a task.
+
+## 1. Essentials
+
+- **Where**: `~/.poly-weaver/flows/*.mjs` (or `*.js`)
+- **Export**: `export default function(dsl) { ... }` or `export function createTemplate(dsl) { ... }`
+- **Must return**: `{ name: string, params: FlowParam[], build(values): FlowDefinition }`
+- **Helpers**: always use `plan()`, `review()`, `implement()`, `simplify()`, or `user()` — never `agentStep()` directly
+- **Finalize**: `build()` must return the result of `defineFlow(name, steps)`
+
+Minimal example:
+
+```js
+export default function (dsl) {
+  const { defineFlow, loop, artifactData, plan, review, TASK } = dsl;
+
+  return {
+    name: "my-flow",
+    params: [
+      { key: "planner", type: "driver", role: "planner", label: "Planner", default: "claude" },
+      { key: "reviewer", type: "driver", role: "reviewer", label: "Reviewer", default: "codex" },
+      { key: "maxIterations", type: "number", label: "Max Iterations", default: 5, min: 1, max: 50 },
+    ],
+
+    build(values) {
+      return defineFlow("my-flow", [
+        loop(values.maxIterations, artifactData("verdict", "approved"), [
+          plan({
+            driver: values.planner,
+            reads: { task: TASK, verdict: "verdict" },
+            writes: { plan: "plan" },
+          }),
+          review({
+            driver: values.reviewer,
+            variant: "plan",
+            reads: { task: TASK, plan: "plan" },
+            writes: { verdict: "verdict" },
+          }),
+        ]),
+      ]);
+    },
+  };
+}
+```
+
+## 2. DSL Helper Defaults
+
+Every helper supplies defaults for optional fields. When you omit an option, the default below applies. When you set an option explicitly, your value wins.
+
+| Helper | `phaseLabel` | `reads` | `writes` | `feedbackToTask` | ID prefix | Notes |
+|--------|-------------|---------|----------|-------------------|-----------|-------|
+| `plan(opts)` | `"📝 Planning..."` | **required** | **required** | `false` | `plan` | |
+| `review(opts)` | `"🔍 Reviewing Plan..."` | **required** | **required** | `false` | `review` | When `variant` is `"impl"`: `"🔍 Reviewing Impl..."` |
+| `implement(opts)` | `"🔨 Implementing..."` | **required** | `{}` | `false` | `implement` | |
+| `simplify(opts)` | `"✨ Simplifying..."` | `{}` (hardcoded) | **required** | `false` | `simplify` | `reads` cannot be overridden — simplifier inspects the working directory directly |
+| `user(label, opts?)` | `"👤 User Review..."` | `{ display: "plan" }` | `{}` | `true` | `user-${label}` | `label` is a semantic name (e.g. `"user:feedback"`) |
+
+**ID generation**: `defineFlow()` auto-assigns IDs using the prefix — first occurrence gets the bare prefix (e.g. `plan`), subsequent get a numeric suffix (e.g. `plan-2`). You can override with `id`.
+
+## 3. How To Edit Common Requests
+
+### Change all phase labels
+
+Set `phaseLabel` explicitly on every step. Helpers only inject their default when you omit it.
+
+```js
+// Before (uses default "📝 Planning...")
+plan({ driver: d, reads: { task: TASK }, writes: { plan: "plan" } })
+
+// After
+plan({ driver: d, reads: { task: TASK }, writes: { plan: "plan" }, phaseLabel: "Step 1: Plan" })
+```
+
+To change every label in a flow, add `phaseLabel` to every `plan()`, `review()`, `implement()`, `simplify()`, and `user()` call. Steps that already have an explicit `phaseLabel` keep it unless you change it.
+
+### Change only review-plan vs review-impl labels
+
+`review()` chooses its default label based on `variant`:
+- `variant: "plan"` (or omitted) → `"🔍 Reviewing Plan..."`
+- `variant: "impl"` → `"🔍 Reviewing Impl..."`
+
+To override one without affecting the other, set `phaseLabel` on the specific `review()` call:
+
+```js
+review({ driver: d, variant: "plan", phaseLabel: "Checking Plan...", reads: {...}, writes: {...} })
+// The variant: "impl" review() elsewhere keeps its default
+```
+
+### Use loop-aware labels with `cyclePhase()`
+
+Show one label on the first iteration and a different label on subsequent iterations:
+
+```js
+// Before (static label)
+plan({ driver: d, phaseLabel: "📝 Planning...", reads: {...}, writes: {...} })
+
+// After (revision-aware)
+plan({ driver: d, phaseLabel: cyclePhase("📝 Planning...", "✏️ Revising Plan..."), reads: {...}, writes: {...} })
+```
+
+`cyclePhase()` must be inside a `loop()`. It auto-binds to the containing loop.
+
+### Change the default display artifact for `user()`
+
+By default, `user()` reads `{ display: "plan" }`. Override `reads` to show a different artifact:
+
+```js
+// Before (shows the plan)
+user("user:feedback", { writes: { verdict: "verdict" } })
+
+// After (shows the implementation verdict)
+user("user:feedback", { reads: { display: "impl-verdict" }, writes: { verdict: "verdict" } })
+```
+
+### Adjust loop counts
+
+Loop counts come from template params. Change the param default, or add a new param:
+
+```js
+params: [
+  { key: "maxIterations", type: "number", label: "Max Iterations", default: 10, min: 1, max: 50 },
+],
+build(values) {
+  return defineFlow("my-flow", [
+    loop(values.maxIterations, artifactData("verdict", "approved"), [ ... ]),
+  ]);
+}
+```
+
+### Preserve explicit overrides
+
+When editing a flow, check whether a step already has an explicit option before applying a blanket change. For example, if a `plan()` already has `phaseLabel: cyclePhase(...)`, replacing it with a static string removes the loop-aware behavior.
+
+## 4. FlowDSL Object
+
+The `dsl` object passed to your factory provides:
+
+| Function | Purpose |
+|----------|---------|
+| `defineFlow(name, steps)` | Finalize a flow definition |
+| `loop(max, until, steps, opts?)` | Create a loop step |
+| `plan(opts)` | Create a planner agent step |
+| `review(opts)` | Create a reviewer agent step |
+| `implement(opts)` | Create an implementor agent step |
+| `simplify(opts)` | Create a simplifier agent step |
+| `user(label, opts?)` | Create a user interaction step |
+| `artifactData(artifactName, field, expected?)` | Structured predicate on artifact data |
+| `ctxField(field, op, value)` | Structured predicate on context fields |
+| `cyclePhase(first, subsequent)` | Loop-aware phase label |
+| `predicateLabel(pred)` | Convert structured predicate to display label |
+| `TASK` | Well-known artifact name (`"task"`) for the user's task description |
+
+> **Note**: `agentStep` is intentionally excluded. It is the low-level builder that role-specific helpers wrap. Only built-in roles have registered handlers — always use `plan()`, `review()`, `implement()`, `simplify()`, or `user()`.
+
+## 5. Step Builder Signatures
+
+### `plan(opts)` → `AgentStep`
+
+```js
+plan({
+  driver: string,                 // required — driver name from param value
+  reads: Record<string, string>,  // required — input artifact mapping
+  writes: Record<string, string>, // required — output artifact mapping
+  id?: string,
+  feedbackToTask?: boolean,       // default: false
+  when?: WhenCondition,           // conditional execution
+  whenLabel?: string,             // display label for when condition
+  phaseLabel?: PhaseLabelSpec,    // default: "📝 Planning..."
+})
+```
+
+### `review(opts)` → `AgentStep`
+
+```js
+review({
+  driver: string,                 // required
+  reads: Record<string, string>,  // required
+  writes: Record<string, string>, // required
+  id?: string,
+  variant?: string,               // differentiates review context (e.g. "plan", "impl")
+  feedbackToTask?: boolean,       // default: false
+  phaseLabel?: PhaseLabelSpec,    // default: varies by variant (see §2)
+})
+```
+
+### `implement(opts)` → `AgentStep`
+
+```js
+implement({
+  driver: string,                  // required
+  reads: Record<string, string>,   // required
+  writes?: Record<string, string>, // default: {}
+  id?: string,
+  feedbackToTask?: boolean,        // default: false
+  phaseLabel?: PhaseLabelSpec,     // default: "🔨 Implementing..."
+})
+```
+
+### `simplify(opts)` → `AgentStep`
+
+```js
+simplify({
+  driver: string,                 // required
+  writes: Record<string, string>, // required
+  id?: string,
+  feedbackToTask?: boolean,       // default: false
+  when?: WhenCondition,
+  phaseLabel?: PhaseLabelSpec,    // default: "✨ Simplifying..."
+})
+```
+
+`reads` is always `{}` (hardcoded) — the simplifier inspects the working directory directly.
+
+### `user(label, opts?)` → `UserStep`
+
+```js
+user("user:feedback", {
+  id?: string,
+  when?: WhenCondition,
+  whenLabel?: string,
+  reads?: Record<string, string>,   // default: { display: "plan" }
+  writes?: Record<string, string>,  // default: {}
+  feedbackToTask?: boolean,         // default: true
+  breakOnAccept?: boolean,          // exits containing loop on accept
+  phaseLabel?: PhaseLabelSpec,      // default: "👤 User Review..."
+})
+```
+
+The `label` argument is a semantic name used for ID generation (e.g. `"user:feedback"`, `"user:approval"`).
+
+## 6. `loop(max, until, steps, opts?)` → `LoopStep`
+
+```js
+loop(maxIterations, untilCondition, stepsArray, {
+  onExhausted?: UserStep,  // runs when max reached without until becoming true
+  untilLabel?: string,     // display label override for until condition
+})
+```
+
+- `max`: maximum iterations (`Infinity` for uncapped)
+- `until`: predicate or lambda — loop exits when truthy
+- `steps`: array of `FlowStep` (agent, user, or nested loop)
+- `onExhausted`: optional user step that runs when the loop hits `max` without `until` becoming true. If the user rejects, the loop restarts with a fresh iteration budget.
+
+## 7. Predicates
+
+### `artifactData(artifactName, field, expected?)` — structured
+
+Checks `artifacts.getData(artifactName)[field] === expected`. Default `expected` is `true`.
+
+```js
+artifactData("verdict", "approved")       // verdict.approved === true
+artifactData("verdict", "status", "closed") // verdict.status === "closed"
+```
+
+Auto-generated labels: `"verdict.approved"`, `"verdict.status=closed"`.
+
+### `ctxField(field, op, value)` — structured
+
+Checks the loop-local cycle iteration. Currently only `field: "iteration"` is supported.
+
+```js
+ctxField("iteration", "!=", 1)   // skip on first iteration
+ctxField("iteration", ">", 3)    // only after 3rd iteration
+```
+
+Operators: `"=="`, `"!="`, `"<"`, `">"`, `"<="`, `">="`.
+
+Auto-generated labels: `"iter≠1"`, `"iter>3"`.
+
+Automatically bound to the containing loop — no loop ID needed.
+
+### Lambda predicates `(ctx) => boolean` — escape hatch
+
+Full access to `ctx.artifacts` for advanced conditions. No auto-label — use `whenLabel` or `untilLabel` overrides.
+
+```js
+when: (ctx) => {
+  const data = ctx.artifacts.getData("impl-verdict");
+  return data != null && Array.isArray(data.issues) && data.issues.length > 2;
+},
+whenLabel: "impl-verdict.issues>2",
+```
+
+### `predicateLabel(pred)` → `string`
+
+Converts a structured predicate into its human-readable label string. Useful when writing a lambda `whenLabel` that should match the auto-generated format.
+
+| Input | Output |
+|-------|--------|
+| `artifactData("verdict", "approved")` | `"verdict.approved"` |
+| `artifactData("verdict", "status", "closed")` | `"verdict.status=closed"` |
+| `ctxField("iteration", "!=", 1)` | `"iter≠1"` |
+| `ctxField("iteration", ">=", 3)` | `"iter≥3"` |
+
+## 8. `reads` & `writes` (Artifact Routing)
+
+Steps declare which artifacts they consume (`reads`) and produce (`writes`).
+
+- **Keys** are semantic names (handler-facing): `"task"`, `"plan"`, `"verdict"`, `"revisePlan"`
+- **Values** are artifact store names: `TASK`, `"plan"`, `"verdict"`, `"impl-verdict"`, `"revise-plan"`
+- Multiple steps can share artifact names (last writer wins)
+- `TASK` is a well-known constant (`"task"`) pre-seeded with the user's task description
+
+```js
+plan({
+  driver: plannerDriver,
+  reads: { task: TASK, verdict: "verdict" },
+  writes: { plan: "plan" },
+})
+review({
+  driver: reviewerDriver,
+  variant: "plan",
+  reads: { task: TASK, plan: "plan" },
+  writes: { verdict: "verdict" },
+})
+```
+
+## 9. Phase Labels
+
+Phase labels control the status bar display during step execution.
+
+- **Static string**: `phaseLabel: "🔨 Implementing..."`
+- **`cyclePhase(first, subsequent)`**: shows `first` on cycle 1, `subsequent` on cycle 2+ within the containing loop. Must be inside a loop.
+- **Lambda**: `(ctx) => string` for fully dynamic labels.
+
+## 10. Other Step Options
+
+- **`variant?: string`** — differentiates handlers for the same role (e.g. `"plan"` vs `"impl"` for reviewer)
+- **`feedbackToTask: boolean`** — whether the step's output is appended to the task artifact on loop retry
+- **`breakOnAccept: boolean`** (user only) — exits the containing loop when the user accepts
+- **`when`** — conditional step execution (step is skipped when predicate returns false)
+
+## 11. Parameters (`FlowParam`)
+
+Three param types. All share `key`, `label`, and optional `description`.
+
+### `DriverFlowParam`
+
+```js
+{ type: "driver", key: "planner", label: "Planner", role: "planner", default: "claude", description?: "..." }
+```
+
+- `role`: `"planner"` | `"reviewer"` | `"implementor"` | `"simplifier"`
+- `default`: `"claude"` | `"codex"` | `"copilot"`
+
+### `NumberFlowParam`
+
+```js
+{ type: "number", key: "maxIterations", label: "Max Iterations", default: 5, min?: 1, max?: 50 }
+```
+
+### `BooleanFlowParam`
+
+```js
+{ type: "boolean", key: "auto", label: "Auto Mode", default: false, description?: "..." }
+```
+
+## 12. FlowTemplate Return Shape
+
+```js
+{
+  name: string,         // unique template identifier
+  params: FlowParam[],  // user-configurable parameters
+  build(values): FlowDefinition  // values: resolved param values
+}
+```
+
+`build()` receives a `FlowParamValues` object — a record mapping each param `key` to its resolved value (from CLI flags, TUI input, or defaults). It must return the result of `defineFlow()`.
+
+## 13. File Loading Rules
+
+- **Directory**: `~/.poly-weaver/flows/`
+- **Extensions**: `*.mjs` or `*.js`
+- **Shadowing protection**: custom names cannot match built-in names (`"default"`, `"why-so-serious"`)
+- **Uniqueness**: template names must be globally unique across all custom flow files; duplicates are skipped (first-loaded wins)
+- **Error handling**: errors are collected per-file, not fatal — other flows still load
+
+## 14. `StepContext` in Lambda Predicates
+
+When writing lambda predicates or phase-label lambdas, you receive `ctx`. The usable surface:
+
+| Method | Returns | Purpose |
+|--------|---------|---------|
+| `ctx.artifacts.getData(name)` | parsed object or `undefined` | Structured data from an artifact |
+| `ctx.artifacts.getText(name)` | string or `undefined` | Human-readable text from an artifact |
+| `ctx.artifacts.set(name, { data?, text?, file?, meta? })` | void | Write or clear an artifact |
+
+For iteration-based conditions, use the structured `ctxField("iteration", op, value)` predicate rather than accessing loop internals directly.
+
+## 15. Patterns & Tips
+
+### Uncapped user-driven loop
+Use `Infinity` + `() => false` for the outer loop, and `breakOnAccept: true` on a user step to let the user decide when to exit:
+```js
+loop(Infinity, () => false, [
+  // ... agent steps ...
+  user("approval", { breakOnAccept: true, writes: { verdict: "verdict" } }),
+])
+```
+
+### Skip a step on first iteration
+```js
+plan({
+  driver: plannerDriver,
+  when: ctxField("iteration", "!=", 1),
+  reads: { task: TASK, verdict: "verdict" },
+  writes: { plan: "plan" },
+})
+```
+
+### Artifact naming conventions
+- `"verdict"` — plan review verdict
+- `"impl-verdict"` — implementation review verdict (avoids collision with plan verdict)
+- `"plan"` — the plan artifact
+- Use distinct artifact names for different phases to prevent data bleed between loops
+
+### Conditional steps with lambdas
+For complex conditions that structured predicates cannot express, use a lambda with `whenLabel`:
+```js
+plan({
+  when: (ctx) => {
+    const data = ctx.artifacts.getData("impl-verdict");
+    return data != null && Array.isArray(data.issues) && data.issues.length > 2;
+  },
+  whenLabel: "impl-verdict.issues>2",
+  driver: plannerDriver,
+  reads: { task: "plan", verdict: "impl-verdict" },
+  writes: { plan: "revise-plan" },
+})
+```
+
+### Cleaning up stale artifacts in lambdas
+If a conditional step writes an artifact that downstream steps read, clear the artifact in the false branch to avoid stale data:
+```js
+when: (ctx) => {
+  const data = ctx.artifacts.getData("impl-verdict");
+  const exceeds = data != null && Array.isArray(data.issues) && data.issues.length > 2;
+  if (!exceeds) {
+    ctx.artifacts.set("revise-plan", {}); // clear stale artifact
+  }
+  return exceeds;
+},
+```
+
+### Post-loop steps
+Steps can appear outside loops as sequential top-level steps:
+```js
+return defineFlow("my-flow", [
+  loop(maxPlan, artifactData("verdict", "approved"), [ ... ]),
+  simplify({ driver: simplifierDriver, writes: { plan: "simplify-plan" } }),
+  implement({ driver: implementorDriver, reads: { plan: "simplify-plan" } }),
+]);
+```
+
+## Appendix: Built-in `default` Flow
+
+The built-in default flow demonstrates the interactive two-layered loop pattern. Key editing implications are noted inline.
+
+```js
+build(values) {
+  const maxPlan = values.maxIterations;
+  const maxImpl = values.maxImplIterations;
+  const isPlanOnly = values.planOnly;
+  const isAuto = values.auto;
+
+  const plannerDriver = values.planner;
+  const reviewerDriver = values.reviewer;
+  const implementorDriver = values.implementor;
+
+  const steps = [];
+
+  if (isAuto) {
+    // Auto mode: flat plan→review loop, no user interaction
+    steps.push(
+      loop(maxPlan, artifactData("verdict", "approved"), [
+        plan({
+          driver: plannerDriver,
+          phaseLabel: cyclePhase("📝 Planning...", "✏️ Revising Plan..."),
+          reads: { task: TASK, verdict: "verdict" },
+          writes: { plan: "plan" },
+        }),
+        review({
+          driver: reviewerDriver,
+          variant: "plan",
+          reads: { task: TASK, plan: "plan" },
+          writes: { verdict: "verdict" },
+        }),
+      ]),
+    );
+  } else {
+    // Interactive mode: outer uncapped user loop + inner capped agent review loop
+    steps.push(
+      loop(Infinity, () => false, [
+        plan({
+          driver: plannerDriver,
+          // NOTE: cyclePhase binds to the outer loop here
+          phaseLabel: cyclePhase("📝 Planning...", "✏️ Addressing Feedback..."),
+          reads: { task: TASK, verdict: "verdict" },
+          writes: { plan: "plan" },
+        }),
+        user("user:feedback", {
+          writes: { verdict: "verdict" },
+        }),
+        loop(maxPlan, artifactData("verdict", "approved"), [
+          plan({
+            driver: plannerDriver,
+            when: ctxField("iteration", "!=", 1), // skip 1st iter — plan exists from outer loop
+            phaseLabel: "✏️ Revising Plan...",
+            reads: { task: TASK, verdict: "verdict" },
+            writes: { plan: "plan" },
+          }),
+          review({
+            driver: reviewerDriver,
+            variant: "plan",
+            reads: { task: TASK, plan: "plan" },
+            writes: { verdict: "verdict" },
+          }),
+        ]),
+        user("user:approval", {
+          breakOnAccept: true,    // exits outer loop on accept
+          writes: { verdict: "verdict" },
+        }),
+      ]),
+    );
+  }
+
+  // Implementation loop (same for auto and interactive)
+  if (!isPlanOnly) {
+    const implVerdict = "impl-verdict";
+    steps.push(
+      loop(maxImpl, artifactData(implVerdict, "approved"), [
+        implement({
+          driver: implementorDriver,
+          phaseLabel: cyclePhase("🔨 Implementing...", "✏️ Revising Impl..."),
+          reads: { plan: "plan", verdict: implVerdict },
+        }),
+        review({
+          driver: reviewerDriver,
+          variant: "impl",
+          reads: { task: TASK, plan: "plan" },
+          writes: { verdict: implVerdict },
+        }),
+      ]),
+    );
+  }
+
+  return defineFlow("default", steps);
+}
+```
+
+**Key patterns**:
+- Outer loop uses `Infinity` + `() => false` — exits only via `breakOnAccept` on the user step.
+- Inner loop is capped by `maxPlan`, exits when `artifactData("verdict", "approved")` is true.
+- `ctxField("iteration", "!=", 1)` on the inner plan step skips it on the first inner iteration (a plan already exists from the outer loop).
+- Implementation loop uses `"impl-verdict"` to avoid collision with `"verdict"`.

package/dist/flow/custom/index.d.ts

@@ -0,0 +1,3 @@
+export { loadAllFlows, loadCustomFlows, loadBuiltinFlows, validateTemplate } from "./load.js";
+export type { AllFlowsResult, LoadResult, LoadError } from "./load.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/flow/custom/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/flow/custom/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAC9F,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC"}

package/dist/flow/custom/index.js

@@ -0,0 +1,2 @@
+export { loadAllFlows, loadCustomFlows, loadBuiltinFlows, validateTemplate } from "./load.js";
+//# sourceMappingURL=index.js.map

package/dist/flow/custom/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/flow/custom/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC"}

package/dist/flow/custom/load.d.ts

@@ -0,0 +1,19 @@
+import type { FlowTemplate } from "../types.js";
+export interface LoadError {
+    file: string;
+    message: string;
+}
+export interface LoadResult {
+    templates: FlowTemplate[];
+    errors: LoadError[];
+}
+export interface AllFlowsResult extends LoadResult {
+    builtinCount: number;
+    customDir: string;
+}
+export declare function loadBuiltinFlows(): Promise<FlowTemplate[]>;
+export declare function validateTemplate(template: unknown, file: string): FlowTemplate;
+export declare function loadCustomFlows(dir?: string): Promise<LoadResult>;
+/** Load all flows: built-in (from package) + custom (from user dir). */
+export declare function loadAllFlows(customDir?: string): Promise<AllFlowsResult>;
+//# sourceMappingURL=load.d.ts.map

package/dist/flow/custom/load.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../../../src/flow/custom/load.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,YAAY,EAAE,CAAC;IAC1B,MAAM,EAAE,SAAS,EAAE,CAAC;CACrB;AAED,MAAM,WAAW,cAAe,SAAQ,UAAU;IAChD,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;CACnB;AASD,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAYhE;AAID,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,YAAY,CAe9E;AAED,wBAAsB,eAAe,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAqDvE;AAID,wEAAwE;AACxE,wBAAsB,YAAY,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAwB9E"}