harnery 0.10.0 → 0.11.0

package/dist/commands/workflow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"workflow.d.ts","sourceRoot":"","sources":["../../src/commands/workflow.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AA0BnD,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CA+FjF"}
+{"version":3,"file":"workflow.d.ts","sourceRoot":"","sources":["../../src/commands/workflow.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AA8BnD,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CA+IjF"}

package/dist/commands/workflow.js

@@ -9,7 +9,7 @@ export function registerWorkflowCommand(program, emit) {
         .description("Run bounded, schema-gated multi-subagent workflow scripts.");
     workflow
         .command("run <script>")
-        .description("Execute a workflow script (plain JS: `export default async ({agent, parallel, stage, log}) => …`). " +
+        .description("Execute a workflow script (plain JS: `export default async ({agent, parallel, stage, log, evidence}) => …`). " +
         "Subagents spawn as headless harness-CLI subprocesses, coordination-registered.")
         .option("--max-agents <n>", "Total-agent ceiling for the run (default 50)")
         .option("--concurrency <n>", "Concurrent-subagent cap (default 4)")
@@ -59,6 +59,12 @@ export function registerWorkflowCommand(program, emit) {
                 maxAgents: opts.maxAgents ? Number.parseInt(opts.maxAgents, 10) : undefined,
                 concurrency: opts.concurrency ? Number.parseInt(opts.concurrency, 10) : undefined,
                 cwd: opts.cwd,
+                harnessEvidence: Object.fromEntries(registry
+                    .list()
+                    .map((adapter) => [
+                    adapter.profile.id,
+                    { toolEvidence: adapter.profile.capabilities.toolEvidence },
+                ])),
             });
             if (opts.json) {
                 emit.config({ format: "json" });
@@ -71,11 +77,48 @@ export function registerWorkflowCommand(program, emit) {
                 : "";
             emit.text(`run ${report.runId} (${report.name}) finished: ${report.agentsSpawned} agent(s)${cachedPart}, ` +
                 `$${report.costUsd.toFixed(4)}, ${Math.round(report.durationMs / 1000)}s\n${billingPart}` +
+                `acceptance: ${report.acceptance.satisfied} satisfied, ${report.acceptance.unsatisfied} unsatisfied, ` +
+                `${report.acceptance.unknown} unknown\n` +
                 `journal: ${report.journalPath}\n` +
+                `proof: ${report.proofPath}\n` +
                 `result: ${typeof report.result === "string" ? report.result : JSON.stringify(report.result, null, 2)}\n`);
         }
         catch (err) {
-            emit.error({ code: "workflow_failed", message: err.message });
+            const proofPath = typeof err === "object" && err !== null && "proofPath" in err
+                ? String(err.proofPath)
+                : undefined;
+            emit.error({
+                code: "workflow_failed",
+                message: `${err.message}${proofPath ? `\nproof: ${proofPath}` : ""}`,
+            });
+            process.exit(1);
+        }
+    });
+    workflow
+        .command("proof <run-id>")
+        .description("Show the bounded proof packet for a completed workflow run.")
+        .option("--json", "Emit the stored proof packet as JSON")
+        .action(async (runId, opts) => {
+        const coordRoot = findCoordRoot();
+        if (!coordRoot) {
+            emit.error({
+                code: "no_coord_root",
+                message: "no .harnery/ coordination root found; run `init` first",
+            });
+            process.exit(1);
+        }
+        try {
+            const { readWorkflowProof, renderWorkflowProof } = await import("../core/workflow/proof.js");
+            const proof = readWorkflowProof(coordRoot, runId);
+            if (opts.json) {
+                emit.config({ format: "json" });
+                emit.data(proof);
+                return;
+            }
+            emit.text(renderWorkflowProof(proof));
+        }
+        catch (err) {
+            emit.error({ code: "workflow_proof_failed", message: err.message });
             process.exit(1);
         }
     });

package/dist/core/workflow/engine.d.ts

@@ -17,5 +17,10 @@
  *     cost, duration, and child session id (the resume + web-UI substrate).
  */
 import type { EngineOpts, RunReport } from "./types.js";
+export declare class WorkflowRunError extends Error {
+    readonly runId: string;
+    readonly proofPath: string;
+    constructor(message: string, runId: string, proofPath: string, cause?: unknown);
+}
 export declare function runWorkflow(scriptPath: string, opts: EngineOpts): Promise<RunReport>;
 //# sourceMappingURL=engine.d.ts.map

package/dist/core/workflow/engine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../../src/core/workflow/engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAOH,OAAO,KAAK,EAEV,UAAU,EAEV,SAAS,EAIV,MAAM,YAAY,CAAC;AASpB,wBAAsB,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,CAgS1F"}
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../../src/core/workflow/engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAeH,OAAO,KAAK,EAEV,UAAU,EAEV,SAAS,EAOV,MAAM,YAAY,CAAC;AAUpB,qBAAa,gBAAiB,SAAQ,KAAK;IACzC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;gBAEf,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO;CAM/E;AAED,wBAAsB,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,CAqa1F"}

package/dist/core/workflow/engine.js

@@ -28,29 +28,46 @@ import { createHash, randomBytes } from "node:crypto";
 import { appendFileSync, existsSync, mkdirSync, readFileSync, statSync } from "node:fs";
 import { isAbsolute, join, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
+import { snapshotRepo } from "../context/index.js";
 import { probeBilling } from "./billing.js";
+import { buildWorkflowProof, createEvidenceRecord, digestResult, normalizeWorkflowMeta, writeWorkflowProof, } from "./proof.js";
+import { WORKFLOW_PROOF_SCHEMA_VERSION } from "./types.js";
 import { parseStageOutput, validateAgainstSchema } from "./validate.js";
 const DEFAULT_MAX_AGENTS = 50;
 const DEFAULT_CONCURRENCY = 4;
 const DEFAULT_MAX_ATTEMPTS = 2;
 const DEFAULT_TIMEOUT_MS = 300_000;
 const DEFAULT_MAX_TURNS = 25;
+export class WorkflowRunError extends Error {
+    runId;
+    proofPath;
+    constructor(message, runId, proofPath, cause) {
+        super(message, cause === undefined ? undefined : { cause });
+        this.name = "WorkflowRunError";
+        this.runId = runId;
+        this.proofPath = proofPath;
+    }
+}
 export async function runWorkflow(scriptPath, opts) {
     const absScript = isAbsolute(scriptPath) ? scriptPath : resolve(process.cwd(), scriptPath);
     const mod = (await import(__rewriteRelativeImportExtension(pathToFileURL(absScript).href)));
     if (typeof mod.default !== "function") {
         throw new Error(`${scriptPath}: workflow script must \`export default async (ctx) => …\``);
     }
-    const name = mod.meta?.name ?? scriptPath.replace(/^.*\//, "").replace(/\.[cm]?js$/, "");
+    const fallbackName = scriptPath.replace(/^.*\//, "").replace(/\.[cm]?js$/, "");
+    const meta = normalizeWorkflowMeta(mod.meta, fallbackName);
+    const name = meta.name;
     const runId = `wf-${new Date().toISOString().replace(/[:.]/g, "-")}-${randomBytes(3).toString("hex")}`;
     const runDir = join(opts.coordRoot, ".harnery", "workflows", runId);
     mkdirSync(runDir, { recursive: true });
     const journalPath = join(runDir, "journal.jsonl");
+    const proofPath = join(runDir, "proof.json");
     const maxAgents = opts.maxAgents ?? DEFAULT_MAX_AGENTS;
     const concurrency = opts.concurrency ?? DEFAULT_CONCURRENCY;
     const cwd = opts.cwd ?? opts.coordRoot;
     const log = opts.onLog ?? ((line) => process.stderr.write(`${line}\n`));
     const defaultHarness = opts.defaultHarness ?? "claude-code";
+    const repoBefore = snapshotRepo(cwd);
     // Per-child fixed context overhead: children spawn in `cwd` and load its
     // repo-instructions file into their system prompt, cache-writing it once
     // per child. A fan-out multiplies this, so surface it BEFORE the burn.
@@ -68,9 +85,15 @@ export async function runWorkflow(scriptPath, opts) {
     let costUsd = 0;
     let currentStage = "";
     let agentSeq = 0;
+    let evidenceSeq = 0;
     const billingProbed = new Map();
+    const agentProofs = new Map();
+    const evidenceRecords = [];
+    const acceptanceIds = new Set(meta.acceptance.map((criterion) => criterion.id));
     const journal = (event, data) => {
         const line = JSON.stringify({
+            schema_version: WORKFLOW_PROOF_SCHEMA_VERSION,
+            run_id: runId,
             ts: new Date().toISOString(),
             event,
             stage: currentStage,
@@ -103,14 +126,35 @@ export async function runWorkflow(scriptPath, opts) {
         }
         const id = `a${++agentSeq}`;
         const label = agentOpts.label ?? `${prompt.slice(0, 60).replace(/\s+/g, " ")}…`;
+        const proofLabel = agentOpts.label ?? id;
         const maxAttempts = agentOpts.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+        const agentProof = {
+            id,
+            label: proofLabel,
+            stage: currentStage || undefined,
+            harness,
+            model: agentOpts.model,
+            status: "failed",
+            attempts: 0,
+            duration_ms: 0,
+        };
+        agentProofs.set(id, agentProof);
         // Call identity for resume: same stage + harness + model + effort + turns + schema
         // + ORIGINAL prompt → same key. Retry-mutated prompts never enter the key.
         const key = agentCallKey(currentStage, harness, agentOpts, prompt);
         const cached = resumeCache.get(key);
         if (cached) {
             agentsCached++;
-            journal("agent.cached", { id, label, key, kind: cached.kind });
+            agentProof.status = "cached";
+            agentProof.result = digestResult(cached.value, cached.kind);
+            journal("agent.cached", {
+                id,
+                label,
+                key,
+                harness,
+                model: agentOpts.model ?? null,
+                kind: cached.kind,
+            });
             log(`[${name}] ${currentStage || "(no stage)"} → ${id} ${label} (cached from ${opts.resumeFrom})`);
             return cached.value;
         }
@@ -154,6 +198,7 @@ export async function runWorkflow(scriptPath, opts) {
             }
         }
         if (agentsSpawned >= maxAgents) {
+            agentProof.error = `workflow agent cap reached (${maxAgents})`;
             throw new Error(`workflow agent cap reached (${maxAgents}); raise --max-agents deliberately if the fan-out is intended`);
         }
         agentsSpawned++;
@@ -170,6 +215,7 @@ export async function runWorkflow(scriptPath, opts) {
             log(`[${name}] ${currentStage || "(no stage)"} → ${id} [${harness}] ${label}`);
             let attemptPrompt = prompt;
             let last = null;
+            let agentCostUsd = 0;
             for (let attempt = 1; attempt <= maxAttempts; attempt++) {
                 last = await spawner({
                     prompt: attemptPrompt,
@@ -181,12 +227,20 @@ export async function runWorkflow(scriptPath, opts) {
                     runId,
                     subscriptionOnly: opts.subscriptionOnly,
                 });
+                agentProof.attempts = attempt;
+                agentProof.duration_ms += last.durationMs;
+                agentCostUsd += last.costUsd ?? 0;
                 costUsd += last.costUsd ?? 0;
                 if (!last.ok) {
                     journal("agent.attempt_failed", { id, attempt, error: last.error });
                     continue; // spawn-level failure: retry with the original prompt
                 }
                 if (!agentOpts.schema) {
+                    agentProof.status = "succeeded";
+                    agentProof.cost_usd =
+                        agentCostUsd > 0 || last.costUsd !== undefined ? agentCostUsd : undefined;
+                    agentProof.session_id = last.sessionId;
+                    agentProof.result = digestResult(last.text, "text");
                     journal("agent.end", {
                         id,
                         key,
@@ -204,6 +258,11 @@ export async function runWorkflow(scriptPath, opts) {
                     ? [parsed.error]
                     : validateAgainstSchema(parsed.value, agentOpts.schema);
                 if (problems.length === 0) {
+                    agentProof.status = "succeeded";
+                    agentProof.cost_usd =
+                        agentCostUsd > 0 || last.costUsd !== undefined ? agentCostUsd : undefined;
+                    agentProof.session_id = last.sessionId;
+                    agentProof.result = digestResult(parsed.value, "json");
                     journal("agent.end", {
                         id,
                         key,
@@ -227,8 +286,16 @@ export async function runWorkflow(scriptPath, opts) {
             const reason = last?.ok
                 ? `schema validation failed after ${maxAttempts} attempt(s)`
                 : (last?.error ?? "spawn failed");
+            agentProof.cost_usd =
+                agentCostUsd > 0 || last?.costUsd !== undefined ? agentCostUsd : undefined;
+            agentProof.session_id = last?.sessionId;
+            agentProof.error = reason;
             journal("agent.failed", { id, error: reason });
-            throw new Error(`agent ${id} (${label}): ${reason}`);
+            throw new Error(`agent ${proofLabel}: ${reason}`);
+        }
+        catch (error) {
+            agentProof.error ??= error.message;
+            throw error;
         }
         finally {
             release();
@@ -248,11 +315,62 @@ export async function runWorkflow(scriptPath, opts) {
         journal("stage.start", { title });
         log(`[${name}] ── stage: ${title}`);
     };
-    const ctx = { agent, parallel, stage, log };
+    const evidence = (input) => {
+        const record = createEvidenceRecord({
+            value: input,
+            sequence: evidenceSeq + 1,
+            acceptanceIds,
+            stage: currentStage || undefined,
+        });
+        evidenceSeq++;
+        evidenceRecords.push(record);
+        journal("evidence.recorded", { ...record });
+        return record.id;
+    };
+    const ctx = { agent, parallel, stage, log, evidence };
     const t0 = Date.now();
-    journal("run.start", { name, script: absScript, max_agents: maxAgents, concurrency });
+    const startedAt = new Date(t0).toISOString();
+    journal("run.start", {
+        name,
+        script: absScript,
+        objective: meta.objective ?? null,
+        acceptance: meta.acceptance,
+        max_agents: maxAgents,
+        concurrency,
+    });
     try {
         const result = await mod.default(ctx);
+        const endedAt = new Date().toISOString();
+        const durationMs = Date.now() - t0;
+        journal("run.end", {
+            ok: true,
+            agents: agentsSpawned,
+            cached: agentsCached,
+            cost_usd: round4(costUsd),
+            duration_ms: durationMs,
+        });
+        let proof;
+        try {
+            proof = buildWorkflowProof({
+                runId,
+                meta,
+                status: "succeeded",
+                startedAt,
+                endedAt,
+                durationMs,
+                journalPath,
+                before: repoBefore,
+                after: snapshotRepo(cwd),
+                agents: Array.from(agentProofs.values()),
+                evidence: evidenceRecords,
+                harnessEvidence: opts.harnessEvidence,
+                result,
+            });
+            writeWorkflowProof(proofPath, proof);
+        }
+        catch (error) {
+            throw new WorkflowRunError(`workflow completed but its proof packet could not be written: ${error.message}`, runId, proofPath, error);
+        }
         const report = {
             runId,
             name,
@@ -260,32 +378,53 @@ export async function runWorkflow(scriptPath, opts) {
             agentsSpawned,
             agentsCached,
             costUsd: round4(costUsd),
-            durationMs: Date.now() - t0,
+            durationMs,
             journalPath,
+            proofPath,
+            acceptance: proof.acceptance.summary,
             contextTokensPerChildEstimate,
             billing: Array.from(billingProbed.values()).map((p) => ({
                 harness: p.harness,
                 mode: opts.subscriptionOnly ? "subscription" : p.mode,
             })),
         };
-        journal("run.end", {
-            ok: true,
-            agents: agentsSpawned,
-            cached: agentsCached,
-            cost_usd: report.costUsd,
-            duration_ms: report.durationMs,
-        });
         return report;
     }
     catch (err) {
+        if (err instanceof WorkflowRunError)
+            throw err;
+        const endedAt = new Date().toISOString();
+        const durationMs = Date.now() - t0;
         journal("run.end", {
             ok: false,
             error: err.message,
             agents: agentsSpawned,
             cached: agentsCached,
             cost_usd: round4(costUsd),
+            duration_ms: durationMs,
         });
-        throw err;
+        try {
+            const proof = buildWorkflowProof({
+                runId,
+                meta,
+                status: "failed",
+                startedAt,
+                endedAt,
+                durationMs,
+                journalPath,
+                before: repoBefore,
+                after: snapshotRepo(cwd),
+                agents: Array.from(agentProofs.values()),
+                evidence: evidenceRecords,
+                harnessEvidence: opts.harnessEvidence,
+                error: err.message,
+            });
+            writeWorkflowProof(proofPath, proof);
+        }
+        catch (proofError) {
+            throw new WorkflowRunError(`${err.message}; proof packet write also failed: ${proofError.message}`, runId, proofPath, err);
+        }
+        throw new WorkflowRunError(err.message, runId, proofPath, err);
     }
 }
 /** Stable identity for one agent() call, for the resume cache. The ORIGINAL

package/dist/core/workflow/index.d.ts

@@ -0,0 +1,5 @@
+export { runWorkflow, WorkflowRunError } from "./engine.js";
+export { buildWorkflowProof, createEvidenceRecord, digestResult, normalizeWorkflowMeta, readWorkflowProof, renderWorkflowProof, rollupAcceptance, writeWorkflowProof, } from "./proof.js";
+export type { AcceptanceCriterion, AcceptanceResult, AcceptanceStatus, AcceptanceSummary, AgentOpts, EngineOpts, EvidenceKind, EvidenceSource, EvidenceStatus, HarnessEvidenceCapability, HarnessEvidenceCoverage, HarnessName, ResultDigest, RunReport, Spawner, SpawnRequest, SpawnResult, StageSchema, WorkflowAgentProof, WorkflowContext, WorkflowEvidenceInput, WorkflowEvidenceRecord, WorkflowMeta, WorkflowModule, WorkflowProof, WorkflowProofUnknown, WorkflowRepoEvidence, WorkflowRepoSnapshot, WorkflowRunStatus, } from "./types.js";
+export { WORKFLOW_PROOF_SCHEMA_VERSION } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/core/workflow/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/workflow/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC5D,OAAO,EACL,kBAAkB,EAClB,oBAAoB,EACpB,YAAY,EACZ,qBAAqB,EACrB,iBAAiB,EACjB,mBAAmB,EACnB,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,YAAY,CAAC;AACpB,YAAY,EACV,mBAAmB,EACnB,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,SAAS,EACT,UAAU,EACV,YAAY,EACZ,cAAc,EACd,cAAc,EACd,yBAAyB,EACzB,uBAAuB,EACvB,WAAW,EACX,YAAY,EACZ,SAAS,EACT,OAAO,EACP,YAAY,EACZ,WAAW,EACX,WAAW,EACX,kBAAkB,EAClB,eAAe,EACf,qBAAqB,EACrB,sBAAsB,EACtB,YAAY,EACZ,cAAc,EACd,aAAa,EACb,oBAAoB,EACpB,oBAAoB,EACpB,oBAAoB,EACpB,iBAAiB,GAClB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,6BAA6B,EAAE,MAAM,YAAY,CAAC"}

package/dist/core/workflow/index.js

@@ -0,0 +1,3 @@
+export { runWorkflow, WorkflowRunError } from "./engine.js";
+export { buildWorkflowProof, createEvidenceRecord, digestResult, normalizeWorkflowMeta, readWorkflowProof, renderWorkflowProof, rollupAcceptance, writeWorkflowProof, } from "./proof.js";
+export { WORKFLOW_PROOF_SCHEMA_VERSION } from "./types.js";

package/dist/core/workflow/proof.d.ts

@@ -0,0 +1,42 @@
+import type { RepoSnapshot } from "../context/index.js";
+import type { AcceptanceCriterion, AcceptanceResult, AcceptanceSummary, HarnessEvidenceCapability, ResultDigest, WorkflowAgentProof, WorkflowEvidenceInput, WorkflowEvidenceRecord, WorkflowMeta, WorkflowProof } from "./types.js";
+export interface NormalizedWorkflowMeta {
+    name: string;
+    description?: string;
+    objective?: string;
+    acceptance: AcceptanceCriterion[];
+}
+export interface BuildWorkflowProofInput {
+    runId: string;
+    meta: NormalizedWorkflowMeta;
+    status: "succeeded" | "failed";
+    startedAt: string;
+    endedAt: string;
+    durationMs: number;
+    journalPath: string;
+    before: RepoSnapshot;
+    after: RepoSnapshot;
+    agents: WorkflowAgentProof[];
+    evidence: WorkflowEvidenceRecord[];
+    harnessEvidence?: Readonly<Record<string, HarnessEvidenceCapability | undefined>>;
+    result?: unknown;
+    error?: string;
+}
+export declare function normalizeWorkflowMeta(meta: WorkflowMeta | undefined, fallbackName: string): NormalizedWorkflowMeta;
+export declare function createEvidenceRecord(input: {
+    value: WorkflowEvidenceInput;
+    sequence: number;
+    acceptanceIds: ReadonlySet<string>;
+    stage?: string;
+    recordedAt?: string;
+}): WorkflowEvidenceRecord;
+export declare function rollupAcceptance(criteria: AcceptanceCriterion[], evidence: WorkflowEvidenceRecord[]): {
+    criteria: AcceptanceResult[];
+    summary: AcceptanceSummary;
+};
+export declare function digestResult(value: unknown, kind?: "text" | "json"): ResultDigest;
+export declare function buildWorkflowProof(input: BuildWorkflowProofInput): WorkflowProof;
+export declare function writeWorkflowProof(path: string, proof: WorkflowProof): void;
+export declare function readWorkflowProof(coordRoot: string, runId: string): WorkflowProof;
+export declare function renderWorkflowProof(proof: WorkflowProof): string;
+//# sourceMappingURL=proof.d.ts.map

package/dist/core/workflow/proof.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proof.d.ts","sourceRoot":"","sources":["../../../src/core/workflow/proof.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EACV,mBAAmB,EACnB,gBAAgB,EAChB,iBAAiB,EACjB,yBAAyB,EAEzB,YAAY,EACZ,kBAAkB,EAClB,qBAAqB,EACrB,sBAAsB,EACtB,YAAY,EACZ,aAAa,EAId,MAAM,YAAY,CAAC;AAepB,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,mBAAmB,EAAE,CAAC;CACnC;AAED,MAAM,WAAW,uBAAuB;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,sBAAsB,CAAC;IAC7B,MAAM,EAAE,WAAW,GAAG,QAAQ,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,YAAY,CAAC;IACrB,KAAK,EAAE,YAAY,CAAC;IACpB,MAAM,EAAE,kBAAkB,EAAE,CAAC;IAC7B,QAAQ,EAAE,sBAAsB,EAAE,CAAC;IACnC,eAAe,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,yBAAyB,GAAG,SAAS,CAAC,CAAC,CAAC;IAClF,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,YAAY,GAAG,SAAS,EAC9B,YAAY,EAAE,MAAM,GACnB,sBAAsB,CAqCxB;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE;IAC1C,KAAK,EAAE,qBAAqB,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACnC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,GAAG,sBAAsB,CA6BzB;AAED,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,mBAAmB,EAAE,EAC/B,QAAQ,EAAE,sBAAsB,EAAE,GACjC;IAAE,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IAAC,OAAO,EAAE,iBAAiB,CAAA;CAAE,CAuB9D;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,YAAY,CAQjF;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,uBAAuB,GAAG,aAAa,CAwChF;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,GAAG,IAAI,CAe3E;AAED,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,aAAa,CAkBjF;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,aAAa,GAAG,MAAM,CA8BhE"}