@nexrall/code-core 1.4.26 → 1.4.27

package/dist/agent/loop.d.ts

@@ -1,4 +1,24 @@
 import type { Message, AgentLoopOptions, EnvContext } from '../types';
+/**
+ * Fingerprint one round's tool failures, for the repeated-failure runaway guard.
+ *
+ * Exported (with the limits) purely as a test seam: the guard's whole value is in the
+ * edge cases — that a DIFFERENT error each round must NOT trip it, that call order
+ * within a round is irrelevant, that a long error body doesn't make every occurrence
+ * look unique — and none of that is reachable without driving a live model loop.
+ *
+ * Sorted so parallel tool calls completing in a different order still compare equal;
+ * truncated because errors often embed a varying path or timestamp late in the string.
+ */
+export declare function errorRoundSignature(errored: Array<{
+    name: string;
+    error: string;
+}>): string;
+/** Runaway-guard limits, exposed for tests. */
+export declare const _stallLimits: {
+    STALL_LIMIT: number;
+    REPEAT_STALL_LIMIT: number;
+};
 export declare function resolveMaxIterations(optionValue: number | undefined, settingsRaw: Record<string, unknown>): number;
 /**
  * Minimal concurrency gate. Hand-rolled rather than pulling in `p-limit` because
@@ -111,6 +131,15 @@ export interface ProgressLedger {
         tool: string;
         edits: number;
     }>;
+    /**
+     * DISTINCT paths ever touched, including any since evicted from `filesTouched`.
+     *
+     * The Map is bounded (see ledgerRecord), so `filesTouched.size` is a window, not a
+     * total. The preamble states "FILES CHANGED THIS SESSION (N)" as a fact the model
+     * reasons about, so N must not silently shrink when eviction kicks in on a very long
+     * run — that would tell the model less work happened than actually did.
+     */
+    filesTouchedTotal: number;
     verifications: Array<{
         cmd: string;
         ok: boolean;
@@ -121,6 +150,19 @@ export interface ProgressLedger {
         path: string;
         reason: string;
     }>;
+    /**
+     * TOTAL test-integrity findings ever recorded, including ones since trimmed.
+     *
+     * `testIntegrity` is a bounded window (older entries are spliced off once it grows
+     * past 2×LEDGER_MAX_NOTES), so its `.length` STOPS being a running total after the
+     * first trim. The one-shot nudge compares "how many findings exist" against "how
+     * many I've already surfaced", and comparing against a window that shrinks meant the
+     * count could never move ahead again — silently disabling the reward-hacking warning
+     * for the remainder of a long session, i.e. exactly when it matters most.
+     *
+     * This counter only ever increases, so it is a safe basis for that comparison.
+     */
+    testIntegrityTotal: number;
     /**
      * Monotonic mutation epoch: incremented on every successful source write. Two
      * verification runs sharing an epoch had NO edit between them, so a PASS↔FAIL

package/dist/agent/loop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loop.d.ts","sourceRoot":"","sources":["../../src/agent/loop.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"loop.d.ts","sourceRoot":"","sources":["../../src/agent/loop.ts"],"names":[],"mappings":"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"}

package/dist/agent/loop.js

@@ -33,7 +33,8 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VERIFY_CMD_RE = exports.WRITE_TOOL_NAMES = exports.ToolNotAllowedError = void 0;
+exports.VERIFY_CMD_RE = exports.WRITE_TOOL_NAMES = exports.ToolNotAllowedError = exports._stallLimits = void 0;
+exports.errorRoundSignature = errorRoundSignature;
 exports.resolveMaxIterations = resolveMaxIterations;
 exports.createLimiter = createLimiter;
 exports.extractSubTaskText = extractSubTaskText;
@@ -189,6 +190,30 @@ const DEFAULT_MAX_ITERATIONS = 500;
 const MAX_ITERATIONS_CEILING = 2000; // default auto-continue backstop (no explicit opt-in)
 const HARD_ITERATIONS_CAP = 100000; // absolute safety cap — even explicit opt-in can't exceed this
 const STALL_LIMIT = 8; // consecutive all-failed tool rounds → give up (runaway guard)
+// Consecutive rounds producing the IDENTICAL error(s) → give up, even if other calls in
+// those rounds succeeded. Higher than STALL_LIMIT because a repeat is weaker evidence of
+// being stuck than a total failure: legitimately retrying one failing command a few times
+// while making progress elsewhere is normal, twelve times is not.
+const REPEAT_STALL_LIMIT = 12;
+/**
+ * Fingerprint one round's tool failures, for the repeated-failure runaway guard.
+ *
+ * Exported (with the limits) purely as a test seam: the guard's whole value is in the
+ * edge cases — that a DIFFERENT error each round must NOT trip it, that call order
+ * within a round is irrelevant, that a long error body doesn't make every occurrence
+ * look unique — and none of that is reachable without driving a live model loop.
+ *
+ * Sorted so parallel tool calls completing in a different order still compare equal;
+ * truncated because errors often embed a varying path or timestamp late in the string.
+ */
+function errorRoundSignature(errored) {
+    return errored
+        .map(({ name, error }) => `${name}:${String(error).slice(0, 200)}`)
+        .sort()
+        .join('|');
+}
+/** Runaway-guard limits, exposed for tests. */
+exports._stallLimits = { STALL_LIMIT, REPEAT_STALL_LIMIT };
 // Resolve the soft iteration budget. Precedence:
 //   options.maxIterations  →  env NEXRALL_MAX_ITERATIONS  →  settings.maxIterations  →  default
 //
@@ -830,6 +855,26 @@ function compactionThresholds() {
 // so we require at least this many bytes reclaimed before accepting a prune.
 const PRUNE_MIN_RECLAIM_BYTES = 256 * 1024; // 256 KB
 const COMPACT_KEEP_MIN = 6; // always keep at least the last N messages verbatim
+/**
+ * Bytes a compaction must reclaim to count as productive.
+ *
+ * Deliberately much smaller than PRUNE_MIN_RECLAIM_BYTES: a prune declines when the
+ * gain isn't worth busting the prompt cache, whereas by the time we are summarising
+ * we are already committed to rewriting the prefix — the only question is whether the
+ * summariser is making ANY headway. 32 KB is small enough that a genuinely useful
+ * compaction always clears it, large enough that shuffling a few bytes doesn't.
+ */
+const COMPACT_MIN_RECLAIM_BYTES = 32 * 1024; // 32 KB
+/**
+ * Consecutive non-productive compaction attempts before auto-compaction is switched
+ * off for the rest of the run.
+ *
+ * 3 rather than 1 because the failure is often transient — a summariser stream that
+ * blipped will usually succeed on the next turn, and giving up instantly would lose
+ * the safety net for a whole long session over one network hiccup. 3 also bounds the
+ * wasted spend: at most three summariser calls, not hundreds.
+ */
+const COMPACT_MAX_FAILURES = 3;
 // Byte-level safety net, independent of the token estimate.
 //
 // Tool-heavy sessions on large codebases accumulate many tool_result blocks
@@ -1013,7 +1058,7 @@ function transcriptOf(messages) {
 const LEDGER_MAX_FILES = 60; // cap the file list so the preamble can't balloon
 const LEDGER_MAX_NOTES = 20; // cap verification/among notes
 function createLedger() {
-    return { filesTouched: new Map(), verifications: [], testIntegrity: [], epoch: 0 };
+    return { filesTouched: new Map(), filesTouchedTotal: 0, verifications: [], testIntegrity: [], testIntegrityTotal: 0, epoch: 0 };
 }
 /** Record one tool call's effect on the ledger (deterministic, no model call). */
 function ledgerRecord(ledger, toolName, input, ok, output, exitCode) {
@@ -1026,7 +1071,32 @@ function ledgerRecord(ledger, toolName, input, ok, output, exitCode) {
         const p = typeof input?.path === 'string' ? input.path : undefined;
         if (p) {
             const prev = ledger.filesTouched.get(p);
+            if (!prev)
+                ledger.filesTouchedTotal++;
+            // DELETE before SET, so a re-touched path moves to the BACK of the insertion
+            // order. `Map.set` on an existing key keeps its ORIGINAL slot, which quietly
+            // broke the eviction policy below: a file edited hundreds of times over a long
+            // session kept the position of its FIRST edit, so it aged out like a file nobody
+            // had looked at since — and on the next edit it was re-inserted as "new", double-
+            // counting filesTouchedTotal (which is documented as DISTINCT paths). Making the
+            // Map a true LRU-by-touch is what lets the `key !== p` guard below mean anything.
+            ledger.filesTouched.delete(p);
             ledger.filesTouched.set(p, { tool: toolName, edits: (prev?.edits ?? 0) + 1 });
+            // Bound the Map itself, not just its rendering. LEDGER_MAX_FILES caps how many
+            // paths the preamble PRINTS (see ledgerSummary's slice), but the Map was only ever
+            // written to — so a multi-hour run touching thousands of files grew it without
+            // limit, and it is deliberately retained across every compaction. Evict the
+            // least-recently-touched entries once we hold well beyond what can ever be
+            // displayed. Hysteresis (evict down to 2× only once we exceed 4×) keeps this an
+            // occasional bulk sweep instead of a delete on every single write.
+            if (ledger.filesTouched.size > LEDGER_MAX_FILES * 4) {
+                for (const key of ledger.filesTouched.keys()) {
+                    if (ledger.filesTouched.size <= LEDGER_MAX_FILES * 2)
+                        break;
+                    if (key !== p)
+                        ledger.filesTouched.delete(key);
+                }
+            }
         }
         // Reward-hacking guard: if this write WEAKENED a test file, record it so the
         // signal survives compaction and can be surfaced before the agent finishes.
@@ -1046,6 +1116,7 @@ function ledgerRecord(ledger, toolName, input, ok, output, exitCode) {
         if (reasons.length && p) {
             for (const reason of reasons) {
                 ledger.testIntegrity.push({ path: p, reason });
+                ledger.testIntegrityTotal++;
             }
             if (ledger.testIntegrity.length > LEDGER_MAX_NOTES * 2) {
                 ledger.testIntegrity.splice(0, ledger.testIntegrity.length - LEDGER_MAX_NOTES);
@@ -1078,8 +1149,11 @@ function ledgerSummary(ledger) {
     const lines = [];
     if (ledger.filesTouched.size) {
         const files = [...ledger.filesTouched.entries()];
-        const shown = files.slice(0, LEDGER_MAX_FILES);
-        lines.push(`FILES CHANGED THIS SESSION (${ledger.filesTouched.size}):`);
+        // The TAIL, not the head: the Map is ordered least-recently-touched first, so
+        // slicing from the front showed the OLDEST files and reliably omitted the ones the
+        // agent was working on right now — the opposite of what this preamble is for.
+        const shown = files.slice(-LEDGER_MAX_FILES);
+        lines.push(`FILES CHANGED THIS SESSION (${ledger.filesTouchedTotal || ledger.filesTouched.size}):`);
         for (const [p, meta] of shown) {
             lines.push(`  • ${p}  (${meta.tool}${meta.edits > 1 ? ` ×${meta.edits}` : ''})`);
         }
@@ -1472,6 +1546,12 @@ async function runAgentLoop(initialMessages, options) {
     let completedRounds = 0;
     let stalledOut = false; // tripped the runaway guard (all-failed rounds)
     let consecutiveErrorRounds = 0; // rounds where every tool call errored
+    // Repeated-identical-failure guard: see the runaway guards below. Tracked
+    // separately from consecutiveErrorRounds because a round can contain a succeeding
+    // call and still be part of a livelock.
+    let repeatedErrorRounds = 0;
+    let lastErrorSignature = '';
+    let stalledRepeatError = null;
     let budget = maxIterations; // extended by auto-continue, capped at hardCap
     let iteration = 0;
     // ─── Verification nudge (GAP D) ───────────────────────────────────────────────
@@ -1498,6 +1578,31 @@ async function runAgentLoop(initialMessages, options) {
     let claimEvidenceNudged = false;
     // GAP E — deterministic progress ledger, preserved verbatim across compactions.
     const ledger = createLedger();
+    // ─── Auto-compact circuit breaker ─────────────────────────────────────────────
+    //
+    // The in-loop compaction trigger below re-derives its pressure from the CURRENT
+    // body on every iteration. That is correct, but it means a compaction which does
+    // not shrink anything leaves the trigger condition still true — so the next
+    // iteration pays for another summariser call over the same (up to ~600KB)
+    // transcript, and so on for the rest of the run. Two ways that happens:
+    //
+    //   • autoCompactMessages returns false (summariser stream threw, or came back
+    //     empty). Nothing was replaced, so the pressure is unchanged.
+    //   • It returns true but cannot get under MAX_BODY_BYTES, because the messages
+    //     it must retain (COMPACT_KEEP_MIN) are themselves huge. `lastPromptTokens = 0`
+    //     suppresses only the TOKEN trigger; the BYTE trigger fires again immediately.
+    //
+    // Both are invisible to the user (the success notice only prints when `did`), so
+    // the symptom is a long run that silently gets slower and more expensive. Count
+    // consecutive non-productive attempts and stop trying after a few — losing
+    // compaction degrades gracefully (the turn may still fit, and the prune pass
+    // still runs), whereas an unbounded retry loop does not.
+    //
+    // The resume-time compactor already had exactly these guards
+    // (compactMessagesForResume: a bounded loop plus `if (!did) break`); this brings
+    // the in-loop path in line with it.
+    let compactFailures = 0;
+    let compactDisabled = false;
     try {
         for (; iteration < budget; iteration++) {
             if (options.abortSignal?.aborted)
@@ -1546,10 +1651,17 @@ async function runAgentLoop(initialMessages, options) {
                     (options.onNotice ?? options.onText)(`\u267b\ufe0f Trimmed ~${(reclaimed / (1024 * 1024)).toFixed(1)}MB of already-processed tool output to keep this chat cheap to continue.`);
                 }
             }
-            if (autoCompact && !compacting && (tokenPressure || bytePressure) && messages.length > COMPACT_KEEP_MIN + 2) {
+            if (autoCompact && !compactDisabled && !compacting && (tokenPressure || bytePressure) && messages.length > COMPACT_KEEP_MIN + 2) {
                 compacting = true;
                 try {
+                    // Measured BEFORE, so "did it actually help?" is a fact about bytes rather
+                    // than a claim from the compactor. A compaction that returns true but
+                    // reclaims nothing is a failure for our purposes — it leaves the trigger
+                    // armed for the next iteration, which is precisely the runaway.
+                    const bytesBefore = estimateBodyBytes(messages);
                     const did = await autoCompactMessages(messages, options, ledger);
+                    const bytesAfter = did ? estimateBodyBytes(messages) : bytesBefore;
+                    const reclaimed = bytesBefore - bytesAfter;
                     if (did) {
                         lastPromptTokens = 0; // stale — next usage event refreshes it
                         const reason = bytePressure
@@ -1558,6 +1670,24 @@ async function runAgentLoop(initialMessages, options) {
                         // Same reasoning as above: this is a system notice about housekeeping,
                         // not part of the model's answer — keep it out of the text bubble.
                         (options.onNotice ?? options.onText)(`\u267b\ufe0f Auto-compacted earlier conversation to stay within the ${reason}.`);
+                        // Refresh local pressure so the rest of THIS iteration sees the new size.
+                        bodyBytes = bytesAfter;
+                        bytePressure = bodyBytes > MAX_BODY_BYTES;
+                    }
+                    // Productive == it shrank the body meaningfully. A successful-but-useless
+                    // compaction counts as a failure, otherwise the "cannot get under the byte
+                    // cap" case would never trip the breaker.
+                    if (did && reclaimed >= COMPACT_MIN_RECLAIM_BYTES) {
+                        compactFailures = 0;
+                    }
+                    else if (++compactFailures >= COMPACT_MAX_FAILURES) {
+                        compactDisabled = true;
+                        // Surfaced ONCE. The user needs to know the automatic safety net is off
+                        // (so a context-window error later isn't a total surprise) and what to do
+                        // about it, but repeating this every iteration would be its own spam.
+                        (options.onNotice ?? options.onText)(`\u26a0\ufe0f Auto-compaction isn't reducing this conversation any further, so it's been switched off ` +
+                            `for the rest of this run to avoid repeated summarising. If the context fills up, start a fresh ` +
+                            `chat or run /compact manually.`);
                     }
                 }
                 finally {
@@ -1772,9 +1902,19 @@ async function runAgentLoop(initialMessages, options) {
                 // and require the agent to either justify each change (legit refactor) or
                 // revert it and fix the real code. Deterministic — the signal comes from
                 // diff structure, not model self-report, so it can't be gamed away.
-                if (ledger.testIntegrity.length > testIntegrityNudgedCount) {
-                    const fresh = ledger.testIntegrity.slice(testIntegrityNudgedCount);
-                    testIntegrityNudgedCount = ledger.testIntegrity.length;
+                //
+                // Compared against testIntegrityTotal, NOT testIntegrity.length: the array is a
+                // bounded window that gets trimmed, so once a long session passed ~40 findings
+                // its length stopped growing and could even fall BELOW the already-nudged count,
+                // permanently wedging this condition false and disabling the guard for the rest
+                // of the run. The total only ever increases.
+                if (ledger.testIntegrityTotal > testIntegrityNudgedCount) {
+                    // How many are genuinely new, clamped to what the window still holds — the
+                    // trimmed-away ones are unrecoverable, and reporting the tail we DO have is
+                    // strictly better than reporting nothing.
+                    const newCount = Math.min(ledger.testIntegrityTotal - testIntegrityNudgedCount, ledger.testIntegrity.length);
+                    const fresh = ledger.testIntegrity.slice(ledger.testIntegrity.length - newCount);
+                    testIntegrityNudgedCount = ledger.testIntegrityTotal;
                     const bullet = fresh.map((t) => `  • ${t.path}: ${t.reason}`).join('\n');
                     messages.push({
                         role: 'user',
@@ -2073,16 +2213,46 @@ async function runAgentLoop(initialMessages, options) {
             // tool_result user turn). Let the caller checkpoint progress so a crash
             // mid-run loses only the in-flight step, not the whole session.
             options.onProgress?.(messages);
-            // Runaway guard: if every tool call in this round failed, count it. Enough
-            // consecutive all-failed rounds (e.g. a command that always errors, or the
-            // user denying every permission) means we're stuck — stop instead of
-            // burning the whole budget spinning.
-            const allErrored = toolResults.length > 0 && toolResults.every(({ result }) => result.error !== undefined);
+            // ── Runaway guards ────────────────────────────────────────────────────────
+            //
+            // TWO independent counters, because "stuck" has two shapes and the original
+            // all-failed test only caught the first.
+            //
+            //   1. TOTAL failure: every call in the round errored (a command that always
+            //      errors, the user denying every permission). Unambiguous.
+            //
+            //   2. REPEATED failure: the SAME error keeps coming back, round after round,
+            //      even though other calls in those rounds succeed. This is the livelock the
+            //      `.every()` test missed entirely — one trivially-succeeding sibling (say a
+            //      `read_file` alongside an `edit_file` that fails identically every time)
+            //      reset the counter to 0 forever, so a genuine loop burned the full
+            //      2000-iteration ceiling instead of stopping at 8. That is the expensive,
+            //      user-visible "it just spun for an hour" failure.
+            //
+            // Keyed on tool + error text so a DIFFERENT error each round (real progress
+            // through a chain of distinct problems) does not trip it.
+            const errored = toolResults.filter(({ result }) => result.error !== undefined);
+            const allErrored = toolResults.length > 0 && errored.length === toolResults.length;
             consecutiveErrorRounds = allErrored ? consecutiveErrorRounds + 1 : 0;
             if (consecutiveErrorRounds >= STALL_LIMIT) {
                 stalledOut = true;
                 break;
             }
+            // Signature of this round's failures, order-independent and truncated so a long
+            // error body (or a path echoed inside it) doesn't make every occurrence unique.
+            const errSignature = errorRoundSignature(errored.map(({ block, result }) => ({ name: block.name, error: String(result.error) })));
+            if (errSignature && errSignature === lastErrorSignature) {
+                repeatedErrorRounds++;
+            }
+            else {
+                repeatedErrorRounds = 0;
+                lastErrorSignature = errSignature;
+            }
+            if (repeatedErrorRounds >= REPEAT_STALL_LIMIT) {
+                stalledOut = true;
+                stalledRepeatError = errored[0] ? String(errored[0].result.error).slice(0, 300) : null;
+                break;
+            }
             // Auto-continue: about to exhaust the current budget but the model is still
             // calling tools (task unfinished) and we're under the ceiling → extend the
             // budget by another segment and keep going, so the agent finishes on its own
@@ -2098,12 +2268,19 @@ async function runAgentLoop(initialMessages, options) {
         // long run never just goes silent. History ends on a tool_result turn, so
         // "continue" resumes exactly where it left off.
         if (!options.abortSignal?.aborted && !completedCleanly) {
+            // Routed through onNotice (falling back to onText) like every other housekeeping
+            // message in this file — these are statements from the harness, not from the model,
+            // and splicing them into the assistant's own bubble reads as if it said them.
             if (stalledOut) {
-                options.onText(`\n🛑 Stopped: the last ${STALL_LIMIT} tool rounds all failed, so the agent looked stuck. ` +
-                    `Fix the underlying error (or grant the needed permission) and send "continue".\n`);
+                (options.onNotice ?? options.onText)(stalledRepeatError
+                    ? `\n🛑 Stopped: the same tool error repeated ${REPEAT_STALL_LIMIT} rounds in a row, so the agent ` +
+                        `was looping without making progress. The recurring error was:\n${stalledRepeatError}\n` +
+                        `Fix that underlying cause (or grant the needed permission) and send "continue".\n`
+                    : `\n🛑 Stopped: the last ${STALL_LIMIT} tool rounds all failed, so the agent looked stuck. ` +
+                        `Fix the underlying error (or grant the needed permission) and send "continue".\n`);
             }
             else if (iteration >= budget) {
-                options.onText(`\n⏸️ Stopped at the ${budget}-step safety limit — the task may be incomplete. ` +
+                (options.onNotice ?? options.onText)(`\n⏸️ Stopped at the ${budget}-step safety limit — the task may be incomplete. ` +
                     `Send "continue" to resume, or raise the limit via "maxIterations" in .nexrall/settings.json ` +
                     `(or the NEXRALL_MAX_ITERATIONS env var). Auto-continue can be disabled with "autoContinue": false.\n`);
             }

package/dist/api/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/api/client.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,EAA8B,UAAU,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAiErH,eAAO,MAAM,QAAQ,QAAmB,CAAC;AAIzC;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,EAC5D,OAAO,EAAE,CAAC,EAAE,EACZ,UAAU,EAAE,KAAK,CAAC;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,IAAI,GAAG,SAAS,GACtD,CAAC,EAAE,CAeL;AAiGD,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,UAAU,CAAC;IACjB,aAAa,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;IACnC,oFAAoF;IACpF,UAAU,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC,CAAC;IACjG,6EAA6E;IAC7E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,6IAA6I;IAC7I,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;;;;;;;;;;OAeG;IACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC;AAiDD,wBAAsB,UAAU,CAC9B,QAAQ,EAAE,OAAO,EAAE,EACnB,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,CAAC,CAAC,EAAE,QAAQ,KAAK,IAAI,GAC7B,OAAO,CAAC,OAAO,CAAC,CA6jClB;AAID;;;;;;;;;;;GAWG;AACH,wBAAsB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAU9D;AAID;;;;;;;;;;GAUG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAYxD;AAID,wBAAsB,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC,CA0BlD;AAID,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CA+B1E;AAID,wBAAsB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CA0BhF"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/api/client.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,EAA8B,UAAU,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAiErH,eAAO,MAAM,QAAQ,QAAmB,CAAC;AAIzC;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,EAC5D,OAAO,EAAE,CAAC,EAAE,EACZ,UAAU,EAAE,KAAK,CAAC;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,IAAI,GAAG,SAAS,GACtD,CAAC,EAAE,CAeL;AAiGD,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,UAAU,CAAC;IACjB,aAAa,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;IACnC,oFAAoF;IACpF,UAAU,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC,CAAC;IACjG,6EAA6E;IAC7E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,6IAA6I;IAC7I,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;;;;;;;;;;OAeG;IACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC;AAiDD,wBAAsB,UAAU,CAC9B,QAAQ,EAAE,OAAO,EAAE,EACnB,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,CAAC,CAAC,EAAE,QAAQ,KAAK,IAAI,GAC7B,OAAO,CAAC,OAAO,CAAC,CAwlClB;AAID;;;;;;;;;;;GAWG;AACH,wBAAsB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAU9D;AAID;;;;;;;;;;GAUG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAYxD;AAID,wBAAsB,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC,CA0BlD;AAID,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CA+B1E;AAID,wBAAsB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CA0BhF"}