@actor0/harness 0.0.0-stage → 0.5.2

package/dist/answer-filter.d.ts

@@ -0,0 +1,36 @@
+import { type RejectedBlock } from "./tool-call-block.js";
+import type { PlanPrefix, ToolCall } from "./types.js";
+/**
+ * Status text kept from one line.
+ *
+ * A line that opens with the marker is a status line, and its text runs to
+ * the end of that line. Past this many characters it stops being a status and
+ * becomes the answer again, which is what keeps a runaway line from taking the
+ * rest of the response with it.
+ */
+export declare const MAX_STATUS_CHARS = 80;
+export type FilteredChunk = {
+    text: string;
+    statuses: string[];
+    plan: PlanPrefix | null;
+    /** Tool calls the model emitted as protocol blocks (see tool-call-block.ts). */
+    toolCalls: ToolCall[];
+    /**
+     * Blocks the protocol refused — a call for an unoffered tool, or arguments
+     * that were not valid JSON. Each becomes a synthetic call plus an error
+     * tool result, so the model is told next round that the call was wrong and
+     * why; nothing here is ever released into the answer text.
+     */
+    rejected: RejectedBlock[];
+};
+export type AnswerFilter = {
+    push(delta: string): FilteredChunk;
+    flush(): FilteredChunk;
+    reset(): void;
+};
+/**
+ * @param toolNames names from the request's tool list. A block naming
+ *   anything else is not a call and is shown as ordinary text.
+ */
+export declare function createAnswerFilter(toolNames?: string[]): AnswerFilter;
+//# sourceMappingURL=answer-filter.d.ts.map

package/dist/answer-filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"answer-filter.d.ts","sourceRoot":"","sources":["../src/answer-filter.ts"],"names":[],"mappings":"AACA,OAAO,EAWL,KAAK,aAAa,EACnB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAMvD;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,KAAK,CAAC;AA+EnC,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,IAAI,EAAE,UAAU,GAAG,IAAI,CAAC;IACxB,gFAAgF;IAChF,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB;;;;;OAKG;IACH,QAAQ,EAAE,aAAa,EAAE,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,CAAC;IACnC,KAAK,IAAI,aAAa,CAAC;IACvB,KAAK,IAAI,IAAI,CAAC;CACf,CAAC;AAEF;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,GAAE,MAAM,EAAO,GAAG,YAAY,CAkPzE"}

package/dist/answer-filter.js

@@ -0,0 +1,308 @@
+import { extractPlanPrefix, needsMorePlanData } from "./plan-prefix.js";
+import { MAX_TOOL_BLOCK, matchCloseEnvelope, matchCloseFence, matchOpenEnvelope, matchOpenFence, mayBeOpenEnvelope, mayBeOpenFence, parseToolCallBlock, parseToolCallEnvelope, } from "./tool-call-block.js";
+/** Incremental answer filtering for streamed model output. */
+const MAX_STATUS_HOLD = 48;
+const MAYBE_STATUS_PREFIX = /^(?:[ \t]*|[ \t]*\[[^\x5d\n]{0,40})$/;
+/**
+ * Status text kept from one line.
+ *
+ * A line that opens with the marker is a status line, and its text runs to
+ * the end of that line. Past this many characters it stops being a status and
+ * becomes the answer again, which is what keeps a runaway line from taking the
+ * rest of the response with it.
+ */
+export const MAX_STATUS_CHARS = 80;
+/**
+ * Status markers.
+ *
+ * Only the bullet form is recognised: `[·] Searching the web`. That is the
+ * shape the system prompt specifies, and it is the only one that can be told
+ * apart from content by inspection rather than by guesswork.
+ *
+ * The bare bracket form, `[Searching the web]`, used to be accepted too. It is
+ * not any more, because it is genuinely indistinguishable from the link text a
+ * model writes: asked for a landing page, it emitted `[Get Started for Free]`
+ * and `[**Start Building**]`, and both were silently deleted from the answer
+ * along with the call to action. Nothing else in prose looks like `[·]`.
+ *
+ * The asymmetry is deliberate. Missing a status leaves a visible `[·] thing`
+ * line in the answer, which is ugly. Eating a link label is silent content
+ * loss. The ugly failure is the better one.
+ *
+ * One known blind spot, left alone on purpose: a marker-shaped line inside an
+ * ordinary (non-protocol) fenced code block is still eaten as a status. The
+ * filter has no notion of a code fence — only a ```json fence is a block it
+ * tracks, because buffering a bare fence would stall any code-heavy answer
+ * waiting for a close that may never come. Adding fence state to get this
+ * right means implementing CommonMark's opening and closing rules for a line
+ * shape that essentially never occurs, and getting them subtly wrong stalls
+ * the stream. Recorded rather than fixed.
+ */
+/**
+ * A marker owns its line when a newline follows it immediately, which is what
+ * lets the trailing newline be swallowed so markers do not each prepend a
+ * blank line to the answer.
+ */
+const ownsLine = (text, length) => text.indexOf("\n", length) === length;
+/** The marker itself, with the indentation and the space that follow it. */
+const STATUS_MARKER = /^[ \t]*\[\u00b7\][ \t]*/;
+function matchStatusLine(text, atEnd) {
+    const marker = STATUS_MARKER.exec(text);
+    if (!marker)
+        return null;
+    const rest = text.slice(marker[0].length);
+    const text_ = (value) => value.replace(/^\u00b7+\s*/, "").trim().slice(0, MAX_STATUS_CHARS);
+    const newline = rest.indexOf("\n");
+    if (newline !== -1) {
+        // A line past the cap stops being a status halfway: the rest of it is
+        // content, and the newline that ends it is content's, not the status's.
+        const capped = newline > MAX_STATUS_CHARS;
+        return {
+            text: text_(rest.slice(0, newline)),
+            end: marker[0].length + (capped ? MAX_STATUS_CHARS : newline + 1),
+            complete: true,
+        };
+    }
+    if (!atEnd && rest.length <= MAX_STATUS_CHARS)
+        return { text: "", end: 0, complete: false };
+    return { text: text_(rest), end: marker[0].length + MAX_STATUS_CHARS, complete: true };
+}
+/**
+ * @param toolNames names from the request's tool list. A block naming
+ *   anything else is not a call and is shown as ordinary text.
+ */
+export function createAnswerFilter(toolNames = []) {
+    let held = "";
+    let atLineStart = true;
+    let eatNewline = false;
+    let planDone = false;
+    /**
+     * Non-null while inside a protocol block — a ```json fence or a
+     * `<tool_calls>` envelope. Everything from the opening delimiter is
+     * accumulated here and released in one go, so a block split across arbitrary
+     * deltas is never half-shown, and the block's own text is only released if it
+     * turns out not to be a tool call.
+     */
+    let block = null;
+    let blockKind = "fence";
+    /**
+     * Where the block's closer is.
+     *
+     * `pending` is the whole block so far, not just the newest delta: a closing
+     * delimiter can straddle a push boundary, and one that lands half in the
+     * buffer and half in the delta is the normal case for a small-chunked SSE
+     * stream. An envelope resumes its scan where the last one stopped, because
+     * the accumulated half has already been searched and had no close in it.
+     */
+    const findClose = (pending, atEnd) => blockKind === "envelope"
+        ? matchCloseEnvelope(pending, block?.length ?? 0)
+        : matchCloseFence(pending, atEnd);
+    /** The calls and rejections a closed block carries. */
+    const parseClosed = (finished) => {
+        if (blockKind === "envelope")
+            return parseToolCallEnvelope(finished, toolNames);
+        const result = parseToolCallBlock(finished, toolNames);
+        if (result === null)
+            return { calls: [], rejected: [] };
+        if ("reason" in result)
+            return { calls: [], rejected: [result] };
+        return { calls: [result], rejected: [] };
+    };
+    /**
+     * The one place text is turned into visible answer, statuses and tool calls.
+     *
+     * push() and flush() both go through here rather than keeping parallel
+     * copies of the rules: a fence parked in `held` by the plan-prefix logic is
+     * still in the buffer when the stream ends, and a flush path that did not
+     * re-run the loop would show it as text instead of a tool call.
+     *
+     * @param atEnd end of stream — a closing fence is final even without its
+     *   trailing newline, and a block that never closed is released as text.
+     */
+    const run = (delta, atEnd) => {
+        let output = "";
+        const statuses = [];
+        const toolCalls = [];
+        const rejected = [];
+        let plan = null;
+        let buffer = held + delta;
+        held = "";
+        if (!planDone) {
+            const extracted = extractPlanPrefix(buffer);
+            if (extracted.plan) {
+                planDone = true;
+                plan = extracted.plan;
+                buffer = extracted.rest;
+            }
+        }
+        while (buffer.length > 0) {
+            if (eatNewline) {
+                eatNewline = false;
+                if (buffer.startsWith("\r\n"))
+                    buffer = buffer.slice(2);
+                else if (buffer.startsWith("\n"))
+                    buffer = buffer.slice(1);
+                continue;
+            }
+            // Inside a candidate block: nothing may be shown until it closes.
+            if (block !== null) {
+                const pending = block + buffer;
+                const close = findClose(pending, atEnd);
+                if (!close) {
+                    block = pending;
+                    buffer = "";
+                    if (block.length > MAX_TOOL_BLOCK) {
+                        // Unterminated: give up rather than swallow the rest of the answer.
+                        output += block;
+                        block = null;
+                        atLineStart = false;
+                    }
+                    continue;
+                }
+                const finished = pending.slice(0, close.index + close.length);
+                buffer = pending.slice(close.index + close.length);
+                block = null;
+                const parsed = parseClosed(finished);
+                if (parsed.rejected.length > 0) {
+                    rejected.push(...parsed.rejected);
+                    // The block owned its line, so drop the newline that ends it.
+                    eatNewline = true;
+                    atLineStart = true;
+                }
+                else if (parsed.calls.length > 0) {
+                    toolCalls.push(...parsed.calls);
+                    // The block owned its line, so drop the newline that ends it.
+                    //
+                    // Unconditionally, and that is the point: the newline ending a
+                    // block is very often the next delta to arrive, and deciding from
+                    // a buffer that does not hold it yet is how a blank line appeared in
+                    // the answer only when the stream happened to be finely chunked. The
+                    // flag is cleared by the next character whatever it is, so setting
+                    // it for a block followed by anything else costs nothing.
+                    eatNewline = true;
+                    atLineStart = true;
+                }
+                else {
+                    output += finished;
+                    atLineStart = ownsLine(finished, finished.length);
+                }
+                continue;
+            }
+            if (atLineStart) {
+                const fence = matchOpenFence(buffer);
+                const envelope = fence ? null : matchOpenEnvelope(buffer);
+                const open = fence ?? envelope;
+                if (open) {
+                    blockKind = fence ? "fence" : "envelope";
+                    block = buffer.slice(0, open.length);
+                    buffer = buffer.slice(open.length);
+                    continue;
+                }
+                // A delimiter split across deltas ("``" then "`json\n", or "<tool_"
+                // then "calls>"): hold the half rather than releasing it as text. A
+                // handful of characters, released on the next push once this is
+                // clearly not a tool block.
+                if (mayBeOpenFence(buffer) || mayBeOpenEnvelope(buffer)) {
+                    held = buffer;
+                    buffer = "";
+                    continue;
+                }
+            }
+            if (!atLineStart) {
+                const newline = buffer.indexOf("\n");
+                if (newline === -1) {
+                    output += buffer;
+                    buffer = "";
+                }
+                else {
+                    output += buffer.slice(0, newline + 1);
+                    buffer = buffer.slice(newline + 1);
+                    atLineStart = true;
+                }
+                continue;
+            }
+            const status = matchStatusLine(buffer, atEnd);
+            if (status) {
+                if (!status.complete) {
+                    // More of the line may still be coming. Held for exactly as long as
+                    // it takes to find out, and no longer: a fragment that is already
+                    // over the cap stops being a status and falls through to the answer.
+                    held = buffer;
+                    buffer = "";
+                    continue;
+                }
+                if (status.text)
+                    statuses.push(status.text);
+                buffer = buffer.slice(status.end);
+                continue;
+            }
+            // The two "wait and see" holds are only legitimate mid-stream. At the
+            // end there is no more input coming, so holding would strand the text
+            // forever — a plan-shaped prefix must not swallow a tool-call block that
+            // follows it.
+            if (!atEnd) {
+                if (buffer.length < MAX_STATUS_HOLD && MAYBE_STATUS_PREFIX.test(buffer)) {
+                    held = buffer;
+                    buffer = "";
+                    continue;
+                }
+                if (!planDone && output.length === 0 && !plan && needsMorePlanData(buffer)) {
+                    held = buffer;
+                    buffer = "";
+                    continue;
+                }
+            }
+            atLineStart = false;
+        }
+        // A block still open when the buffer runs dry is only decidable at the end
+        // of the stream: its closing fence may be the last thing that arrives, or
+        // it may never come. Left alone it would be dropped — neither shown nor
+        // run — so it is resolved here.
+        if (atEnd && block !== null) {
+            const close = findClose(block, true);
+            const finished = close ? block.slice(0, close.index + close.length) : block;
+            const rest = close ? block.slice(close.index + close.length) : "";
+            block = null;
+            // Never execute a block that never closed: whatever it parses as, it is
+            // the model showing the user JSON, not a protocol message.
+            const parsed = close ? parseClosed(finished) : { calls: [], rejected: [] };
+            if (parsed.rejected.length > 0) {
+                rejected.push(...parsed.rejected);
+                // The block is the protocol, not content: it must not also be shown.
+                output += rest;
+            }
+            else if (parsed.calls.length > 0) {
+                toolCalls.push(...parsed.calls);
+                output += rest;
+            }
+            else {
+                output += finished + rest;
+            }
+        }
+        return { text: output, statuses, plan, toolCalls, rejected };
+    };
+    return {
+        push(delta) {
+            return run(delta, false);
+        },
+        flush() {
+            atLineStart = true;
+            eatNewline = false;
+            const result = run("", true);
+            // `run` may have parked a final fragment (a half fence, a status
+            // prefix). Nothing more is coming, so release it as answer text.
+            if (held) {
+                result.text += held;
+                held = "";
+            }
+            return result;
+        },
+        reset() {
+            held = "";
+            atLineStart = true;
+            eatNewline = false;
+            planDone = false;
+            block = null;
+        },
+    };
+}

package/dist/harness.d.ts

@@ -0,0 +1,154 @@
+import type { ChatMessage, HarnessObserver, ModelClient, RoundResult, RunResult, ToolHost, ToolRoundPolicy } from "./types.js";
+export type HarnessConfig = {
+    maxRetries: number;
+    initialBackoffMs: number;
+    maxBackoffMs: number;
+    idleTimeoutMs: number;
+    /**
+     * Hard cap on tool rounds. Defaults to unbounded — a turn that needs to
+     * research for hours should be allowed to. A caller that pays per round
+     * should set it: reaching it ends the turn with `needs_user` and everything
+     * the rounds already produced, never a thrown error.
+     */
+    maxToolRounds: number;
+    /**
+     * Consecutive rounds in which *every* tool call failed. Reaching this stops
+     * the turn and reports `needs_user` rather than throwing, so the caller can
+     * ask whether to continue. A single bad call is normal and never counts.
+     */
+    maxConsecutiveToolErrors: number;
+    recoverEmptyAnswer: boolean;
+    /**
+     * Whether one continuation is attempted when the endpoint cuts an answer
+     * off at its output cap. Once, not repeatedly: a model that is too long
+     * for the cap is too long for it twice, and the second attempt costs a
+     * full request to learn the same thing.
+     */
+    recoverTruncatedAnswer: boolean;
+};
+export declare const DEFAULT_HARNESS_CONFIG: HarnessConfig;
+/** Marker appended to an answer a cancel cut short. */
+export declare const INTERRUPT_MARKER = "[interrupted]";
+/**
+ * `text` with the interrupt marker appended, or the marker alone when the
+ * cancel landed before anything streamed. The marker is what tells a resumed
+ * session that the text above it is a fragment the user stopped, not a
+ * completed answer the model should stand behind.
+ */
+export declare function withInterruptMarker(text: string): string;
+/** Marker appended to an answer a failed turn cut short. */
+export declare const FAILED_MARKER = "[failed]";
+/**
+ * `text` with the failure marker appended, or the marker alone when
+ * the failure landed before anything streamed. The marker is what
+ * tells a resumed session that the text above it is a fragment of a
+ * failed attempt, not a completed answer the model stands behind.
+ */
+export declare function withFailedMarker(text: string): string;
+/** Marker appended to an answer the endpoint cut off at its output cap. */
+export declare const TRUNCATED_MARKER = "[cut off at the output limit]";
+/**
+ * `text` with the truncation marker appended, or the marker alone when
+ * the answer never started.
+ *
+ * The third of the three markers a terminal state leaves in the
+ * transcript, and the only one whose host flag was optional: a cancel and a
+ * failure each had to hand the transcript back with the marker on it, while
+ * a cut-off answer was saved as the plain words the model had written so
+ * far. It is not a completed reply and the transcript is what the next turn
+ * reads first, so the marker goes here rather than in whichever host
+ * remembered to render `RunResult.truncated`.
+ */
+export declare function withTruncationMarker(text: string): string;
+/**
+ * What a tool call that a cancel cut short is answered with.
+ *
+ * It is the model's half of the record: the call happened, the command may
+ * have done anything, and nobody knows what it produced. Exported because
+ * the same sentence is now also the event the host shows the user, and a
+ * host that renders its own copy must not be able to word it differently
+ * from the one the next turn's model reads.
+ */
+export declare const CANCELLED_TOOL_RESULT = "[cancelled] The turn was interrupted around this call, so its result is unknown. Run it again if you still need it.";
+/**
+ * Thrown when the caller aborted a turn. Carries the transcript as the turn
+ * left it — the input, every finished round, answers for calls the cancel cut
+ * short, and the partial answer marked interrupted — so a host can persist an
+ * exchange the user watched happen. Without it, a cancel rewinds the
+ * conversation to before the turn: the work vanishes from the saved session
+ * and a resume replays it from zero.
+ *
+ * The transcript is API-valid by construction (see `abortTurn`), so a host can
+ * save it as-is and the next request will be accepted.
+ */
+export declare class AbortedTurnError extends Error {
+    readonly messages: ChatMessage[];
+    /** What the cancelled attempt had streamed, without the marker. */
+    readonly partialText: string;
+    constructor(messages: ChatMessage[], 
+    /** What the cancelled attempt had streamed, without the marker. */
+    partialText: string);
+}
+/**
+ * Thrown when a turn failed for any reason other than a cancel: the
+ * endpoint refused the request, the stream died mid-answer, a retry
+ * budget ran out. Carries the transcript as the turn left it — the
+ * input, every finished round, and the partial answer marked failed
+ * — so a host can persist an exchange whose later rounds really
+ * happened. Without it, a mid-turn failure rewinds the conversation
+ * to before the turn: tool calls that ran and files that changed
+ * vanish from the saved session, and a resume replays them from zero
+ * as though they never happened. Claude Code yields the error into
+ * the conversation instead of rewinding, and so does this.
+ *
+ * The transcript is API-valid by construction (see `failedTurn`), so
+ * a host can save it as-is and the next request will be accepted.
+ */
+export declare class FailedTurnError extends Error {
+    readonly messages: ChatMessage[];
+    /** What the failed attempt had streamed, without the marker. */
+    readonly partialText: string;
+    constructor(messages: ChatMessage[], 
+    /** What the failed attempt had streamed, without the marker. */
+    partialText: string, cause?: unknown);
+}
+export declare function runModelRound(model: ModelClient, messages: ChatMessage[], tools: Parameters<ModelClient["stream"]>[1], signal: AbortSignal, observer?: HarnessObserver, config?: HarnessConfig): Promise<RoundResult>;
+export declare function runAgentTurn(options: {
+    model: ModelClient;
+    messages: ChatMessage[];
+    input: string;
+    toolHost?: ToolHost;
+    signal: AbortSignal;
+    observer?: HarnessObserver;
+    config?: HarnessConfig;
+    policy?: ToolRoundPolicy;
+}): Promise<RunResult>;
+/**
+ * Jitter added to every wait, as a fraction of the delay itself.
+ *
+ * Without it, every client that hit a rate limit in the same second comes back
+ * in the same second, and the limit that just rejected them rejects them
+ * again. It is added and never subtracted: a wait shorter than the backoff it
+ * is jittering is not a backoff.
+ */
+export declare const RETRY_JITTER_RATIO = 0.25;
+/**
+ * How long to wait before the next attempt.
+ *
+ * Two inputs, and the second can only make the wait longer:
+ *
+ *  - exponential backoff, capped, which is what a dropped connection or a
+ *    5xx wants;
+ *  - `Retry-After`, which is the server stating a rate limit window. A 429
+ *    that says "come back in 30" and is retried after one, two and four
+ *    seconds has honoured nothing: every attempt lands inside the window and
+ *    the turn fails having spent seven seconds confirming what it was told.
+ *
+ * A wait beyond `MAX_HONOURED_RETRY_AFTER_MS` never reaches here — the
+ * transport has already made that failure non-retriable rather than have the
+ * turn vanish for a number of minutes a user is waiting on.
+ *
+ * Exported so the arithmetic can be tested without sleeping through it.
+ */
+export declare function retryDelay(attempt: number, config: HarnessConfig, error?: unknown): number;
+//# sourceMappingURL=harness.d.ts.map

package/dist/harness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"harness.d.ts","sourceRoot":"","sources":["../src/harness.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,WAAW,EACX,eAAe,EACf,WAAW,EAGX,WAAW,EACX,SAAS,EAET,QAAQ,EACR,eAAe,EAGhB,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,aAAa,GAAG;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,MAAM,CAAC;IACzB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,aAAa,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,wBAAwB,EAAE,MAAM,CAAC;IACjC,kBAAkB,EAAE,OAAO,CAAC;IAC5B;;;;;OAKG;IACH,sBAAsB,EAAE,OAAO,CAAC;CACjC,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,aASpC,CAAC;AAEF,uDAAuD;AACvD,eAAO,MAAM,gBAAgB,kBAAkB,CAAC;AAEhD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGxD;AAED,4DAA4D;AAC5D,eAAO,MAAM,aAAa,aAAa,CAAC;AAExC;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGrD;AAED,2EAA2E;AAC3E,eAAO,MAAM,gBAAgB,kCAAkC,CAAC;AAEhE;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGzD;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,wHACqF,CAAC;AAExH;;;;;;;;;;GAUG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;IAEvC,QAAQ,CAAC,QAAQ,EAAE,WAAW,EAAE;IAChC,mEAAmE;IACnE,QAAQ,CAAC,WAAW,EAAE,MAAM;gBAFnB,QAAQ,EAAE,WAAW,EAAE;IAChC,mEAAmE;IAC1D,WAAW,EAAE,MAAM;CAK/B;AAED;;;;;;;;;;;;;;GAcG;AACH,qBAAa,eAAgB,SAAQ,KAAK;IAEtC,QAAQ,CAAC,QAAQ,EAAE,WAAW,EAAE;IAChC,gEAAgE;IAChE,QAAQ,CAAC,WAAW,EAAE,MAAM;gBAFnB,QAAQ,EAAE,WAAW,EAAE;IAChC,gEAAgE;IACvD,WAAW,EAAE,MAAM,EAC5B,KAAK,CAAC,EAAE,OAAO;CAKlB;AAED,wBAAsB,aAAa,CACjC,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,WAAW,EAAE,EACvB,KAAK,EAAE,UAAU,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,EAC3C,MAAM,EAAE,WAAW,EACnB,QAAQ,CAAC,EAAE,eAAe,EAC1B,MAAM,GAAE,aAAsC,GAC7C,OAAO,CAAC,WAAW,CAAC,CAwBtB;AA0KD,wBAAsB,YAAY,CAAC,OAAO,EAAE;IAC1C,KAAK,EAAE,WAAW,CAAC;IACnB,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,MAAM,EAAE,WAAW,CAAC;IACpB,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB,MAAM,CAAC,EAAE,eAAe,CAAC;CAC1B,GAAG,OAAO,CAAC,SAAS,CAAC,CAqRrB;AAqHD;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,OAAO,CAAC;AAEvC;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,MAAM,CAI1F"}