@sunshaobei/dsh-workflow 0.0.0-stage → 2.1.0

package/vendor/dynamic-workflow/engine/concurrency.js

@@ -0,0 +1,282 @@
+/**
+ * 自适应并发控制器：一个 provider key 上的纯 AIMD 状态机。
+ *
+ * 纯包纪律：不读时钟、不做 I/O——`now`（ms since epoch）一律由调用方传入；本类只回答
+ * 「cap 现在是多少、能不能准入、这次信号让 cap 变了没有」。谁喂信号、谁排队（bootstrap 的进程级
+ * 治理器）都在包外。
+ *
+ * 度量单位是**模型请求**（每一次尝试）：`inFlight` = 已准入、尚未 release 的请求数。
+ * 没有 ask 级计数——一个子代理同时只有一个请求在飞，「≤ N 个请求」与「≤ N 个子代理在跑」等价。
+ *
+ * 批次阻尼靠 **epoch**：每次准入记下当时的 epoch，每次限流裁决 epoch += 1。一个 429 只在
+ * 它的请求是在**当前** cap 下发出（epoch 相同）时才评价当前 cap；旧 epoch 的 429 评价的是一个已被
+ * 砍掉的 cap，只清 streak、刷新 cooldown。成功同理：只有当前 epoch 的成功计入 streak。
+ *
+ * 信号方法都返回本次信号引起的 cap 变化列表（通常 0 或 1 条；空闲重置紧接着一次限流时会是 2 条），
+ * 调用方原样扇出成 `concurrency-changed` 事件。
+ */
+/**
+ * 限流即 `cap = max(FLOOR, floor(cap × 0.75))`（系数从 0.5 改为 0.75）：
+ * 减半对「只多了一两个」的越界反应过猛——闸门是请求级的，一次 429 说明 cap 高了，很少说明高了一倍。
+ */
+export const CONCURRENCY_DECREASE_FACTOR = 0.75;
+/** 加性递增步长。 */
+export const CONCURRENCY_INCREASE_STEP = 1;
+/**
+ * 每 +1 需要的连续成功模型请求数 K。只有一档。该值从 40 降到 4：
+ * 探测失败的代价只是一个请求撞一次 429 然后退回 `lastGood`（已证明可用的水位），不值得用 40 次
+ * 成功去换一次试探。
+ */
+export const CONCURRENCY_INCREASE_AFTER_SUCCESSES = 4;
+/** 永远至少有一个探针在跑。 */
+export const CONCURRENCY_FLOOR = 1;
+/** 某 key 空闲这么久（且无在飞）后遗忘学到的 cap，回起点 `initial`（决策 20）。 */
+export const CONCURRENCY_IDLE_RESET_MS = 300_000;
+export class ConcurrencyController {
+    key;
+    initial;
+    cap;
+    growthLimit_;
+    epoch = 0;
+    inFlight = 0;
+    waiters_ = 0;
+    successStreak = 0;
+    cooldownUntil;
+    lastRequestAt;
+    lastGood;
+    lastBad;
+    lastThrottledAt;
+    /**
+     * @param key provider key（`${providerId}/${modelId}`），只用于填进 change 事件——控制器自己
+     *   对它无感。放在构造参数而不是每次信号传入：一个控制器只服务一个 key，这是身份不是参数。
+     * @param initial 默认并发 D（docs/dynamic-workflow/concurrency.md「Two bounds on a run」）：cap 的
+     *   起点，也是空闲重置的落点。它**不是**上界。
+     * @param growthLimit 自动增长的上界；缺省即 `initial`（只回落、不越过起点的旧行为）。治理器按
+     *   `max(2D, 用过这个 key 的在飞 run 的最大上界)` 给出并随时经 {@link setGrowthLimit} 挪动。
+     */
+    constructor(key, initial, growthLimit = initial) {
+        this.key = key;
+        this.initial = initial;
+        this.cap = initial;
+        this.growthLimit_ = Math.max(initial, growthLimit);
+    }
+    snapshot() {
+        return {
+            key: this.key,
+            initial: this.initial,
+            growthLimit: this.growthLimit_,
+            cap: this.cap,
+            epoch: this.epoch,
+            inFlight: this.inFlight,
+            waiters: this.waiters_,
+            successStreak: this.successStreak,
+            ...(this.cooldownUntil === undefined ? {} : { cooldownUntil: this.cooldownUntil }),
+            ...(this.lastRequestAt === undefined ? {} : { lastRequestAt: this.lastRequestAt }),
+            ...(this.lastGood === undefined ? {} : { lastGood: this.lastGood }),
+            ...(this.lastBad === undefined ? {} : { lastBad: this.lastBad }),
+            ...(this.lastThrottledAt === undefined ? {} : { lastThrottledAt: this.lastThrottledAt }),
+        };
+    }
+    /**
+     * 闸门（准入条件）：在飞请求数低于 cap 且不在 Retry-After 冷却中。纯查询，不做空闲重置——
+     * 调用方（治理器）在准入路径上先调 {@link observe}（准入也是一次「信号」，空闲一小时后的第一个
+     * run 要立刻从起点 `initial` 起步，决策 20）。
+     */
+    canAdmit(now) {
+        return (this.inFlight < this.cap && (this.cooldownUntil === undefined || now >= this.cooldownUntil));
+    }
+    /** 只做空闲重置检查的「空信号」（准入前、observer 放行前用）。 */
+    observe(now) {
+        return this.idleReset(now);
+    }
+    /**
+     * 一个请求被准入：`inFlight++`、刷新 `lastRequestAt`，返回它所属的 epoch（请求结束时带回来）。
+     * 不做空闲重置——调用方已在 {@link observe} 里做过；这里若再做，一个刚被 observe 判定「不空闲」
+     * 的准入不可能变成空闲。
+     */
+    admitted(now) {
+        this.lastRequestAt = now;
+        this.inFlight += 1;
+        return this.epoch;
+    }
+    /**
+     * 一个请求成功结束：`inFlight--`；只有**当前 epoch** 的成功使
+     * `successStreak++`——旧 epoch 的成功证明的是旧 cap 下退避压低后的负载，不是新 cap 可以更高。
+     * `successStreak ≥ K` 即**证明**当前 cap 可用：`lastGood = max(lastGood, cap)`（决策 40：只有
+     * 完成的 streak 能设 lastGood，减少 cap 不能）。再满足有等待者 **且** `cap < growthLimit` → +1。
+     * 无等待者时 streak 照累积但不兑现（决策 15）。
+     */
+    succeeded(now, epoch) {
+        const changes = this.idleReset(now);
+        this.inFlight = Math.max(0, this.inFlight - 1);
+        if (epoch !== this.epoch)
+            return changes;
+        this.successStreak += 1;
+        if (this.successStreak < CONCURRENCY_INCREASE_AFTER_SUCCESSES)
+            return changes;
+        // 这一级被一整段 streak 证明可用——不论此刻有没有人等着往上爬。
+        if (this.lastGood === undefined || this.cap > this.lastGood)
+            this.lastGood = this.cap;
+        if (this.waiters_ <= 0 || this.cap >= this.growthLimit_)
+            return changes;
+        const previous = this.cap;
+        this.cap = Math.min(this.growthLimit_, previous + CONCURRENCY_INCREASE_STEP);
+        this.successStreak = 0;
+        changes.push(this.change(previous, "recovered"));
+        return changes;
+    }
+    /**
+     * 被限流/过载。一律 `inFlight--`、清 streak、带 Retry-After 则把 cooldown
+     * 推到更晚者。
+     *
+     * 只有 `epoch === 当前 epoch` 的 429 才动 cap：它是在当前 cap 下发出的请求，是对当前 cap 的评价；
+     * 旧 epoch 的 429 忽略（不发事件）。当前 epoch 的分两档：在 `lastGood` **之上**探测被限流 → 退回
+     * `lastGood`（记 `lastBad`，不按系数减）；否则（`lastGood` 缺席或 `cap ≤ lastGood`：墙下移了）→
+     * `cap = max(FLOOR, floor(cap × 0.75))`，记 `lastBad = 旧 cap`，并**清掉** `lastGood`——它刚被
+     * 证伪，而新 cap 还没被任何 streak 证明（减 cap 不设 lastGood）。两档之后 `epoch += 1`——
+     * 即便 cap 已在地板、数值没变，也翻一页：同一批请求只能触发一次裁决。
+     */
+    throttled(now, epoch, reason, retryAfterMs) {
+        const changes = this.idleReset(now);
+        this.inFlight = Math.max(0, this.inFlight - 1);
+        this.successStreak = 0;
+        // 旧 epoch 的拒绝同样记：它不评价当前 cap，却足以说明 provider 此刻就在墙上（起跳看它）。
+        this.lastThrottledAt = now;
+        const cooldownMs = retryAfterMs !== undefined && retryAfterMs > 0 ? retryAfterMs : undefined;
+        if (cooldownMs !== undefined) {
+            this.cooldownUntil = Math.max(this.cooldownUntil ?? 0, now + cooldownMs);
+        }
+        if (epoch !== this.epoch)
+            return changes;
+        const previous = this.cap;
+        if (this.lastGood !== undefined && this.cap > this.lastGood) {
+            this.lastBad = this.cap;
+            this.cap = this.lastGood;
+        }
+        else {
+            this.cap = Math.max(CONCURRENCY_FLOOR, Math.floor(this.cap * CONCURRENCY_DECREASE_FACTOR));
+            this.lastBad = previous;
+            this.lastGood = undefined;
+        }
+        this.epoch += 1;
+        // cap 已在地板且无 Retry-After 时确实什么都没变，不发事件；带 Retry-After 的限流即便 cap 不动
+        // 也要让 run 头知道「冷却至…」，所以带 cooldownMs 的一律发。
+        if (previous === this.cap && cooldownMs === undefined)
+            return changes;
+        changes.push(this.change(previous, reason, cooldownMs));
+        return changes;
+    }
+    /** 瞬态但非限流的失败（timeout / 5xx / 网络）：`inFlight--`、清 streak，cap 不动。 */
+    failedTransient(now) {
+        const changes = this.idleReset(now);
+        this.inFlight = Math.max(0, this.inFlight - 1);
+        this.successStreak = 0;
+        return changes;
+    }
+    /** 一个请求以永久失败 / 取消终结，或 ticket 只见 release 没见终结事件：只做 `inFlight--`。 */
+    ended(now) {
+        const changes = this.idleReset(now);
+        this.inFlight = Math.max(0, this.inFlight - 1);
+        return changes;
+    }
+    /** 治理器在队列变化时喂入的等待者数（有需求才加 cap）。 */
+    waiters(now, count) {
+        const changes = this.idleReset(now);
+        this.waiters_ = Math.max(0, count);
+        return changes;
+    }
+    /**
+     * 挪动自动增长的上界（docs/dynamic-workflow/concurrency.md「Increase」）。这是控制器里唯一一个
+     * 不归它自己管的数：治理器按「2D 与用过这个 key 的在飞 run 的最大上界取大」算出来，run 来去、
+     * retune 都会让它变。恒夹到 ≥ initial。
+     *
+     * 抬高什么都不立刻改：cap 照旧一级一级爬。压低到 cap 之下则当场把 cap 拉到新上界并发一条
+     * `limit_lowered`——否则一个为大 run 学到的高 cap 会留给之后的默认 run 共用，直到空闲重置。
+     * 同时夹 `lastGood`、清 streak、翻 epoch：旧 cap 下发出的请求撞的 429 不是对新 cap 的裁决。
+     */
+    setGrowthLimit(now, limit) {
+        const changes = this.idleReset(now);
+        this.growthLimit_ = Math.max(this.initial, Math.floor(limit));
+        if (this.cap <= this.growthLimit_)
+            return changes;
+        const previous = this.cap;
+        this.cap = this.growthLimit_;
+        if (this.lastGood !== undefined && this.lastGood > this.cap)
+            this.lastGood = this.cap;
+        this.successStreak = 0;
+        this.epoch += 1;
+        changes.push(this.change(previous, "limit_lowered"));
+        return changes;
+    }
+    /**
+     * 起跳（docs/dynamic-workflow/concurrency.md「Seeding」）：用户把一个 run 的上界调高时，治理器请
+     * cap 直接跳到 `min(target, growthLimit)`，而不是每 K 次成功爬一级——从 8 爬到 32 要约 96 次
+     * 成功，用户看到的是「设置没生效」。
+     *
+     * 清 `lastGood`：起跳点是新的起点，不是在已证明水位之上的探测；否则第一次 429 会一路退回旧的
+     * 已证明水位，而不是按系数减（32 → 24 → 18 …）。同时清 `lastBad`、清 streak、翻 epoch。
+     *
+     * 两种情况不跳：目标不高于 cap；五分钟内（空闲重置同一窗口）有过任何一次拒绝——那时起跳就是
+     * 明知故犯地对着刚撞过的墙再冲一波，cap 改为照常一级一级爬。
+     */
+    seed(now, target) {
+        const changes = this.idleReset(now);
+        const next = Math.min(this.growthLimit_, Math.floor(target));
+        if (next <= this.cap)
+            return changes;
+        if (this.lastThrottledAt !== undefined &&
+            now - this.lastThrottledAt < CONCURRENCY_IDLE_RESET_MS) {
+            return changes;
+        }
+        const previous = this.cap;
+        this.cap = next;
+        this.lastGood = undefined;
+        this.lastBad = undefined;
+        this.successStreak = 0;
+        this.epoch += 1;
+        changes.push(this.change(previous, "seeded"));
+        return changes;
+    }
+    // ——————————————————————————————— 内部 ———————————————————————————————
+    /**
+     * 空闲重置（决策 20）：`now − lastRequestAt ≥ IDLE_RESET_MS` 且无在飞 → cap 回起点 `initial`，
+     * 清 streak / cooldown / lastGood / lastBad，epoch += 1。惰性发生在任一信号到达时（无定时器）。
+     */
+    idleReset(now) {
+        if (this.lastRequestAt === undefined ||
+            this.inFlight !== 0 ||
+            now - this.lastRequestAt < CONCURRENCY_IDLE_RESET_MS) {
+            return [];
+        }
+        const previous = this.cap;
+        // 幂等：已在起点且状态干净时什么都不做（否则每个空闲信号都翻一页 epoch）。
+        if (previous === this.initial &&
+            this.successStreak === 0 &&
+            this.cooldownUntil === undefined &&
+            this.lastGood === undefined &&
+            this.lastBad === undefined &&
+            this.lastThrottledAt === undefined) {
+            return [];
+        }
+        this.cap = this.initial;
+        this.successStreak = 0;
+        this.cooldownUntil = undefined;
+        this.lastGood = undefined;
+        this.lastBad = undefined;
+        this.lastThrottledAt = undefined;
+        this.epoch += 1;
+        // lastRequestAt 保留：下一次仍空闲的信号不该再「重置」一次；反正状态已在起点。
+        return previous === this.cap ? [] : [this.change(previous, "idle_reset")];
+    }
+    change(previous, reason, cooldownMs) {
+        return {
+            key: this.key,
+            previous,
+            next: this.cap,
+            reason,
+            ...(this.lastGood === undefined ? {} : { lastGood: this.lastGood }),
+            ...(this.lastBad === undefined ? {} : { lastBad: this.lastBad }),
+            ...(cooldownMs === undefined ? {} : { cooldownMs }),
+        };
+    }
+}

package/vendor/dynamic-workflow/engine/engine-artifacts-primary.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 修复原因：engine-artifacts.ts 顶到 oxlint max-lines 上限（400 行）。拆出来的是一个完整的
+ * 概念——**交付物旗子**（`primary`）：全 run 至多一个 id 带它（docs/dynamic-workflow/authoring.md
+ * 「Ids, tags and versions」），内容成员与预置成员两族各自的准入都要问同一组判据，所以它本就
+ * 该有自己的模块，而不是散在发布路径里。
+ *
+ * 三个函数都是**纯**的：只读 `state.artifacts`（由 journal 行派生，resume 后自然一致），
+ * 不落库、不发事件——调用方拿到判据之后自己决定是拒绝还是 failRun。
+ */
+import type { EngineState } from "./engine-state.js";
+import type { InstanceRef } from "./types.js";
+/** 本 run 目前的 primary id（至多一个）；没有则 undefined。从 `state.artifacts` 派生，resume 后自然一致。 */
+export declare function primaryArtifactId(state: EngineState): string | undefined;
+/** `id` 想当 primary 而**别的** id 已经是 ⇒ 返回那个 id；否则 undefined（不想当 / 就是它自己）。 */
+export declare function primaryConflict(state: EngineState, id: string, primary: boolean): string | undefined;
+export declare function primaryConflictMessage(id: string, holder: string, fix: string, instance: InstanceRef | undefined): string;
+//# sourceMappingURL=engine-artifacts-primary.d.ts.map

package/vendor/dynamic-workflow/engine/engine-artifacts-primary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-artifacts-primary.d.ts","sourceRoot":"","sources":["../../src/engine/engine-artifacts-primary.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAG9C,oFAAoF;AACpF,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,GAAG,SAAS,CAGxE;AAED,0EAA0E;AAC1E,wBAAgB,eAAe,CAC7B,KAAK,EAAE,WAAW,EAClB,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,OAAO,GACf,MAAM,GAAG,SAAS,CAIpB;AAED,wBAAgB,sBAAsB,CACpC,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,WAAW,GAAG,SAAS,GAChC,MAAM,CAMR"}

package/vendor/dynamic-workflow/engine/engine-artifacts-primary.js

@@ -0,0 +1,29 @@
+/**
+ * 修复原因：engine-artifacts.ts 顶到 oxlint max-lines 上限（400 行）。拆出来的是一个完整的
+ * 概念——**交付物旗子**（`primary`）：全 run 至多一个 id 带它（docs/dynamic-workflow/authoring.md
+ * 「Ids, tags and versions」），内容成员与预置成员两族各自的准入都要问同一组判据，所以它本就
+ * 该有自己的模块，而不是散在发布路径里。
+ *
+ * 三个函数都是**纯**的：只读 `state.artifacts`（由 journal 行派生，resume 后自然一致），
+ * 不落库、不发事件——调用方拿到判据之后自己决定是拒绝还是 failRun。
+ */
+import { refToString } from "./types.js";
+/** 本 run 目前的 primary id（至多一个）；没有则 undefined。从 `state.artifacts` 派生，resume 后自然一致。 */
+export function primaryArtifactId(state) {
+    for (const [id, idState] of state.artifacts)
+        if (idState.primary)
+            return id;
+    return undefined;
+}
+/** `id` 想当 primary 而**别的** id 已经是 ⇒ 返回那个 id；否则 undefined（不想当 / 就是它自己）。 */
+export function primaryConflict(state, id, primary) {
+    if (!primary)
+        return undefined;
+    const holder = primaryArtifactId(state);
+    return holder === undefined || holder === id ? undefined : holder;
+}
+export function primaryConflictMessage(id, holder, fix, instance) {
+    const where = instance === undefined ? "" : ` (at ${refToString(instance)})`;
+    return (`Cannot mark "${id}" as primary${where}: "${holder}" is already this run's primary artifact. ` +
+        `A run has one deliverable; ${fix}, or publish it as a new version of "${holder}".`);
+}

package/vendor/dynamic-workflow/engine/engine-artifacts.d.ts

@@ -0,0 +1,55 @@
+/**
+ * engine.ts 顶到 oxlint max-lines 上限（400 行），把**用户面产物**（`artifact.*`）的
+ * 发布 / 声明 / 准入 / 结算 / resume 恢复拆到本文件；公开面仍从 engine.ts 导出。
+ *
+ * ⚠ 术语：以下一律指**用户面产物**（脚本发布给用户看的产出），不是 RunSettlement.artifact。
+ * 自由函数经 {@link EngineState} 接缝读写引擎状态；WorkflowEngine 上的同名方法只是薄委托。
+ */
+import { type ArtifactContentOp, type ArtifactPresetOp } from "../facade/registry.js";
+import type { EngineState } from "./engine-state.js";
+import type { ArtifactRef } from "./types.js";
+/**
+ * 发布一个**内容产物**（`artifact.file` / `artifact.markdown`）。效应族：经 driver 拷字节进
+ * store，成功兑现 {@link ArtifactRef}，失败**可 catch 地拒绝**——脚本的门控习语是
+ * `try { await artifact.file(...) } catch { …让子代理补写… }`。
+ *
+ * 顺序：
+ * 1. `nextOrdinal` → journal 命中？命中即短路：比 inputHash，成功记录返回它的 ArtifactRef，
+ *    **失败记录按记录重新拒绝**（resume 是崩溃恢复，不是复验：一次失败的发布在恢复后仍然
+ *    是那次失败，重跑它会让脚本的 catch 分支走两次不同的路）。命中一律**不重发事件**（同 report）。
+ * 2. 未命中：种类归属 → id 数上限 → 版本数上限，三条都是节点级拒绝（有 promise 可拒）。
+ * 3. 版本号在 dispatch **之前**算好并传给 driver（store 的 toolCallId 里要带它，每版一份字节）。
+ * 4. `putNode(running)` → driver → 成功 `putNode(completed)` + `artifact-published`；
+ *    失败 `putNode(failed)` + `artifact-failed` → reject。
+ *
+ * 两条路都**不发任何节点生命周期事件**（node-queued / dispatched / settled）：产物站点在两张
+ * 图里都不是节点，一条 node-settled 落在这样的站点上会被投影归约进 `nodes[]`，在 run 面板里
+ * 变成一个无从解释的未知节点。
+ */
+export declare function publishContentArtifact(state: EngineState, siteId: string, op: ArtifactContentOp, args: unknown[]): Promise<ArtifactRef>;
+/**
+ * 声明一个**预置产物**（`artifact.chart` / `table` / `metrics` / `board`）。声明族：同步、
+ * 无返回值、**不经 driver**——一个声明没有可等的东西。
+ *
+ * 顺序：`nextOrdinal` → 命中即返回 → spec 形状校验
+ * → 同 id 既有声明？相同 canonical ⇒ 幂等 no-op（不落新行、不发事件）；不同 ⇒ failRun
+ * → 上限 → `putNode(completed)` + `artifact-published`。
+ *
+ * 三种失败（spec 非法 / 同 id 异 spec / 超上限）全是 failRun 而不是拒绝：void 返回没有拒绝
+ * 通道，与 `report` 的两个上限同一条论证。
+ */
+export declare function declarePresetArtifact(state: EngineState, siteId: string, op: ArtifactPresetOp, args: unknown[]): void;
+/**
+ * resume 恢复：把 journal 里一行**已完成**的产物记录并进内存状态。
+ *
+ * **只有 completed 行才认领 id**：失败的发布不占 id、不占种类、不占版本。这不只是图简洁——
+ * 失败行的 `result` 是空的，种类无从恢复，若让 live 那一侧认领而 resume 那一侧认领不了，
+ * 同一个脚本在崩溃前后就会得到两套上限账。种类冲突另有编译期诊断把守，运行期这条
+ * （`ArtifactKindMismatch`）管的是真正发布成功过的那些 id。
+ */
+export declare function rememberArtifactRow(state: EngineState, id: string | undefined, result: unknown): void;
+/** 该 id 是否已被声明为**预置**产物（`report` 标签的合法目标）。 */
+export declare function isDeclaredPreset(state: EngineState, id: string): boolean;
+/** 已声明的预置 id（字典序）——只用于把 `ArtifactUndeclared` 的消息写得能照做。 */
+export declare function declaredPresetIds(state: EngineState): string[];
+//# sourceMappingURL=engine-artifacts.d.ts.map

package/vendor/dynamic-workflow/engine/engine-artifacts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-artifacts.d.ts","sourceRoot":"","sources":["../../src/engine/engine-artifacts.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,EAEL,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACtB,MAAM,uBAAuB,CAAC;AAS/B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAEV,WAAW,EAGZ,MAAM,YAAY,CAAC;AAGpB;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,MAAM,EACd,EAAE,EAAE,iBAAiB,EACrB,IAAI,EAAE,OAAO,EAAE,GACd,OAAO,CAAC,WAAW,CAAC,CAqItB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,MAAM,EACd,EAAE,EAAE,gBAAgB,EACpB,IAAI,EAAE,OAAO,EAAE,GACd,IAAI,CA0GN;AA2ID;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,WAAW,EAClB,EAAE,EAAE,MAAM,GAAG,SAAS,EACtB,MAAM,EAAE,OAAO,GACd,IAAI,CAaN;AAED,8CAA8C;AAC9C,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAGxE;AAED,0DAA0D;AAC1D,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,EAAE,CAK9D"}