@aplaytest/core 0.1.0

package/dist/history/memory-index.d.ts

@@ -0,0 +1,88 @@
+/**
+ * The query engine, with no storage under it.
+ *
+ * Every driver ends up answering the same four questions — attempts in a
+ * window, distinct test keys, run count, prune — and the SQL that answers them
+ * carries semantics that took real incidents to get right: shard-scoped
+ * replacement, earliest-shard `startedAt`, ordering before the limit. Writing
+ * those a second time in a blob driver would mean maintaining two definitions
+ * of "the same history" and discovering the drift months later, as a flake
+ * score that differs between local and CI.
+ *
+ * So the semantics live here, once, over plain objects. `SqliteHistoryStore`
+ * keeps its own SQL (it is the local/dev driver and the schema is its own
+ * documentation); the Azure driver is this index plus blob I/O, which is the
+ * only shape that makes sense when the durable form is an append-only log of
+ * run records rather than a queryable database.
+ *
+ * Pure and synchronous: no clock, no filesystem, no network. That is what
+ * makes the query semantics testable without a container or an emulator.
+ */
+import type { RunRecord } from './types.js';
+import type { HistoricalAttempt, HistoryQuery, HistoryStore, TestKey } from './store.js';
+/**
+ * Identifies the unit that is replaced wholesale on re-ingest.
+ *
+ * NOT the run id. Under sharding every shard reports the same run id, so
+ * keying on it alone means ingesting shard 2 discards shard 1 — the bug that
+ * once turned three shard files carrying four attempts into zero. A shard is
+ * the smallest thing a re-run can replace, so it is the key.
+ */
+export declare function shardKeyOf(shard: {
+    current: number;
+    total: number;
+} | null | undefined): string;
+/**
+ * In-memory history with SQLite's query semantics and none of its storage.
+ *
+ * Add segments in any order; the answers do not depend on it, except where
+ * SQLite's own answers would not either (last writer wins on mutable run
+ * metadata).
+ */
+export declare class HistoryIndex {
+    /** Keyed `runId\x00shardKey` — the replacement unit. */
+    private readonly segments;
+    add(run: RunRecord): void;
+    /** Drop everything, so a driver can reload from its backing store. */
+    clear(): void;
+    has(runId: string, shardKey: string): boolean;
+    /**
+     * One metadata row per run id, merged across its shards.
+     *
+     * `startedAt` takes the EARLIEST value: a run spanning six shards started
+     * when its first shard did, and letting the last shard ingested stamp the
+     * time would move the run inside the recency window depending on artifact
+     * download order. Everything else is last-writer-wins, matching the UPSERT.
+     */
+    private runMetadata;
+    attempts(query?: HistoryQuery): HistoricalAttempt[];
+    testKeys(): TestKey[];
+    runCount(): number;
+    /**
+     * Remove runs that started before the cutoff. Returns the number of RUNS
+     * dropped, not segments — a six-shard run pruned is one run, which is what
+     * `runCount()` counted it as.
+     */
+    prune(olderThanIso: string): {
+        removedRuns: number;
+        removedKeys: string[];
+    };
+}
+/**
+ * `HistoryStore` over a `HistoryIndex` and nothing else.
+ *
+ * This is what `--db :memory:` should always have meant. Reaching for
+ * `new SqliteHistoryStore(':memory:')` to get a throwaway store — as the MCP
+ * server and `aplaytest impact` both did — pulls in `node:sqlite`, a schema and a
+ * transaction to hold data that is discarded when the process exits.
+ */
+export declare class MemoryHistoryStore implements HistoryStore {
+    private readonly index;
+    ingest(run: RunRecord): Promise<void>;
+    attempts(query?: HistoryQuery): Promise<HistoricalAttempt[]>;
+    testKeys(): Promise<TestKey[]>;
+    runCount(): Promise<number>;
+    prune(olderThanIso: string): Promise<number>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=memory-index.d.ts.map

package/dist/history/memory-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-index.d.ts","sourceRoot":"","sources":["../../src/history/memory-index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAA0B,SAAS,EAAE,MAAM,YAAY,CAAC;AAGpE,OAAO,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAEzF;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAE/F;AAuED;;;;;;GAMG;AACH,qBAAa,YAAY;IACvB,wDAAwD;IACxD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA8B;IAEvD,GAAG,CAAC,GAAG,EAAE,SAAS,GAAG,IAAI;IAKzB,sEAAsE;IACtE,KAAK,IAAI,IAAI;IAIb,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO;IAI7C;;;;;;;OAOG;IACH,OAAO,CAAC,WAAW;IAwBnB,QAAQ,CAAC,KAAK,GAAE,YAAiB,GAAG,iBAAiB,EAAE;IAiCvD,QAAQ,IAAI,OAAO,EAAE;IAqBrB,QAAQ,IAAI,MAAM;IAMlB;;;;OAIG;IACH,KAAK,CAAC,YAAY,EAAE,MAAM,GAAG;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,EAAE,CAAA;KAAE;CAgB5E;AAED;;;;;;;GAOG;AACH,qBAAa,kBAAmB,YAAW,YAAY;IACrD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAsB;IAEtC,MAAM,CAAC,GAAG,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAIrC,QAAQ,CAAC,KAAK,GAAE,YAAiB,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC;IAIhE,QAAQ,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;IAI9B,QAAQ,IAAI,OAAO,CAAC,MAAM,CAAC;IAI3B,KAAK,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAI5C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAG7B"}

package/dist/history/memory-index.js

@@ -0,0 +1,236 @@
+/**
+ * The query engine, with no storage under it.
+ *
+ * Every driver ends up answering the same four questions — attempts in a
+ * window, distinct test keys, run count, prune — and the SQL that answers them
+ * carries semantics that took real incidents to get right: shard-scoped
+ * replacement, earliest-shard `startedAt`, ordering before the limit. Writing
+ * those a second time in a blob driver would mean maintaining two definitions
+ * of "the same history" and discovering the drift months later, as a flake
+ * score that differs between local and CI.
+ *
+ * So the semantics live here, once, over plain objects. `SqliteHistoryStore`
+ * keeps its own SQL (it is the local/dev driver and the schema is its own
+ * documentation); the Azure driver is this index plus blob I/O, which is the
+ * only shape that makes sense when the durable form is an append-only log of
+ * run records rather than a queryable database.
+ *
+ * Pure and synchronous: no clock, no filesystem, no network. That is what
+ * makes the query semantics testable without a container or an emulator.
+ */
+/**
+ * Identifies the unit that is replaced wholesale on re-ingest.
+ *
+ * NOT the run id. Under sharding every shard reports the same run id, so
+ * keying on it alone means ingesting shard 2 discards shard 1 — the bug that
+ * once turned three shard files carrying four attempts into zero. A shard is
+ * the smallest thing a re-run can replace, so it is the key.
+ */
+export function shardKeyOf(shard) {
+    return shard === null || shard === undefined ? 'all' : `${shard.current}-of-${shard.total}`;
+}
+/**
+ * Composite-key separator. NUL rather than a space or a colon, because a run id
+ * is whatever `ATEST_RUN_ID` contained and both of those are legal in one — and
+ * `"a b" + sep + "c"` colliding with `"a" + sep + "b c"` would silently merge
+ * two runs into one.
+ */
+const KEY_SEP = '\u0000';
+function asStringArray(value) {
+    return Array.isArray(value) ? value.filter((v) => typeof v === 'string') : [];
+}
+/**
+ * Records reaching here have been shape-checked, not type-checked: `validate()`
+ * in ingest.ts asserts a schema version, a run id and an attempts array, and
+ * nothing else. A record written by a different atest version can be missing
+ * any optional field entirely, and `undefined` where the type says `T | null`
+ * propagates into scores as a silent NaN rather than an error.
+ */
+function normalizeAttempt(attempt, segment, runMeta) {
+    return {
+        runId: segment.runId,
+        testId: attempt.testId,
+        project: attempt.project,
+        retry: attempt.retry ?? 0,
+        title: attempt.title,
+        titlePath: asStringArray(attempt.titlePath),
+        file: attempt.file,
+        line: attempt.line ?? 0,
+        tags: asStringArray(attempt.tags),
+        outcome: attempt.outcome,
+        failureKind: (attempt.failureKind ?? null),
+        durationMs: attempt.durationMs ?? 0,
+        workerIndex: attempt.workerIndex ?? 0,
+        // An attempt executed during shard 1 of 3 belongs to shard 1 of 3.
+        // Falling back to the run's shard is what keeps the replacement key and
+        // the attempt's own record of itself in agreement.
+        shard: attempt.shard ?? segment.run.shard ?? null,
+        traceId: attempt.traceId ?? null,
+        evidenceId: (attempt.evidenceId ?? null),
+        coScheduled: asStringArray(attempt.coScheduled),
+        routes: asStringArray(attempt.routes),
+        startedAt: runMeta.startedAt,
+        commit: runMeta.commit,
+        branch: runMeta.branch,
+        ci: runMeta.ci,
+        workers: runMeta.workers,
+    };
+}
+/**
+ * In-memory history with SQLite's query semantics and none of its storage.
+ *
+ * Add segments in any order; the answers do not depend on it, except where
+ * SQLite's own answers would not either (last writer wins on mutable run
+ * metadata).
+ */
+export class HistoryIndex {
+    /** Keyed `runId\x00shardKey` — the replacement unit. */
+    segments = new Map();
+    add(run) {
+        const shardKey = shardKeyOf(run.shard);
+        this.segments.set(`${run.runId}${KEY_SEP}${shardKey}`, { runId: run.runId, shardKey, run });
+    }
+    /** Drop everything, so a driver can reload from its backing store. */
+    clear() {
+        this.segments.clear();
+    }
+    has(runId, shardKey) {
+        return this.segments.has(`${runId}${KEY_SEP}${shardKey}`);
+    }
+    /**
+     * One metadata row per run id, merged across its shards.
+     *
+     * `startedAt` takes the EARLIEST value: a run spanning six shards started
+     * when its first shard did, and letting the last shard ingested stamp the
+     * time would move the run inside the recency window depending on artifact
+     * download order. Everything else is last-writer-wins, matching the UPSERT.
+     */
+    runMetadata() {
+        const meta = new Map();
+        for (const segment of this.segments.values()) {
+            const run = segment.run;
+            const existing = meta.get(run.runId);
+            if (existing === undefined) {
+                meta.set(run.runId, {
+                    startedAt: run.startedAt,
+                    commit: run.commit ?? null,
+                    branch: run.branch ?? null,
+                    ci: run.ci === true,
+                    workers: run.workers ?? 0,
+                });
+                continue;
+            }
+            if (run.startedAt < existing.startedAt)
+                existing.startedAt = run.startedAt;
+            existing.commit = run.commit ?? null;
+            existing.branch = run.branch ?? null;
+            existing.ci = run.ci === true;
+            existing.workers = run.workers ?? 0;
+        }
+        return meta;
+    }
+    attempts(query = {}) {
+        const meta = this.runMetadata();
+        const rows = [];
+        for (const segment of this.segments.values()) {
+            const runMeta = meta.get(segment.runId);
+            if (runMeta === undefined)
+                continue;
+            if (query.since !== undefined && runMeta.startedAt < query.since)
+                continue;
+            for (const attempt of segment.run.attempts ?? []) {
+                if (query.testId !== undefined && attempt.testId !== query.testId)
+                    continue;
+                if (query.project !== undefined && attempt.project !== query.project)
+                    continue;
+                rows.push(normalizeAttempt(attempt, segment, runMeta));
+            }
+        }
+        // `ORDER BY r.started_at DESC, a.retry ASC`, then LIMIT — the limit is a
+        // window over the newest attempts, so applying it before the sort would
+        // silently score an arbitrary subset. The extra tiebreakers are not in the
+        // SQL: SQLite leaves ties unordered, and an unstable order here would make
+        // a `--limit`ed score depend on Map iteration order.
+        rows.sort((a, b) => b.startedAt.localeCompare(a.startedAt) ||
+            a.retry - b.retry ||
+            a.runId.localeCompare(b.runId) ||
+            a.testId.localeCompare(b.testId) ||
+            a.project.localeCompare(b.project));
+        return query.limit === undefined ? rows : rows.slice(0, Math.max(0, query.limit));
+    }
+    testKeys() {
+        // Newest first, so the title and file a key reports are the ones the test
+        // has NOW. SQLite's bare-column GROUP BY picks an arbitrary row, which
+        // after a rename reports whichever the query planner happened to visit.
+        const keys = new Map();
+        for (const attempt of this.attempts()) {
+            const key = `${attempt.testId}${KEY_SEP}${attempt.project}`;
+            if (keys.has(key))
+                continue;
+            keys.set(key, {
+                testId: attempt.testId,
+                project: attempt.project,
+                title: attempt.title,
+                file: attempt.file,
+            });
+        }
+        return [...keys.values()].sort((a, b) => a.file.localeCompare(b.file) || a.title.localeCompare(b.title));
+    }
+    runCount() {
+        const ids = new Set();
+        for (const segment of this.segments.values())
+            ids.add(segment.runId);
+        return ids.size;
+    }
+    /**
+     * Remove runs that started before the cutoff. Returns the number of RUNS
+     * dropped, not segments — a six-shard run pruned is one run, which is what
+     * `runCount()` counted it as.
+     */
+    prune(olderThanIso) {
+        const meta = this.runMetadata();
+        const doomed = new Set();
+        for (const [runId, runMeta] of meta) {
+            if (runMeta.startedAt < olderThanIso)
+                doomed.add(runId);
+        }
+        const removedKeys = [];
+        for (const [key, segment] of this.segments) {
+            if (!doomed.has(segment.runId))
+                continue;
+            removedKeys.push(key);
+            this.segments.delete(key);
+        }
+        return { removedRuns: doomed.size, removedKeys };
+    }
+}
+/**
+ * `HistoryStore` over a `HistoryIndex` and nothing else.
+ *
+ * This is what `--db :memory:` should always have meant. Reaching for
+ * `new SqliteHistoryStore(':memory:')` to get a throwaway store — as the MCP
+ * server and `aplaytest impact` both did — pulls in `node:sqlite`, a schema and a
+ * transaction to hold data that is discarded when the process exits.
+ */
+export class MemoryHistoryStore {
+    index = new HistoryIndex();
+    async ingest(run) {
+        this.index.add(run);
+    }
+    async attempts(query = {}) {
+        return this.index.attempts(query);
+    }
+    async testKeys() {
+        return this.index.testKeys();
+    }
+    async runCount() {
+        return this.index.runCount();
+    }
+    async prune(olderThanIso) {
+        return this.index.prune(olderThanIso).removedRuns;
+    }
+    async close() {
+        this.index.clear();
+    }
+}
+//# sourceMappingURL=memory-index.js.map

package/dist/history/memory-index.js.map

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

package/dist/history/playwright-report.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Map a merged Playwright JSON report onto history records.
+ *
+ * This is a runner adapter for suites that cannot install the atest reporter —
+ * most importantly, a suite whose test job is owned by a shared CI template
+ * that only uploads `blob-report/` and the merged JSON. Playwright's own
+ * `--reporter=json` output is then the ONLY channel through which run data
+ * escapes, and it carries more than it first appears to.
+ *
+ * Pure and synchronous, over structural interfaces: the whole mapping is
+ * unit-testable against a plain object, with no store and no filesystem.
+ * `ingestPlaywrightJson` does the I/O and hands the result in.
+ *
+ * ── What this path gives up, and what it does not ───────────────────────────
+ * No evidence bundle: no ARIA snapshot, no locator candidates, no network
+ * ledger, no console capture. Healing therefore still requires the reporter.
+ *
+ * What it does NOT give up is identity. Every field below is read from the
+ * report rather than invented, because a history row that cannot be joined to
+ * the rows around it is worse than no row at all — it looks like data and
+ * scores like noise.
+ */
+import { type RunRecord } from './types.js';
+export interface JsonError {
+    readonly message?: string;
+    readonly stack?: string;
+}
+export interface JsonResult {
+    readonly status?: string;
+    readonly duration?: number;
+    readonly retry?: number;
+    readonly workerIndex?: number;
+    /** ISO timestamp of the attempt. The reason history can be back-filled. */
+    readonly startTime?: string;
+    readonly errors?: readonly JsonError[];
+}
+export interface JsonTest {
+    readonly projectName?: string;
+    readonly timeout?: number;
+    readonly results?: readonly JsonResult[];
+}
+export interface JsonSpec {
+    /** Playwright's stable test id. Present since 1.38; see `attemptTestId`. */
+    readonly id?: string;
+    readonly title?: string;
+    readonly file?: string;
+    readonly line?: number;
+    readonly tags?: readonly string[];
+    readonly tests?: readonly JsonTest[];
+}
+export interface JsonSuite {
+    readonly title?: string;
+    readonly file?: string;
+    readonly specs?: readonly JsonSpec[];
+    readonly suites?: readonly JsonSuite[];
+}
+export interface JsonReport {
+    readonly config?: {
+        readonly version?: string;
+        readonly workers?: number;
+        readonly shard?: {
+            readonly current?: number;
+            readonly total?: number;
+        } | null;
+        readonly metadata?: {
+            readonly actualWorkers?: number;
+            readonly ci?: {
+                readonly commitHash?: string;
+                readonly branch?: string;
+                readonly buildHref?: string;
+            };
+        };
+    };
+    readonly suites?: readonly JsonSuite[];
+}
+/**
+ * Run-level facts the report cannot supply, from the environment doing the
+ * ingest. The report always wins where it has an answer — it describes the run
+ * being ingested, whereas the environment describes whoever is ingesting it,
+ * and those differ whenever history is back-filled from an archived artifact.
+ */
+export interface RunIdentity {
+    readonly commit: string | null;
+    readonly branch: string | null;
+    readonly appEnv: string | null;
+    readonly ci: boolean;
+}
+export interface MappedReport {
+    readonly run: RunRecord;
+    /**
+     * Attempts that collided on the store's primary key and had to be collapsed.
+     * Reported rather than swallowed — see `collapseDuplicates`.
+     */
+    readonly collapsed: readonly string[];
+}
+export interface MapReportOptions {
+    readonly identity: RunIdentity;
+    /** Injectable clock, for the no-timestamps fallback. Tests pin it. */
+    readonly now?: () => number;
+}
+export declare function mapPlaywrightReport(report: JsonReport, options: MapReportOptions): MappedReport;
+//# sourceMappingURL=playwright-report.d.ts.map

package/dist/history/playwright-report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"playwright-report.d.ts","sourceRoot":"","sources":["../../src/history/playwright-report.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAQH,OAAO,EAAwD,KAAK,SAAS,EAAE,MAAM,YAAY,CAAC;AAMlG,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,2EAA2E;IAC3E,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,SAAS,EAAE,CAAC;CACxC;AAED,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,UAAU,EAAE,CAAC;CAC1C;AAED,MAAM,WAAW,QAAQ;IACvB,4EAA4E;IAC5E,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,QAAQ,EAAE,CAAC;CACtC;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,QAAQ,EAAE,CAAC;IACrC,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,SAAS,EAAE,CAAC;CACxC;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,MAAM,CAAC,EAAE;QAChB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,KAAK,CAAC,EAAE;YAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;SAAE,GAAG,IAAI,CAAC;QAC/E,QAAQ,CAAC,QAAQ,CAAC,EAAE;YAClB,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;YAChC,QAAQ,CAAC,EAAE,CAAC,EAAE;gBACZ,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;gBAC7B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;gBACzB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;aAC7B,CAAC;SACH,CAAC;KACH,CAAC;IACF,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,SAAS,EAAE,CAAC;CACxC;AAED;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;IACxB;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC;AAoPD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;IAC/B,sEAAsE;IACtE,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CAC7B;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,gBAAgB,GAAG,YAAY,CAmC/F"}