@supaku/agentfactory-server 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Supaku
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/src/agent-tracking.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Agent Tracking Module
+ *
+ * Tracks which issues the agent has worked on to enable automated QA pickup.
+ * Also tracks QA attempts to prevent infinite loops.
+ */
+/**
+ * Record of an issue that was worked on by an agent
+ */
+export interface AgentWorkRecord {
+    issueId: string;
+    issueIdentifier: string;
+    completedAt: number;
+    sessionId: string;
+    prUrl?: string;
+}
+/**
+ * Record of QA attempts for an issue
+ */
+export interface QAAttemptRecord {
+    issueId: string;
+    attemptNumber: number;
+    startedAt: number;
+    sessionId: string;
+    previousAttempts: Array<{
+        sessionId: string;
+        failedAt: number;
+        reason?: string;
+    }>;
+}
+/**
+ * Mark an issue as having been worked on by the agent
+ */
+export declare function markAgentWorked(issueId: string, data: Omit<AgentWorkRecord, 'issueId' | 'completedAt'>): Promise<void>;
+/**
+ * Check if an issue was worked on by the agent
+ */
+export declare function wasAgentWorked(issueId: string): Promise<AgentWorkRecord | null>;
+/**
+ * Record a QA attempt for an issue
+ */
+export declare function recordQAAttempt(issueId: string, sessionId: string): Promise<QAAttemptRecord>;
+/**
+ * Get QA attempt count for an issue
+ */
+export declare function getQAAttemptCount(issueId: string): Promise<number>;
+/**
+ * Mark an issue as having just failed QA (prevents immediate re-trigger)
+ */
+export declare function markQAFailed(issueId: string, reason?: string): Promise<void>;
+/**
+ * Check if an issue just failed QA (within cooldown period)
+ */
+export declare function didJustFailQA(issueId: string): Promise<boolean>;
+/**
+ * Clear QA failed marker (when issue is fixed and moves to Finished again)
+ */
+export declare function clearQAFailed(issueId: string): Promise<void>;
+/**
+ * Clear agent worked record (e.g., when issue is moved back to Backlog)
+ */
+export declare function clearAgentWorked(issueId: string): Promise<void>;
+/**
+ * Clear QA attempt record (e.g., after successful QA)
+ */
+export declare function clearQAAttempts(issueId: string): Promise<void>;
+/**
+ * Mark an issue as having development work just queued
+ * Prevents rapid re-queuing if status is toggled back and forth
+ */
+export declare function markDevelopmentQueued(issueId: string): Promise<void>;
+/**
+ * Check if development work was just queued for an issue (within cooldown period)
+ */
+export declare function didJustQueueDevelopment(issueId: string): Promise<boolean>;
+/**
+ * Clear development queued marker
+ */
+export declare function clearDevelopmentQueued(issueId: string): Promise<void>;
+/**
+ * Mark an issue as having acceptance work just queued
+ * Prevents rapid re-queuing if status is toggled back and forth
+ */
+export declare function markAcceptanceQueued(issueId: string): Promise<void>;
+/**
+ * Check if acceptance work was just queued for an issue (within cooldown period)
+ */
+export declare function didJustQueueAcceptance(issueId: string): Promise<boolean>;
+/**
+ * Clear acceptance queued marker
+ */
+export declare function clearAcceptanceQueued(issueId: string): Promise<void>;
+/**
+ * Clean up all tracking data for an accepted issue
+ * Called after successful acceptance processing to remove all Redis state
+ */
+export declare function cleanupAcceptedIssue(issueId: string): Promise<void>;
+//# sourceMappingURL=agent-tracking.d.ts.map

package/dist/src/agent-tracking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-tracking.d.ts","sourceRoot":"","sources":["../../src/agent-tracking.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAyBH;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAA;IACf,eAAe,EAAE,MAAM,CAAA;IACvB,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAA;IACf,aAAa,EAAE,MAAM,CAAA;IACrB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,gBAAgB,EAAE,KAAK,CAAC;QACtB,SAAS,EAAE,MAAM,CAAA;QACjB,QAAQ,EAAE,MAAM,CAAA;QAChB,MAAM,CAAC,EAAE,MAAM,CAAA;KAChB,CAAC,CAAA;CACH;AAED;;GAEG;AACH,wBAAsB,eAAe,CACnC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,IAAI,CAAC,eAAe,EAAE,SAAS,GAAG,aAAa,CAAC,GACrD,OAAO,CAAC,IAAI,CAAC,CAYf;AAED;;GAEG;AACH,wBAAsB,cAAc,CAClC,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAGjC;AAED;;GAEG;AACH,wBAAsB,eAAe,CACnC,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,eAAe,CAAC,CA2B1B;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAIxE;AAED;;GAEG;AACH,wBAAsB,YAAY,CAChC,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,IAAI,CAAC,CAIf;AAED;;GAEG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAGrE;AAED;;GAEG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAIlE;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAIrE;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAIpE;AAED;;;GAGG;AACH,wBAAsB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAI1E;AAED;;GAEG;AACH,wBAAsB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAG/E;AAED;;GAEG;AACH,wBAAsB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAI3E;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAIzE;AAED;;GAEG;AACH,wBAAsB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAG9E;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAI1E;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAWzE"}

package/dist/src/agent-tracking.js

@@ -0,0 +1,185 @@
+/**
+ * Agent Tracking Module
+ *
+ * Tracks which issues the agent has worked on to enable automated QA pickup.
+ * Also tracks QA attempts to prevent infinite loops.
+ */
+import { redisSet, redisGet, redisExists, redisDel } from './redis';
+const log = {
+    info: (msg, data) => console.log(`[tracking] ${msg}`, data ? JSON.stringify(data) : ''),
+    warn: (msg, data) => console.warn(`[tracking] ${msg}`, data ? JSON.stringify(data) : ''),
+    error: (msg, data) => console.error(`[tracking] ${msg}`, data ? JSON.stringify(data) : ''),
+    debug: (_msg, _data) => { },
+};
+// Redis key prefixes
+const AGENT_WORKED_PREFIX = 'agent:worked:';
+const QA_ATTEMPT_PREFIX = 'qa:attempt:';
+const QA_FAILED_PREFIX = 'qa:failed:';
+const DEV_QUEUED_PREFIX = 'agent:dev-queued:';
+const ACCEPTANCE_QUEUED_PREFIX = 'agent:acceptance-queued:';
+// TTLs in seconds
+const AGENT_WORKED_TTL = 7 * 24 * 60 * 60; // 7 days
+const QA_ATTEMPT_TTL = 24 * 60 * 60; // 24 hours
+const QA_FAILED_TTL = 60 * 60; // 1 hour
+const DEV_QUEUED_TTL = 10; // 10 seconds - just enough to prevent duplicate webhooks
+const ACCEPTANCE_QUEUED_TTL = 10; // 10 seconds - just enough to prevent duplicate webhooks
+/**
+ * Mark an issue as having been worked on by the agent
+ */
+export async function markAgentWorked(issueId, data) {
+    const key = `${AGENT_WORKED_PREFIX}${issueId}`;
+    const record = {
+        ...data,
+        issueId,
+        completedAt: Date.now(),
+    };
+    await redisSet(key, record, AGENT_WORKED_TTL);
+    log.info('Marked agent worked', {
+        issueId,
+        issueIdentifier: data.issueIdentifier,
+    });
+}
+/**
+ * Check if an issue was worked on by the agent
+ */
+export async function wasAgentWorked(issueId) {
+    const key = `${AGENT_WORKED_PREFIX}${issueId}`;
+    return redisGet(key);
+}
+/**
+ * Record a QA attempt for an issue
+ */
+export async function recordQAAttempt(issueId, sessionId) {
+    const key = `${QA_ATTEMPT_PREFIX}${issueId}`;
+    const existing = await redisGet(key);
+    const record = {
+        issueId,
+        attemptNumber: (existing?.attemptNumber ?? 0) + 1,
+        startedAt: Date.now(),
+        sessionId,
+        previousAttempts: existing?.previousAttempts ?? [],
+    };
+    // Add current attempt to history if this is a retry
+    if (existing) {
+        record.previousAttempts.push({
+            sessionId: existing.sessionId,
+            failedAt: Date.now(),
+        });
+    }
+    await redisSet(key, record, QA_ATTEMPT_TTL);
+    log.info('Recorded QA attempt', {
+        issueId,
+        attemptNumber: record.attemptNumber,
+    });
+    return record;
+}
+/**
+ * Get QA attempt count for an issue
+ */
+export async function getQAAttemptCount(issueId) {
+    const key = `${QA_ATTEMPT_PREFIX}${issueId}`;
+    const record = await redisGet(key);
+    return record?.attemptNumber ?? 0;
+}
+/**
+ * Mark an issue as having just failed QA (prevents immediate re-trigger)
+ */
+export async function markQAFailed(issueId, reason) {
+    const key = `${QA_FAILED_PREFIX}${issueId}`;
+    await redisSet(key, { failedAt: Date.now(), reason }, QA_FAILED_TTL);
+    log.info('Marked QA failed', { issueId, reason });
+}
+/**
+ * Check if an issue just failed QA (within cooldown period)
+ */
+export async function didJustFailQA(issueId) {
+    const key = `${QA_FAILED_PREFIX}${issueId}`;
+    return redisExists(key);
+}
+/**
+ * Clear QA failed marker (when issue is fixed and moves to Finished again)
+ */
+export async function clearQAFailed(issueId) {
+    const key = `${QA_FAILED_PREFIX}${issueId}`;
+    await redisDel(key);
+    log.debug('Cleared QA failed marker', { issueId });
+}
+/**
+ * Clear agent worked record (e.g., when issue is moved back to Backlog)
+ */
+export async function clearAgentWorked(issueId) {
+    const key = `${AGENT_WORKED_PREFIX}${issueId}`;
+    await redisDel(key);
+    log.debug('Cleared agent worked marker', { issueId });
+}
+/**
+ * Clear QA attempt record (e.g., after successful QA)
+ */
+export async function clearQAAttempts(issueId) {
+    const key = `${QA_ATTEMPT_PREFIX}${issueId}`;
+    await redisDel(key);
+    log.debug('Cleared QA attempts', { issueId });
+}
+/**
+ * Mark an issue as having development work just queued
+ * Prevents rapid re-queuing if status is toggled back and forth
+ */
+export async function markDevelopmentQueued(issueId) {
+    const key = `${DEV_QUEUED_PREFIX}${issueId}`;
+    await redisSet(key, { queuedAt: Date.now() }, DEV_QUEUED_TTL);
+    log.info('Marked development queued', { issueId });
+}
+/**
+ * Check if development work was just queued for an issue (within cooldown period)
+ */
+export async function didJustQueueDevelopment(issueId) {
+    const key = `${DEV_QUEUED_PREFIX}${issueId}`;
+    return redisExists(key);
+}
+/**
+ * Clear development queued marker
+ */
+export async function clearDevelopmentQueued(issueId) {
+    const key = `${DEV_QUEUED_PREFIX}${issueId}`;
+    await redisDel(key);
+    log.debug('Cleared development queued marker', { issueId });
+}
+/**
+ * Mark an issue as having acceptance work just queued
+ * Prevents rapid re-queuing if status is toggled back and forth
+ */
+export async function markAcceptanceQueued(issueId) {
+    const key = `${ACCEPTANCE_QUEUED_PREFIX}${issueId}`;
+    await redisSet(key, { queuedAt: Date.now() }, ACCEPTANCE_QUEUED_TTL);
+    log.info('Marked acceptance queued', { issueId });
+}
+/**
+ * Check if acceptance work was just queued for an issue (within cooldown period)
+ */
+export async function didJustQueueAcceptance(issueId) {
+    const key = `${ACCEPTANCE_QUEUED_PREFIX}${issueId}`;
+    return redisExists(key);
+}
+/**
+ * Clear acceptance queued marker
+ */
+export async function clearAcceptanceQueued(issueId) {
+    const key = `${ACCEPTANCE_QUEUED_PREFIX}${issueId}`;
+    await redisDel(key);
+    log.debug('Cleared acceptance queued marker', { issueId });
+}
+/**
+ * Clean up all tracking data for an accepted issue
+ * Called after successful acceptance processing to remove all Redis state
+ */
+export async function cleanupAcceptedIssue(issueId) {
+    const keysToDelete = [
+        `${AGENT_WORKED_PREFIX}${issueId}`,
+        `${QA_ATTEMPT_PREFIX}${issueId}`,
+        `${QA_FAILED_PREFIX}${issueId}`,
+        `${DEV_QUEUED_PREFIX}${issueId}`,
+        `${ACCEPTANCE_QUEUED_PREFIX}${issueId}`,
+    ];
+    await Promise.all(keysToDelete.map((key) => redisDel(key)));
+    log.info('Cleaned up all tracking data for accepted issue', { issueId });
+}

package/dist/src/index.d.ts

@@ -0,0 +1,9 @@
+export * from './types';
+export * from './redis';
+export * from './session-storage';
+export * from './work-queue';
+export * from './worker-storage';
+export * from './issue-lock';
+export * from './agent-tracking';
+export * from './webhook-idempotency';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,cAAc,SAAS,CAAA;AAGvB,cAAc,SAAS,CAAA;AAGvB,cAAc,mBAAmB,CAAA;AAGjC,cAAc,cAAc,CAAA;AAG5B,cAAc,kBAAkB,CAAA;AAGhC,cAAc,cAAc,CAAA;AAG5B,cAAc,kBAAkB,CAAA;AAGhC,cAAc,uBAAuB,CAAA"}

package/dist/src/index.js

@@ -0,0 +1,16 @@
+// Types
+export * from './types';
+// Redis client
+export * from './redis';
+// Session management
+export * from './session-storage';
+// Work queue
+export * from './work-queue';
+// Worker pool
+export * from './worker-storage';
+// Issue locking
+export * from './issue-lock';
+// Agent tracking
+export * from './agent-tracking';
+// Webhook idempotency
+export * from './webhook-idempotency';

package/dist/src/issue-lock.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Issue Lock Module
+ *
+ * Prevents overlapping agents for the same issue by providing:
+ * - Per-issue mutex (Redis SET NX) that gates work dispatch
+ * - Per-issue pending queue for parking incoming work while locked
+ * - Automatic promotion: releasing a lock dispatches the next pending item
+ *
+ * Redis Keys:
+ * - issue:lock:{issueId}         -- String (JSON IssueLock), 2hr TTL
+ * - issue:pending:{issueId}      -- Sorted Set (priority-ordered session IDs)
+ * - issue:pending:items:{issueId} -- Hash (sessionId -> JSON QueuedWork)
+ */
+import { type QueuedWork } from './work-queue';
+import type { AgentWorkType } from './types';
+/**
+ * Lock payload stored in Redis
+ */
+export interface IssueLock {
+    sessionId: string;
+    workType: AgentWorkType;
+    workerId: string | null;
+    lockedAt: number;
+    issueIdentifier: string;
+}
+/**
+ * Result of a dispatchWork call
+ */
+export interface DispatchResult {
+    dispatched: boolean;
+    parked: boolean;
+    replaced: boolean;
+}
+/**
+ * Acquire an issue-level lock.
+ * Uses SET NX for atomicity -- only one caller wins.
+ *
+ * @returns true if lock was acquired
+ */
+export declare function acquireIssueLock(issueId: string, lock: IssueLock): Promise<boolean>;
+/**
+ * Read the current lock for an issue.
+ */
+export declare function getIssueLock(issueId: string): Promise<IssueLock | null>;
+/**
+ * Release an issue lock. Idempotent.
+ */
+export declare function releaseIssueLock(issueId: string): Promise<void>;
+/**
+ * Refresh the TTL on an issue lock (extend while agent is alive).
+ */
+export declare function refreshIssueLockTTL(issueId: string, ttlSeconds?: number): Promise<boolean>;
+/**
+ * Park work for a locked issue.
+ *
+ * Deduplication: at most one parked item per workType per issue.
+ * If a parked item with the same workType already exists, it's replaced
+ * (the latest webhook wins). Different workTypes can coexist.
+ */
+export declare function parkWorkForIssue(issueId: string, work: QueuedWork): Promise<{
+    parked: boolean;
+    replaced: boolean;
+}>;
+/**
+ * Promote the next pending work item for an issue.
+ * Pops the highest-priority item, acquires the issue lock for it,
+ * and queues it in the global work queue.
+ *
+ * @returns The promoted work item, or null if nothing to promote
+ */
+export declare function promoteNextPendingWork(issueId: string): Promise<QueuedWork | null>;
+/**
+ * Get the count of pending work items for an issue.
+ */
+export declare function getPendingWorkCount(issueId: string): Promise<number>;
+/**
+ * Main entry point for dispatching work.
+ *
+ * Try to acquire the issue lock:
+ * - If acquired -> queue the work in the global queue
+ * - If locked -> park the work in the per-issue pending queue
+ *
+ * @returns DispatchResult indicating what happened
+ */
+export declare function dispatchWork(work: QueuedWork): Promise<DispatchResult>;
+/**
+ * Remove a parked work item by sessionId.
+ *
+ * The issue-pending hash is keyed by workType, so we scan all entries
+ * to find the one matching the given sessionId.
+ *
+ * @returns true if a matching parked item was found and removed
+ */
+export declare function removeParkedWorkBySessionId(issueId: string, sessionId: string): Promise<boolean>;
+/**
+ * Check if a session is parked in any issue-pending queue.
+ *
+ * Scans the issue:pending:items:{issueId} hash entries for a matching sessionId.
+ *
+ * @param issueId - The issue to check
+ * @param sessionId - The session to look for
+ * @returns true if the session is parked for this issue
+ */
+export declare function isSessionParkedForIssue(issueId: string, sessionId: string): Promise<boolean>;
+/**
+ * Scan for expired issue locks that have pending work.
+ * If a lock expired naturally (TTL) but pending items remain, promote them.
+ *
+ * Called from orphan-cleanup to handle crashed workers that didn't release locks.
+ */
+export declare function cleanupExpiredLocksWithPendingWork(): Promise<number>;
+/**
+ * Release issue locks held by sessions that have already reached a terminal state.
+ *
+ * This handles the case where a session completes but the lock release failed
+ * (e.g., network error during cleanup). The lock's 2-hour TTL would eventually
+ * expire, but this proactively clears it when workers have idle capacity.
+ *
+ * Only runs when workers are online -- if no workers are available, there's no
+ * point promoting parked work since nothing can pick it up.
+ *
+ * @param hasIdleWorkers - true if at least one worker is online with spare capacity
+ * @returns Number of stale locks released and parked work promoted
+ */
+export declare function cleanupStaleLocksWithIdleWorkers(hasIdleWorkers: boolean): Promise<number>;
+//# sourceMappingURL=issue-lock.d.ts.map

package/dist/src/issue-lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"issue-lock.d.ts","sourceRoot":"","sources":["../../src/issue-lock.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAmBH,OAAO,EAAa,KAAK,UAAU,EAAE,MAAM,cAAc,CAAA;AAEzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAoB5C;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,aAAa,CAAA;IACvB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,QAAQ,EAAE,MAAM,CAAA;IAChB,eAAe,EAAE,MAAM,CAAA;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,OAAO,CAAA;IACnB,MAAM,EAAE,OAAO,CAAA;IACf,QAAQ,EAAE,OAAO,CAAA;CAClB;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,SAAS,GACd,OAAO,CAAC,OAAO,CAAC,CA4BlB;AAED;;GAEG;AACH,wBAAsB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CAY7E;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAUrE;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,MAAM,EACf,UAAU,GAAE,MAAyB,GACpC,OAAO,CAAC,OAAO,CAAC,CAUlB;AAED;;;;;;GAMG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,UAAU,GACf,OAAO,CAAC;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,CAAC,CAoDjD;AAED;;;;;;GAMG;AACH,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAqE5B;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAU1E;AAED;;;;;;;;GAQG;AACH,wBAAsB,YAAY,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,cAAc,CAAC,CAoD5E;AAED;;;;;;;GAOG;AACH,wBAAsB,2BAA2B,CAC/C,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,OAAO,CAAC,CAsClB;AAED;;;;;;;;GAQG;AACH,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,OAAO,CAAC,CAwBlB;AAED;;;;;GAKG;AACH,wBAAsB,kCAAkC,IAAI,OAAO,CAAC,MAAM,CAAC,CA0C1E;AAID;;;;;;;;;;;;GAYG;AACH,wBAAsB,gCAAgC,CACpD,cAAc,EAAE,OAAO,GACtB,OAAO,CAAC,MAAM,CAAC,CAgEjB"}