charness 0.0.0-stage → 3.0.0

package/dist/shutdown.js

@@ -0,0 +1,164 @@
+"use strict";
+/**
+ * @description Ordered, deterministic graceful-shutdown sequence shared by
+ * every signal-driven exit path (`SIGINT`, `SIGTERM`) of the bot.
+ *
+ * **Why a dedicated module:**
+ *
+ *   - **Single owner of exit ordering.** The previous code had two SIGTERM
+ *     handlers: `installLockCleanupHandlers()` (in `instanceLock.ts`) was
+ *     registered first and called `releaseLock(); process.exit(0)` *synchronously*,
+ *     pre-empting the bot's own async `state.flush()`. Frequent reloads
+ *     under nodemon could therefore lose the last <500ms of state (one
+ *     debounce window). The fix is to remove the lock module's signal
+ *     handlers entirely and route every signal through this orchestrator,
+ *     which awaits the flush before releasing the lock.
+ *
+ *   - **Bounded by a watchdog.** If `state.flush()` hangs (disk full,
+ *     network FS that lost its mount), the sequence still terminates
+ *     within {@link DEFAULT_WATCHDOG_MS} so the next nodemon respawn can
+ *     reclaim the lock instead of waiting forever.
+ *
+ *   - **Testable.** Dependencies are injected, so a unit test can assert
+ *     ordering (`state.flush()` resolves before `releaseLock()`) and
+ *     watchdog behaviour without spinning up Telegram or the lockfile.
+ *
+ * **What it deliberately does NOT do:** stop tmux sessions or kill the
+ * OpenCode HTTP server. Both run in external process groups and survive
+ * the bot process by design — the reattach path on the next boot picks
+ * them up. Killing them here would defeat the whole "hot reload keeps
+ * agents alive" property the surrounding plan rests on.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_WATCHDOG_MS = void 0;
+exports.gracefulShutdown = gracefulShutdown;
+/**
+ * @description Upper bound (ms) on the whole graceful-shutdown sequence — the
+ * watchdog forces `releaseLock(); exit(0)` when it elapses first. Raised from
+ * 3s when the sequence gained the bounded (≤~7s) output flush. Exported because
+ * the lock module's same-token handoff wait must OUT-WAIT this window (the
+ * incoming nodemon respawn polls the lock while the predecessor finishes
+ * shutting down); an undersized wait aborts the new process and leaves the bot
+ * down until the next file change.
+ */
+exports.DEFAULT_WATCHDOG_MS = 10000;
+/**
+ * @description Run the ordered shutdown sequence:
+ *
+ *   1. `cleanupTimers()` — drop any background `setInterval`s so they
+ *      don't fire mid-shutdown and re-dirty state.
+ *   1a. `await finalizePendingOutput()` — flush the not-yet-delivered agent
+ *      output (coalesce buffers / DM drafts → send FIFOs) while the Telegram
+ *      client is still up, so a restart can't swallow it. Self-bounded.
+ *   1b. `await clearTransientFrames()` — best-effort delete of the
+ *      "✽ working…" / thinking / sub-agent status frames still on screen,
+ *      while the Telegram client is still up. Self-bounded so it can't
+ *      starve the flush.
+ *   2. `bot.stop(signal)` — Telegraf stops long-polling. Synchronous in
+ *      Telegraf 4.x, so safe to call before the flush.
+ *   2b. `await drainPendingUpdates()` — drain the off-loop update queues so
+ *      updates enqueued during a hot-reload still route to their live agent.
+ *      Self-bounded, so it can't starve the flush's watchdog budget.
+ *   3. `await state.flush()` — atomic-write any pending state changes.
+ *      THIS is the step the old `releaseLock(); process.exit(0)` raced;
+ *      we wait for the on-disk rename to land here.
+ *   4. `releaseLock()` — drop the lockfile so the incoming nodemon
+ *      respawn can claim it. Idempotent and owner-checked, so the
+ *      `process.on('exit')` safety net in `lock.ts` finding nothing to do
+ *      is fine.
+ *   5. `exit(0)` — let Node tear the rest down.
+ *
+ * The watchdog races the whole sequence (steps 2-4): if it fires first,
+ * we still call `releaseLock(); exit(0)` so the operator's terminal
+ * unblocks and nodemon's next iteration finds a free lock.
+ */
+async function gracefulShutdown(deps) {
+    const watchdogMs = deps.watchdogMs ?? exports.DEFAULT_WATCHDOG_MS;
+    const log = deps.log ?? ((m) => console.log(m));
+    log(`\n${deps.signal} received, shutting down...`);
+    let alreadyExited = false;
+    const finishExit = (code) => {
+        if (alreadyExited)
+            return;
+        alreadyExited = true;
+        try {
+            deps.releaseLock();
+        }
+        catch (e) {
+            console.error('[shutdown] releaseLock failed:', e);
+        }
+        deps.exit(code);
+    };
+    // Race the shutdown sequence against the watchdog. We MUST `Promise.race`
+    // (not just `await` the sequence with a separate watchdog timer that
+    // calls `exit`): if the sequence's `await state.flush()` hangs, the
+    // outer function would otherwise never resolve and any caller awaiting
+    // `gracefulShutdown(...)` (the bot's signal handler, our tests) would
+    // hang along with it. The race lets the watchdog branch return control
+    // immediately while the hung flush stays pending in the background —
+    // harmless once we've called `exit(code)`.
+    const sequence = (async () => {
+        if (deps.cleanupTimers) {
+            try {
+                deps.cleanupTimers();
+            }
+            catch (e) {
+                console.error('[shutdown] cleanupTimers failed:', e);
+            }
+        }
+        if (deps.finalizePendingOutput) {
+            try {
+                await deps.finalizePendingOutput();
+            }
+            catch (e) {
+                console.error('[shutdown] finalizePendingOutput failed:', e);
+            }
+        }
+        if (deps.clearTransientFrames) {
+            try {
+                await deps.clearTransientFrames();
+            }
+            catch (e) {
+                console.error('[shutdown] clearTransientFrames failed:', e);
+            }
+        }
+        try {
+            deps.bot.stop(deps.signal);
+        }
+        catch (e) {
+            console.error('[shutdown] bot.stop failed:', e);
+        }
+        if (deps.drainPendingUpdates) {
+            try {
+                await deps.drainPendingUpdates();
+            }
+            catch (e) {
+                console.error('[shutdown] drainPendingUpdates failed:', e);
+            }
+        }
+        try {
+            await deps.state.flush();
+        }
+        catch (e) {
+            console.error('[shutdown] state.flush failed:', e);
+        }
+        return 'sequence';
+    })();
+    let watchdogHandle;
+    const watchdogPromise = new Promise((resolve) => {
+        watchdogHandle = setTimeout(() => resolve('watchdog'), watchdogMs);
+        // Don't let the watchdog keep the event loop alive on its own — once
+        // the sequence resolves first and we clear the timer below, this just
+        // avoids edge-case timer leaks in long-running test suites.
+        watchdogHandle.unref?.();
+    });
+    const winner = await Promise.race([sequence, watchdogPromise]);
+    if (watchdogHandle)
+        clearTimeout(watchdogHandle);
+    if (winner === 'watchdog') {
+        log(`[shutdown] watchdog fired after ${watchdogMs}ms — forcing exit ` +
+            `(state.flush() did not resolve in time)`);
+    }
+    finishExit(0);
+}
+//# sourceMappingURL=shutdown.js.map

package/dist/shutdown.js.map

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

package/dist/startupPromptBuffer.d.ts

@@ -0,0 +1,85 @@
+/**
+ * @name BufferedPromptOutcome
+ * @description How a buffered prompt's wait ended. `replayed`: it was handed to the
+ * session — a forward that threw is logged and not retried, so it counts, since
+ * nobody re-delivers it. `dropped`: it can never reach a session (the start failed,
+ * or the session is not active once the window closes).
+ */
+export type BufferedPromptOutcome = 'replayed' | 'dropped';
+/** Called once, when a buffered prompt's wait ends. */
+export type BufferedPromptSettled = (outcome: BufferedPromptOutcome) => void;
+/** What {@link StartupPromptBuffer.replayPrompts} replays through. */
+export interface ReplayPromptsOptions {
+    /** Whether the session is up now; `false` drops every buffered prompt. */
+    isSessionActive: boolean;
+    /** Hand one prompt to the live session. */
+    forward: (text: string) => Promise<void>;
+}
+/**
+ * @description FIFO buffer for prompts typed while an agent session is still
+ * starting up.
+ *
+ * Both backends have a startup window where the session is not yet ready to
+ * receive input: Claude boots a tmux pane + `node-pty`, OpenCode boots the
+ * local server and `POST /session`. A message typed during that window used to
+ * be dropped — the bot saw `checkIsActive === false`, routed the text to the
+ * "no agent running" guidance, and the user had to retype once the session was
+ * up. This buffer captures those prompts and replays them, in arrival order,
+ * the moment the session becomes active.
+ *
+ * The buffer lives in memory: a bot restart mid-start loses what it holds. A
+ * prompt whose sender must not lose it that way (the API-error retry's nudge — its
+ * saved record fires it again after a restart) passes `onSettled` and is told when
+ * its wait ends, one way or the other. Every way out of the window settles its
+ * prompts, so no caller can close the window and leave one waiting.
+ *
+ * Adapter-agnostic on purpose: the startup race is identical for Claude and
+ * OpenCode, so the fix lives in the bot layer instead of being duplicated in
+ * each adapter. Keyed by `keyToString(SessionKey)`.
+ */
+export declare class StartupPromptBuffer {
+    private startingThreads;
+    private bufferedPrompts;
+    /** Threads that already received the "queued while starting" ack, so we
+     *  ack once per startup window rather than on every buffered prompt. */
+    private ackedThreads;
+    /** Mark a thread as mid-startup; inbound text should now be buffered. */
+    markStarting(threadId: string): void;
+    /** Whether a thread's session is currently starting. */
+    checkIsStarting(threadId: string): boolean;
+    /** Whether the thread holds prompts that wait for a session. */
+    checkHasPrompts(threadId: string): boolean;
+    /**
+     * End the window WITHOUT settling what it holds: the prompts stay for the
+     * next window — the idle stop opens one so a prompt arriving while the process
+     * stops is kept, and the resume that follows opens its own and replays them.
+     */
+    closeWindow(threadId: string): void;
+    /**
+     * Buffer one prompt for a starting thread.
+     * @param onSettled Told once how the prompt's wait ended ({@link BufferedPromptOutcome}).
+     * @returns `true` if this is the first buffered prompt for the current
+     * startup window (the caller uses it to send the ack only once).
+     */
+    addPrompt(threadId: string, text: string, onSettled?: BufferedPromptSettled): boolean;
+    /**
+     * End the startup window and hand the buffered prompts, in FIFO order, to the
+     * session. Call on a successful start. The window closes and the buffer empties
+     * BEFORE the first await, so a caller that does not await it still leaves no
+     * prompt able to slip into a second buffer.
+     *
+     * With no active session nothing is forwarded and every prompt is `dropped`;
+     * otherwise each is forwarded in turn (one that throws is logged, the rest still
+     * go) and settles as `replayed` after its own forward.
+     */
+    replayPrompts(threadId: string, options: ReplayPromptsOptions): Promise<void>;
+    /**
+     * End the startup window and discard the buffer without replaying, settling
+     * every prompt as `dropped`. Call when the start fails — the prompts would have
+     * nowhere to go.
+     */
+    discardPrompts(threadId: string): void;
+    /** Close the window and take what it held, clearing all per-thread state. */
+    private takePrompts;
+}
+//# sourceMappingURL=startupPromptBuffer.d.ts.map

package/dist/startupPromptBuffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"startupPromptBuffer.d.ts","sourceRoot":"","sources":["../src/startupPromptBuffer.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,MAAM,qBAAqB,GAAG,UAAU,GAAG,SAAS,CAAC;AAE3D,uDAAuD;AACvD,MAAM,MAAM,qBAAqB,GAAG,CAAC,OAAO,EAAE,qBAAqB,KAAK,IAAI,CAAC;AAO7E,sEAAsE;AACtE,MAAM,WAAW,oBAAoB;IACnC,0EAA0E;IAC1E,eAAe,EAAE,OAAO,CAAC;IACzB,2CAA2C;IAC3C,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1C;AAWD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,eAAe,CAAqB;IAC5C,OAAO,CAAC,eAAe,CAAuC;IAC9D;4EACwE;IACxE,OAAO,CAAC,YAAY,CAAqB;IAEzC,yEAAyE;IACzE,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAIpC,wDAAwD;IACxD,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAI1C,gEAAgE;IAChE,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAI1C;;;;OAIG;IACH,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAKnC;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,qBAAqB,GAAG,OAAO;IAUrF;;;;;;;;;OASG;IACG,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBnF;;;;OAIG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAItC,6EAA6E;IAC7E,OAAO,CAAC,WAAW;CAOpB"}

package/dist/startupPromptBuffer.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StartupPromptBuffer = void 0;
+/** A callback that throws must not break the replay or the failed-start path that called it. */
+function settleBufferedPrompt(prompt, outcome) {
+    try {
+        prompt.onSettled?.(outcome);
+    }
+    catch (err) {
+        console.error('[startupPromptBuffer] a settle callback threw:', err);
+    }
+}
+/**
+ * @description FIFO buffer for prompts typed while an agent session is still
+ * starting up.
+ *
+ * Both backends have a startup window where the session is not yet ready to
+ * receive input: Claude boots a tmux pane + `node-pty`, OpenCode boots the
+ * local server and `POST /session`. A message typed during that window used to
+ * be dropped — the bot saw `checkIsActive === false`, routed the text to the
+ * "no agent running" guidance, and the user had to retype once the session was
+ * up. This buffer captures those prompts and replays them, in arrival order,
+ * the moment the session becomes active.
+ *
+ * The buffer lives in memory: a bot restart mid-start loses what it holds. A
+ * prompt whose sender must not lose it that way (the API-error retry's nudge — its
+ * saved record fires it again after a restart) passes `onSettled` and is told when
+ * its wait ends, one way or the other. Every way out of the window settles its
+ * prompts, so no caller can close the window and leave one waiting.
+ *
+ * Adapter-agnostic on purpose: the startup race is identical for Claude and
+ * OpenCode, so the fix lives in the bot layer instead of being duplicated in
+ * each adapter. Keyed by `keyToString(SessionKey)`.
+ */
+class StartupPromptBuffer {
+    startingThreads = new Set();
+    bufferedPrompts = new Map();
+    /** Threads that already received the "queued while starting" ack, so we
+     *  ack once per startup window rather than on every buffered prompt. */
+    ackedThreads = new Set();
+    /** Mark a thread as mid-startup; inbound text should now be buffered. */
+    markStarting(threadId) {
+        this.startingThreads.add(threadId);
+    }
+    /** Whether a thread's session is currently starting. */
+    checkIsStarting(threadId) {
+        return this.startingThreads.has(threadId);
+    }
+    /** Whether the thread holds prompts that wait for a session. */
+    checkHasPrompts(threadId) {
+        return (this.bufferedPrompts.get(threadId)?.length ?? 0) > 0;
+    }
+    /**
+     * End the window WITHOUT settling what it holds: the prompts stay for the
+     * next window — the idle stop opens one so a prompt arriving while the process
+     * stops is kept, and the resume that follows opens its own and replays them.
+     */
+    closeWindow(threadId) {
+        this.startingThreads.delete(threadId);
+        this.ackedThreads.delete(threadId);
+    }
+    /**
+     * Buffer one prompt for a starting thread.
+     * @param onSettled Told once how the prompt's wait ended ({@link BufferedPromptOutcome}).
+     * @returns `true` if this is the first buffered prompt for the current
+     * startup window (the caller uses it to send the ack only once).
+     */
+    addPrompt(threadId, text, onSettled) {
+        const prompts = this.bufferedPrompts.get(threadId) ?? [];
+        prompts.push({ text, onSettled });
+        this.bufferedPrompts.set(threadId, prompts);
+        const isFirstForWindow = !this.ackedThreads.has(threadId);
+        this.ackedThreads.add(threadId);
+        return isFirstForWindow;
+    }
+    /**
+     * End the startup window and hand the buffered prompts, in FIFO order, to the
+     * session. Call on a successful start. The window closes and the buffer empties
+     * BEFORE the first await, so a caller that does not await it still leaves no
+     * prompt able to slip into a second buffer.
+     *
+     * With no active session nothing is forwarded and every prompt is `dropped`;
+     * otherwise each is forwarded in turn (one that throws is logged, the rest still
+     * go) and settles as `replayed` after its own forward.
+     */
+    async replayPrompts(threadId, options) {
+        const prompts = this.takePrompts(threadId);
+        if (!options.isSessionActive) {
+            for (const prompt of prompts)
+                settleBufferedPrompt(prompt, 'dropped');
+            return;
+        }
+        // Sequential await keeps the forwards in arrival order even when each one awaits its own loader send first.
+        for (const prompt of prompts) {
+            try {
+                await options.forward(prompt.text);
+            }
+            catch (err) {
+                console.error('[replayBufferedPrompts] forward failed:', err);
+            }
+            settleBufferedPrompt(prompt, 'replayed');
+        }
+    }
+    /**
+     * End the startup window and discard the buffer without replaying, settling
+     * every prompt as `dropped`. Call when the start fails — the prompts would have
+     * nowhere to go.
+     */
+    discardPrompts(threadId) {
+        for (const prompt of this.takePrompts(threadId))
+            settleBufferedPrompt(prompt, 'dropped');
+    }
+    /** Close the window and take what it held, clearing all per-thread state. */
+    takePrompts(threadId) {
+        const prompts = this.bufferedPrompts.get(threadId) ?? [];
+        this.startingThreads.delete(threadId);
+        this.bufferedPrompts.delete(threadId);
+        this.ackedThreads.delete(threadId);
+        return prompts;
+    }
+}
+exports.StartupPromptBuffer = StartupPromptBuffer;
+//# sourceMappingURL=startupPromptBuffer.js.map

package/dist/startupPromptBuffer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"startupPromptBuffer.js","sourceRoot":"","sources":["../src/startupPromptBuffer.ts"],"names":[],"mappings":";;;AAyBA,gGAAgG;AAChG,SAAS,oBAAoB,CAAC,MAAsB,EAAE,OAA8B;IAClF,IAAI,CAAC;QACH,MAAM,CAAC,SAAS,EAAE,CAAC,OAAO,CAAC,CAAC;IAC9B,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,OAAO,CAAC,KAAK,CAAC,gDAAgD,EAAE,GAAG,CAAC,CAAC;IACvE,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAa,mBAAmB;IACtB,eAAe,GAAG,IAAI,GAAG,EAAU,CAAC;IACpC,eAAe,GAAG,IAAI,GAAG,EAA4B,CAAC;IAC9D;4EACwE;IAChE,YAAY,GAAG,IAAI,GAAG,EAAU,CAAC;IAEzC,yEAAyE;IACzE,YAAY,CAAC,QAAgB;QAC3B,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IACrC,CAAC;IAED,wDAAwD;IACxD,eAAe,CAAC,QAAgB;QAC9B,OAAO,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAC5C,CAAC;IAED,gEAAgE;IAChE,eAAe,CAAC,QAAgB;QAC9B,OAAO,CAAC,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;IAC/D,CAAC;IAED;;;;OAIG;IACH,WAAW,CAAC,QAAgB;QAC1B,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QACtC,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IACrC,CAAC;IAED;;;;;OAKG;IACH,SAAS,CAAC,QAAgB,EAAE,IAAY,EAAE,SAAiC;QACzE,MAAM,OAAO,GAAG,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;QACzD,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC;QAClC,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;QAE5C,MAAM,gBAAgB,GAAG,CAAC,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAC1D,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAChC,OAAO,gBAAgB,CAAC;IAC1B,CAAC;IAED;;;;;;;;;OASG;IACH,KAAK,CAAC,aAAa,CAAC,QAAgB,EAAE,OAA6B;QACjE,MAAM,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;QAC3C,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE,CAAC;YAC7B,KAAK,MAAM,MAAM,IAAI,OAAO;gBAAE,oBAAoB,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;YACtE,OAAO;QACT,CAAC;QACD,4GAA4G;QAC5G,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;YAC7B,IAAI,CAAC;gBACH,MAAM,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YACrC,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,OAAO,CAAC,KAAK,CAAC,yCAAyC,EAAE,GAAG,CAAC,CAAC;YAChE,CAAC;YACD,oBAAoB,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;QAC3C,CAAC;IACH,CAAC;IAED;;;;OAIG;IACH,cAAc,CAAC,QAAgB;QAC7B,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC;YAAE,oBAAoB,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAC3F,CAAC;IAED,6EAA6E;IACrE,WAAW,CAAC,QAAgB;QAClC,MAAM,OAAO,GAAG,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;QACzD,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QACtC,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QACtC,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QACnC,OAAO,OAAO,CAAC;IACjB,CAAC;CACF;AA5FD,kDA4FC"}