@cursor/july 0.1.1

package/dist/internal/reminder-runner.js

@@ -0,0 +1,582 @@
+/**
+ * Per-session reminder runner: durable wake subscriptions with
+ * prompt XOR run, every/cron/delay/at schedules, and until as
+ * function XOR prompt.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { randomBytes } from "node:crypto";
+import { join } from "node:path";
+import { parseDuration } from "./duration.js";
+import { defaultBusyPolicy, MAX_TIMER_MS, nextCronFireMs, ReminderValidationError, resolveSchedule, } from "./reminder-schedule.js";
+import { ReminderStore, } from "./reminder-store.js";
+import { APP_AUTH } from "./schedule-runner.js";
+import { SessionBusyError } from "./session-engine.js";
+export { ReminderValidationError } from "./reminder-schedule.js";
+export class UnknownReminderError extends Error {
+    constructor(reminderId, availableReminderIds) {
+        super(`Unknown reminder "${reminderId}"`);
+        this.availableReminderIds = availableReminderIds;
+        this.name = "UnknownReminderError";
+    }
+}
+function newReminderId() {
+    return `rem_${randomBytes(8).toString("hex")}`;
+}
+function toInfo(record) {
+    return {
+        id: record.id,
+        purpose: record.purpose,
+        channelId: record.channelId,
+        continuationToken: record.continuationToken,
+        target: record.target,
+        scheduleKind: record.scheduleKind,
+        scheduleValue: record.scheduleValue,
+        prompt: record.prompt,
+        untilPrompt: record.untilPrompt,
+        busyPolicy: record.busyPolicy,
+        status: record.status,
+        disarmReason: record.disarmReason,
+        fireCount: record.fireCount,
+        nextFireAt: new Date(record.nextFireAtMs).toISOString(),
+        createdAt: record.createdAt,
+        updatedAt: record.updatedAt,
+        hasRunHandler: record.hasRunHandler === true,
+        hasUntilFn: record.hasUntilFn === true,
+    };
+}
+function buildFirePrompt(record) {
+    var _a;
+    const recurring = record.scheduleKind === "every" || record.scheduleKind === "cron";
+    const lines = [
+        `[reminder] id=${record.id} purpose=${record.purpose}`,
+        (_a = record.prompt) !== null && _a !== void 0 ? _a : "Reminder fired. Check current state and only act if needed.",
+    ];
+    if (record.untilPrompt !== undefined && record.untilPrompt.trim() !== "") {
+        lines.push("", `Stop condition: ${record.untilPrompt}`);
+        if (recurring) {
+            lines.push(`When the stop condition is met, call reminders_cancel with id=${record.id}.`);
+        }
+        else {
+            lines.push("This is a one-shot reminder (auto-completes after this fire); no cancel needed unless you armed a separate recurring reminder.");
+        }
+    }
+    return lines.join("\n");
+}
+export class ReminderRunner {
+    constructor(engine, logger = () => { }) {
+        this.engine = engine;
+        this.logger = logger;
+        this.handlers = new Map();
+        this.timers = new Map();
+        this.firing = new Set();
+        /** Single-flight idle gates keyed by `channelId:continuationToken`. */
+        this.idleGates = new Map();
+        this.started = false;
+        this.store = new ReminderStore(join(engine.stateRoot, "reminders"));
+    }
+    get storeRoot() {
+        return join(this.engine.stateRoot, "reminders");
+    }
+    /** Start deadline timers for armed reminders (call after restore). */
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.started)
+                return;
+            this.started = true;
+            const armed = yield this.store.listArmed();
+            let restored = 0;
+            let disarmedOrphan = 0;
+            for (const record of armed) {
+                // Run / function-until handlers are in-memory only. After restart they
+                // are gone — disarm rather than falling back to a generic prompt fire.
+                if ((record.hasRunHandler === true || record.hasUntilFn === true) &&
+                    this.handlers.get(record.id) === undefined) {
+                    yield this.disarm(record, "handler_lost_on_restart");
+                    disarmedOrphan += 1;
+                    continue;
+                }
+                this.armTimer(record);
+                restored += 1;
+            }
+            if (restored > 0 || disarmedOrphan > 0) {
+                this.logger(`[agent-serve] reminders: restored ${restored} armed reminder(s)` +
+                    (disarmedOrphan > 0
+                        ? `; disarmed ${disarmedOrphan} without live handlers`
+                        : ""));
+            }
+        });
+    }
+    stop() {
+        this.started = false;
+        for (const timer of this.timers.values()) {
+            clearTimeout(timer);
+        }
+        this.timers.clear();
+        this.idleGates.clear();
+    }
+    create(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const hasPrompt = input.prompt !== undefined;
+            const hasRun = input.run !== undefined;
+            if (hasPrompt === hasRun) {
+                throw new ReminderValidationError("reminders.create requires exactly one of prompt or run");
+            }
+            if (input.continuationToken.trim() === "") {
+                throw new ReminderValidationError("continuationToken is required");
+            }
+            if (input.channelId.trim() === "") {
+                throw new ReminderValidationError("channelId is required");
+            }
+            if (input.purpose.trim() === "") {
+                throw new ReminderValidationError("purpose is required");
+            }
+            const schedule = resolveSchedule(input);
+            const busyPolicy = (_a = input.busyPolicy) !== null && _a !== void 0 ? _a : defaultBusyPolicy(schedule.kind);
+            const now = new Date().toISOString();
+            const id = newReminderId();
+            const untilPrompt = typeof input.until === "string" ? input.until : undefined;
+            const untilFn = typeof input.until === "function" ? input.until : undefined;
+            const hasRunHandler = input.run !== undefined;
+            const hasUntilFn = untilFn !== undefined;
+            const record = {
+                version: 1,
+                id,
+                purpose: input.purpose,
+                channelId: input.channelId,
+                continuationToken: input.continuationToken,
+                target: input.target,
+                scheduleKind: schedule.kind,
+                scheduleValue: schedule.value,
+                intervalMs: schedule.intervalMs,
+                prompt: input.prompt,
+                hasRunHandler,
+                hasUntilFn,
+                untilPrompt,
+                busyPolicy,
+                status: "armed",
+                fireCount: 0,
+                nextFireAtMs: schedule.nextFireAtMs,
+                createdAt: now,
+                updatedAt: now,
+            };
+            yield this.store.save(record);
+            this.handlers.set(id, {
+                run: input.run,
+                untilFn,
+            });
+            if (this.started) {
+                this.armTimer(record);
+            }
+            return toInfo(record);
+        });
+    }
+    list(filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const all = yield this.store.list();
+            return all
+                .filter((r) => {
+                if ((filter === null || filter === void 0 ? void 0 : filter.status) !== undefined && r.status !== filter.status) {
+                    return false;
+                }
+                if ((filter === null || filter === void 0 ? void 0 : filter.purpose) !== undefined && r.purpose !== filter.purpose) {
+                    return false;
+                }
+                if ((filter === null || filter === void 0 ? void 0 : filter.continuationToken) !== undefined &&
+                    r.continuationToken !== filter.continuationToken) {
+                    return false;
+                }
+                return true;
+            })
+                .map((r) => {
+                const live = this.handlers.get(r.id);
+                const info = toInfo(r);
+                if (live === undefined)
+                    return info;
+                return Object.assign(Object.assign({}, info), { hasRunHandler: live.run !== undefined || info.hasRunHandler, hasUntilFn: live.untilFn !== undefined || info.hasUntilFn });
+            });
+        });
+    }
+    cancel(id_1) {
+        return __awaiter(this, arguments, void 0, function* (id, reason = "explicit_cancel") {
+            const record = yield this.store.get(id);
+            if (record === undefined) {
+                return undefined;
+            }
+            if (record.status !== "armed") {
+                return toInfo(record);
+            }
+            this.clearTimer(id);
+            const updated = Object.assign(Object.assign({}, record), { status: "cancelled", disarmReason: reason, updatedAt: new Date().toISOString() });
+            yield this.store.save(updated);
+            this.handlers.delete(id);
+            return toInfo(updated);
+        });
+    }
+    /** Cancel all armed reminders matching a continuation token (e.g. PR closed). */
+    cancelForContinuation(continuationToken, reason) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const armed = yield this.store.listArmed();
+            let n = 0;
+            for (const record of armed) {
+                if (record.continuationToken === continuationToken) {
+                    yield this.cancel(record.id, reason);
+                    n += 1;
+                }
+            }
+            return n;
+        });
+    }
+    /** Fire one reminder immediately (dev / hillclimb). */
+    dispatch(reminderId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const record = yield this.store.get(reminderId);
+            if (record === undefined) {
+                const ids = (yield this.store.list()).map((r) => r.id);
+                throw new UnknownReminderError(reminderId, ids);
+            }
+            const result = yield this.fire(record.id, { force: true });
+            return Object.assign({ reminderId }, result);
+        });
+    }
+    armTimer(record) {
+        var _a;
+        this.clearTimer(record.id);
+        if (!this.started || record.status !== "armed")
+            return;
+        const nextFireAtMs = Number.isFinite(record.nextFireAtMs)
+            ? record.nextFireAtMs
+            : Date.now();
+        const delay = Math.min(MAX_TIMER_MS, Math.max(0, nextFireAtMs - Date.now()));
+        const timer = setTimeout(() => {
+            void this.fire(record.id).catch((error) => __awaiter(this, void 0, void 0, function* () {
+                this.logger(`[agent-serve] reminder "${record.id}" fire failed: ${error instanceof Error ? error.message : String(error)}`);
+                // Keep recurring reminders alive after unexpected throws.
+                // One-shots stay armed so a failed wake can be retried / dispatched.
+                try {
+                    const current = yield this.store.get(record.id);
+                    if (current === undefined || current.status !== "armed")
+                        return;
+                    const oneShot = current.scheduleKind === "delay" || current.scheduleKind === "at";
+                    if (oneShot) {
+                        this.armTimer(current);
+                        return;
+                    }
+                    yield this.afterFire(current, "skip");
+                }
+                catch (rescheduleError) {
+                    this.logger(`[agent-serve] reminder "${record.id}" reschedule after failure failed: ${rescheduleError instanceof Error
+                        ? rescheduleError.message
+                        : String(rescheduleError)}`);
+                }
+            }));
+        }, delay);
+        (_a = timer.unref) === null || _a === void 0 ? void 0 : _a.call(timer);
+        this.timers.set(record.id, timer);
+    }
+    clearTimer(id) {
+        const timer = this.timers.get(id);
+        if (timer !== undefined) {
+            clearTimeout(timer);
+            this.timers.delete(id);
+        }
+    }
+    fire(id_1) {
+        return __awaiter(this, arguments, void 0, function* (id, opts = {}) {
+            var _a, _b;
+            if (this.firing.has(id)) {
+                return { outcome: "noop", reason: "already_firing" };
+            }
+            this.firing.add(id);
+            try {
+                const record = yield this.store.get(id);
+                if (record === undefined || record.status !== "armed") {
+                    this.clearTimer(id);
+                    return { outcome: "noop", reason: "not_armed" };
+                }
+                if (!opts.force && record.nextFireAtMs > Date.now() + 50) {
+                    // Spurious early wake — re-arm.
+                    this.armTimer(record);
+                    return { outcome: "noop", reason: "not_due" };
+                }
+                const live = (_a = this.handlers.get(id)) !== null && _a !== void 0 ? _a : {};
+                if ((record.hasRunHandler === true || record.hasUntilFn === true) &&
+                    live.run === undefined &&
+                    live.untilFn === undefined) {
+                    yield this.disarm(record, "handler_lost_on_restart");
+                    return { outcome: "noop", reason: "handler_lost_on_restart" };
+                }
+                const untilCtx = this.buildUntilContext(record);
+                if (live.untilFn !== undefined) {
+                    try {
+                        const done = yield live.untilFn(untilCtx);
+                        if (done) {
+                            yield this.disarm(record, "until_fn");
+                            return { outcome: "fired", reason: "until_fn" };
+                        }
+                    }
+                    catch (error) {
+                        this.logger(`[agent-serve] reminder "${id}" until() failed: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                }
+                if (yield this.isSessionBusy(record.channelId, record.continuationToken)) {
+                    if (record.busyPolicy === "skipIfBusy") {
+                        yield this.afterFire(record, "skip");
+                        this.logger(`[agent-serve] reminder "${id}" (${record.purpose}) skipped: session busy`);
+                        return { outcome: "fired", reason: "skipped_busy" };
+                    }
+                    yield this.whenSessionIdle(record.channelId, record.continuationToken);
+                    const still = yield this.store.get(id);
+                    if (still === undefined || still.status !== "armed") {
+                        return { outcome: "noop", reason: "disarmed_while_waiting" };
+                    }
+                }
+                let result;
+                if (live.run !== undefined) {
+                    const fireCtx = this.buildFireContext(record);
+                    result = yield live.run(fireCtx);
+                }
+                else if (record.prompt !== undefined) {
+                    result = yield this.deliverPrompt(record);
+                }
+                else {
+                    yield this.disarm(record, "missing_handler");
+                    return { outcome: "noop", reason: "missing_handler" };
+                }
+                // Cancel / disarm during the handler must win over reschedule.
+                const latest = yield this.store.get(id);
+                if (result.action === "stop") {
+                    if (latest !== undefined && latest.status === "armed") {
+                        yield this.disarm(latest, "run_stop");
+                        this.logger(`[agent-serve] reminder "${id}" (${record.purpose}) disarmed: run_stop`);
+                        return { outcome: "fired", reason: "run_stop" };
+                    }
+                    return {
+                        outcome: "fired",
+                        reason: (_b = latest === null || latest === void 0 ? void 0 : latest.disarmReason) !== null && _b !== void 0 ? _b : "run_stop",
+                    };
+                }
+                if (latest === undefined || latest.status !== "armed") {
+                    return { outcome: "noop", reason: "disarmed_during_fire" };
+                }
+                if (result.action === "skip") {
+                    yield this.afterFire(latest, "skip", result.reschedule);
+                    this.logger(`[agent-serve] reminder "${id}" (${record.purpose}) skipped`);
+                    return { outcome: "fired", reason: "skipped" };
+                }
+                yield this.afterFire(latest, "delivered", result.reschedule);
+                this.logger(`[agent-serve] reminder "${id}" (${record.purpose}) delivered`);
+                return { outcome: "fired", reason: "delivered" };
+            }
+            finally {
+                this.firing.delete(id);
+            }
+        });
+    }
+    isSessionBusy(channelId, continuationToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const existing = yield this.engine.sessions.findByContinuation(channelId, continuationToken);
+            if (existing === undefined)
+                return false;
+            return this.engine.isTurnRunning(existing.sessionId);
+        });
+    }
+    whenSessionIdle(channelId, continuationToken) {
+        const sessionKey = `${channelId}:${continuationToken}`;
+        const existing = this.idleGates.get(sessionKey);
+        if (existing !== undefined)
+            return existing;
+        const gate = (() => __awaiter(this, void 0, void 0, function* () {
+            const session = yield this.engine.sessions.findByContinuation(channelId, continuationToken);
+            if (session === undefined)
+                return;
+            yield this.engine.waitForCompletion(session.sessionId);
+        }))().finally(() => {
+            this.idleGates.delete(sessionKey);
+        });
+        this.idleGates.set(sessionKey, gate);
+        return gate;
+    }
+    /**
+     * Follow-ups must use the bound session's principal. If the session is gone,
+     * disarm rather than creating a fresh APP_AUTH conversation.
+     */
+    resolveFollowupAuth(channelId, continuationToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const existing = yield this.engine.sessions.findByContinuation(channelId, continuationToken);
+            if (existing !== undefined) {
+                return existing.auth;
+            }
+            return undefined;
+        });
+    }
+    deliverPrompt(record) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const auth = yield this.resolveFollowupAuth(record.channelId, record.continuationToken);
+            if (auth === undefined) {
+                yield this.disarm(record, "session_gone");
+                return { action: "stop" };
+            }
+            return this.sendFollowup(record, buildFirePrompt(record), auth);
+        });
+    }
+    sendFollowup(record, message, auth) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const session = yield this.engine.send(record.channelId, message, {
+                    auth,
+                    continuationToken: record.continuationToken,
+                });
+                this.engine.trackBackground(this.engine.waitForCompletion(session.id));
+                return { action: "delivered" };
+            }
+            catch (error) {
+                if (error instanceof SessionBusyError) {
+                    if (record.busyPolicy === "skipIfBusy") {
+                        return { action: "skip" };
+                    }
+                    yield this.whenSessionIdle(record.channelId, record.continuationToken);
+                    try {
+                        const session = yield this.engine.send(record.channelId, message, {
+                            auth,
+                            continuationToken: record.continuationToken,
+                        });
+                        this.engine.trackBackground(this.engine.waitForCompletion(session.id));
+                        return { action: "delivered" };
+                    }
+                    catch (retryError) {
+                        this.logger(`[agent-serve] reminder "${record.id}" followup failed after wait: ${retryError instanceof Error
+                            ? retryError.message
+                            : String(retryError)}`);
+                        return { action: "skip" };
+                    }
+                }
+                throw error;
+            }
+        });
+    }
+    buildFireContext(record) {
+        var _a;
+        const self = this;
+        return {
+            id: record.id,
+            purpose: record.purpose,
+            fireCount: record.fireCount,
+            target: Object.assign({ channelId: record.channelId, continuationToken: record.continuationToken }, ((_a = record.target) !== null && _a !== void 0 ? _a : {})),
+            host: this.engine.host,
+            mcp: this.engine.host.mcp,
+            appAuth: APP_AUTH,
+            followup(args) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const auth = yield self.resolveFollowupAuth(record.channelId, record.continuationToken);
+                    if (auth === undefined) {
+                        yield self.disarm(record, "session_gone");
+                        throw new Error(`Reminder "${record.id}" followup: session gone for continuation`);
+                    }
+                    const result = yield self.sendFollowup(record, args.message, auth);
+                    if (result.action === "skip") {
+                        throw new Error(`Reminder "${record.id}" followup skipped: session busy`);
+                    }
+                    const existing = yield self.engine.sessions.findByContinuation(record.channelId, record.continuationToken);
+                    if (existing === undefined) {
+                        throw new Error(`Reminder "${record.id}" followup: session not found for continuation`);
+                    }
+                    const session = yield self.engine.getChannelSession(record.channelId, existing.sessionId);
+                    if (session === null) {
+                        throw new Error(`Reminder "${record.id}" followup: channel session missing`);
+                    }
+                    return session;
+                });
+            },
+            cancel() {
+                return __awaiter(this, arguments, void 0, function* (reason = "handler_cancel") {
+                    yield self.cancel(record.id, reason);
+                });
+            },
+        };
+    }
+    buildUntilContext(record) {
+        var _a;
+        return {
+            id: record.id,
+            purpose: record.purpose,
+            fireCount: record.fireCount,
+            target: Object.assign({ channelId: record.channelId, continuationToken: record.continuationToken }, ((_a = record.target) !== null && _a !== void 0 ? _a : {})),
+            host: this.engine.host,
+            mcp: this.engine.host.mcp,
+        };
+    }
+    disarm(record, reason) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.clearTimer(record.id);
+            const updated = Object.assign(Object.assign({}, record), { status: "disarmed", disarmReason: reason, updatedAt: new Date().toISOString() });
+            yield this.store.save(updated);
+            this.handlers.delete(record.id);
+        });
+    }
+    afterFire(record, _outcome, reschedule) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const current = yield this.store.get(record.id);
+            if (current === undefined || current.status !== "armed") {
+                return;
+            }
+            const now = Date.now();
+            const oneShot = current.scheduleKind === "delay" || current.scheduleKind === "at";
+            if (reschedule !== undefined) {
+                let nextFireAtMs;
+                if (reschedule.delay !== undefined) {
+                    nextFireAtMs = now + parseDuration(reschedule.delay);
+                }
+                else if (reschedule.at !== undefined) {
+                    nextFireAtMs =
+                        reschedule.at instanceof Date
+                            ? reschedule.at.getTime()
+                            : Date.parse(String(reschedule.at));
+                    if (!Number.isFinite(nextFireAtMs)) {
+                        throw new ReminderValidationError(`Invalid reschedule.at for reminder "${current.id}"`);
+                    }
+                }
+                else {
+                    throw new ReminderValidationError(`reschedule requires delay or at for reminder "${current.id}"`);
+                }
+                const updated = Object.assign(Object.assign({}, current), { fireCount: current.fireCount + 1, nextFireAtMs, 
+                    // Promote to one-shot-from-now semantics if they rescheduled
+                    scheduleKind: reschedule.delay !== undefined ? "delay" : "at", scheduleValue: reschedule.delay !== undefined
+                        ? String(reschedule.delay)
+                        : String(reschedule.at), updatedAt: new Date().toISOString() });
+                yield this.store.save(updated);
+                this.armTimer(updated);
+                return;
+            }
+            if (oneShot) {
+                this.clearTimer(current.id);
+                const updated = Object.assign(Object.assign({}, current), { fireCount: current.fireCount + 1, status: "completed", disarmReason: "one_shot_complete", updatedAt: new Date().toISOString() });
+                yield this.store.save(updated);
+                this.handlers.delete(current.id);
+                return;
+            }
+            // Recurring
+            let nextFireAtMs;
+            if (current.scheduleKind === "every" && current.intervalMs !== undefined) {
+                nextFireAtMs = now + current.intervalMs;
+            }
+            else if (current.scheduleKind === "cron") {
+                nextFireAtMs = nextCronFireMs(current.scheduleValue, now);
+            }
+            else {
+                throw new Error(`Reminder "${current.id}" has recurring status with scheduleKind=${current.scheduleKind}`);
+            }
+            const updated = Object.assign(Object.assign({}, current), { fireCount: current.fireCount + 1, nextFireAtMs, updatedAt: new Date().toISOString() });
+            yield this.store.save(updated);
+            this.armTimer(updated);
+        });
+    }
+}

package/dist/internal/reminder-schedule.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Schedule resolution for reminders (`every` / `cron` / `delay` / `at`).
+ */
+import type { ReminderCreateInput, ReminderScheduleKind } from "../types.js";
+export declare class ReminderValidationError extends Error {
+    constructor(message: string);
+}
+/** Node setTimeout overflows past ~2^31-1 ms (~24.8d); chunk long waits. */
+export declare const MAX_TIMER_MS = 2147483647;
+export interface ResolvedSchedule {
+    kind: ReminderScheduleKind;
+    value: string;
+    intervalMs?: number;
+    nextFireAtMs: number;
+}
+/** Resolve create-input schedule fields into a concrete next-fire plan. */
+export declare function resolveSchedule(input: ReminderCreateInput): ResolvedSchedule;
+/** Next UTC fire strictly after `afterMs` for a 5-field cron. */
+export declare function nextCronFireMs(cronSource: string, afterMs: number): number;
+/** Default busy policy: recurring may skip; one-shots queue behind the turn. */
+export declare function defaultBusyPolicy(kind: ReminderScheduleKind): "skipIfBusy" | "queueBehindTurn";
+//# sourceMappingURL=reminder-schedule.d.ts.map

package/dist/internal/reminder-schedule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reminder-schedule.d.ts","sourceRoot":"","sources":["../../src/internal/reminder-schedule.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAI7E,qBAAa,uBAAwB,SAAQ,KAAK;IAChD,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAED,4EAA4E;AAC5E,eAAO,MAAM,YAAY,aAAgB,CAAC;AAE1C,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,oBAAoB,CAAC;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,2EAA2E;AAC3E,wBAAgB,eAAe,CAAC,KAAK,EAAE,mBAAmB,GAAG,gBAAgB,CA2D5E;AAED,iEAAiE;AACjE,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAU1E;AAED,gFAAgF;AAChF,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,oBAAoB,GACzB,YAAY,GAAG,iBAAiB,CAElC"}