@nuanu-ai/agentbrowse 0.2.47 → 0.2.49

package/dist/run-store.js

@@ -0,0 +1,631 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync, } from 'node:fs';
+import { randomBytes, randomUUID } from 'node:crypto';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const PACKAGE_JSON_URL = new URL('../package.json', import.meta.url);
+const SERVICE_NAME = '@nuanu-ai/agentbrowse';
+const RUN_LOCK_DIRNAME = '.lock';
+const RUN_LOCK_TIMEOUT_MS = 2_000;
+const RUN_LOCK_RETRY_MS = 10;
+const RUN_LOCK_STALE_MS = 30_000;
+const lockSleepView = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
+export const DEFAULT_RUN_RETENTION_DAYS = 7;
+function ensureRunsDir() {
+    const runsDir = getRunsDir();
+    if (!existsSync(runsDir)) {
+        mkdirSync(runsDir, { recursive: true });
+    }
+}
+function getRunDir(runId) {
+    return join(getRunsDir(), runId);
+}
+function getRunRecordPath(runId) {
+    return join(getRunDir(runId), 'run.json');
+}
+function getRunsDir() {
+    return join(homedir(), '.agentpay', 'runs');
+}
+function getRunStepsDir(runId) {
+    return join(getRunDir(runId), 'steps');
+}
+function getRunArtifactsDir(runId) {
+    return join(getRunDir(runId), 'artifacts');
+}
+function getRunSnapshotsDir(runId) {
+    return join(getRunDir(runId), 'snapshots');
+}
+function getRunEventsDir(runId) {
+    return join(getRunDir(runId), 'events');
+}
+function getStepRecordPath(runId, stepId) {
+    return join(getRunStepsDir(runId), `${stepId}.json`);
+}
+function getArtifactManifestPath(runId, artifactManifestId) {
+    return join(getRunArtifactsDir(runId), `${artifactManifestId}.json`);
+}
+function getBrowserStateSnapshotPath(runId, snapshotId) {
+    return join(getRunSnapshotsDir(runId), `${snapshotId}.json`);
+}
+function getRunEventRecordPath(runId, eventId) {
+    return join(getRunEventsDir(runId), `${eventId}.json`);
+}
+function getRunLockDir(runId) {
+    return join(getRunDir(runId), RUN_LOCK_DIRNAME);
+}
+function randomHex(bytes) {
+    return randomBytes(bytes).toString('hex');
+}
+function readCurrentPackageVersion() {
+    const raw = JSON.parse(readFileSync(PACKAGE_JSON_URL, 'utf-8'));
+    if (!raw.version || typeof raw.version !== 'string') {
+        throw new Error('Package version is missing from package.json.');
+    }
+    return raw.version;
+}
+function parseHostHints(url) {
+    if (!url) {
+        return undefined;
+    }
+    try {
+        return [new URL(url).host];
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseTimestamp(value) {
+    if (!value) {
+        return null;
+    }
+    const parsed = new Date(value).getTime();
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function formatUnknownError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === 'string') {
+        return error;
+    }
+    if (error && typeof error === 'object') {
+        try {
+            return JSON.stringify(error);
+        }
+        catch {
+            return Object.prototype.toString.call(error);
+        }
+    }
+    return String(error);
+}
+function isFsError(error, code) {
+    return typeof error === 'object' && error !== null && 'code' in error && error.code === code;
+}
+function sleepSync(ms) {
+    Atomics.wait(lockSleepView, 0, 0, ms);
+}
+function atomicWriteUtf8(filePath, contents) {
+    const tempPath = `${filePath}.${process.pid}.${randomHex(4)}.tmp`;
+    try {
+        writeFileSync(tempPath, contents, 'utf-8');
+        renameSync(tempPath, filePath);
+    }
+    catch (error) {
+        rmSync(tempPath, { force: true });
+        throw error;
+    }
+}
+function listRunStepRecords(runId) {
+    const stepsDir = getRunStepsDir(runId);
+    if (!existsSync(stepsDir)) {
+        return [];
+    }
+    const records = [];
+    for (const entry of readdirSync(stepsDir, { withFileTypes: true })) {
+        if (!entry.isFile() || !entry.name.endsWith('.json')) {
+            continue;
+        }
+        try {
+            const parsed = JSON.parse(readFileSync(join(stepsDir, entry.name), 'utf-8'));
+            if (parsed.runId === runId) {
+                records.push({
+                    ...parsed,
+                    eventIds: loadDerivedEventIds(runId, parsed.stepId, parsed.eventIds),
+                    childSpanIds: parsed.childSpanIds ??
+                        parsed.childSpans?.map((childSpan) => childSpan.spanId) ??
+                        [],
+                    childSpans: parsed.childSpans ?? [],
+                });
+            }
+        }
+        catch {
+        }
+    }
+    records.sort((left, right) => {
+        if (left.ordinal !== right.ordinal) {
+            return left.ordinal - right.ordinal;
+        }
+        const leftStartedAt = parseTimestamp(left.startedAt) ?? 0;
+        const rightStartedAt = parseTimestamp(right.startedAt) ?? 0;
+        if (leftStartedAt !== rightStartedAt) {
+            return leftStartedAt - rightStartedAt;
+        }
+        return left.stepId.localeCompare(right.stepId);
+    });
+    return records;
+}
+function listRunEventRecords(runId, stepId) {
+    const eventsDir = getRunEventsDir(runId);
+    if (!existsSync(eventsDir)) {
+        return [];
+    }
+    const records = [];
+    for (const entry of readdirSync(eventsDir, { withFileTypes: true })) {
+        if (!entry.isFile() || !entry.name.endsWith('.json')) {
+            continue;
+        }
+        try {
+            const parsed = JSON.parse(readFileSync(join(eventsDir, entry.name), 'utf-8'));
+            if (parsed.runId === runId && (!stepId || parsed.stepId === stepId)) {
+                records.push(parsed);
+            }
+        }
+        catch {
+        }
+    }
+    records.sort((left, right) => {
+        const leftEmittedAt = parseTimestamp(left.emittedAt) ?? 0;
+        const rightEmittedAt = parseTimestamp(right.emittedAt) ?? 0;
+        if (leftEmittedAt !== rightEmittedAt) {
+            return leftEmittedAt - rightEmittedAt;
+        }
+        return left.eventId.localeCompare(right.eventId);
+    });
+    return records;
+}
+function loadDerivedStepIds(runId, fallbackStepIds) {
+    const derived = listRunStepRecords(runId).map((step) => step.stepId);
+    if (derived.length > 0) {
+        return derived;
+    }
+    return [...(fallbackStepIds ?? [])];
+}
+function loadDerivedEventIds(runId, stepId, fallbackEventIds) {
+    const derived = listRunEventRecords(runId, stepId).map((event) => event.eventId);
+    if (derived.length > 0) {
+        return derived;
+    }
+    return [...(fallbackEventIds ?? [])];
+}
+function withRunLock(runId, fn) {
+    ensureRunsDir();
+    mkdirSync(getRunDir(runId), { recursive: true });
+    const lockDir = getRunLockDir(runId);
+    const deadline = Date.now() + RUN_LOCK_TIMEOUT_MS;
+    while (true) {
+        try {
+            mkdirSync(lockDir);
+            break;
+        }
+        catch (error) {
+            if (!isFsError(error, 'EEXIST')) {
+                throw error;
+            }
+            let lockAgeMs = null;
+            try {
+                lockAgeMs = Date.now() - statSync(lockDir).mtimeMs;
+            }
+            catch {
+                continue;
+            }
+            if (lockAgeMs > RUN_LOCK_STALE_MS) {
+                rmSync(lockDir, { recursive: true, force: true });
+                continue;
+            }
+            if (Date.now() >= deadline) {
+                throw new Error(`run_lock_timeout:${runId}`);
+            }
+            sleepSync(RUN_LOCK_RETRY_MS);
+        }
+    }
+    try {
+        return fn();
+    }
+    finally {
+        rmSync(lockDir, { recursive: true, force: true });
+    }
+}
+function isTerminalStatus(status) {
+    return status === 'completed' || status === 'failed' || status === 'aborted';
+}
+export function createCliRunRecord(options) {
+    const now = options.now ?? new Date();
+    const packageVersion = readCurrentPackageVersion();
+    return {
+        runId: randomUUID(),
+        sessionId: options.sessionId,
+        startedAt: now.toISOString(),
+        status: 'running',
+        source: 'cli',
+        entryCommand: options.entryCommand,
+        ...(options.displayName ? { displayName: options.displayName } : {}),
+        profile: options.profile,
+        runtimeVersion: process.version,
+        cliVersion: packageVersion,
+        cwd: options.cwd ?? process.cwd(),
+        hostHints: parseHostHints(options.url),
+        traceContext: {
+            traceId: randomHex(16),
+            rootSpanId: randomHex(8),
+            propagationMode: 'single-trace-across-cli-steps',
+        },
+        resource: {
+            serviceName: SERVICE_NAME,
+            serviceVersion: packageVersion,
+            serviceInstanceId: options.sessionId,
+            telemetrySdkLanguage: 'nodejs',
+        },
+        stepIds: [],
+        protectedRun: options.protectedRun === true,
+        ingestState: 'local_only',
+    };
+}
+export function saveRunRecord(record) {
+    ensureRunsDir();
+    const runDir = getRunDir(record.runId);
+    mkdirSync(runDir, { recursive: true });
+    const { stepIds: _stepIds, ...persisted } = record;
+    atomicWriteUtf8(getRunRecordPath(record.runId), JSON.stringify(persisted, null, 2) + '\n');
+}
+export function startCliRun(options) {
+    const record = createCliRunRecord(options);
+    saveRunRecord(record);
+    return record;
+}
+export function loadRunRecord(runId) {
+    const recordPath = getRunRecordPath(runId);
+    if (!existsSync(recordPath)) {
+        return null;
+    }
+    try {
+        const persisted = JSON.parse(readFileSync(recordPath, 'utf-8'));
+        return {
+            ...persisted,
+            stepIds: loadDerivedStepIds(runId, persisted.stepIds),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function loadStepRecord(runId, stepId) {
+    const recordPath = getStepRecordPath(runId, stepId);
+    if (!existsSync(recordPath)) {
+        return null;
+    }
+    try {
+        const persisted = JSON.parse(readFileSync(recordPath, 'utf-8'));
+        return {
+            ...persisted,
+            eventIds: loadDerivedEventIds(runId, stepId, persisted.eventIds),
+            childSpanIds: persisted.childSpanIds ?? persisted.childSpans?.map((childSpan) => childSpan.spanId) ?? [],
+            childSpans: persisted.childSpans ?? [],
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function saveStepRecord(record) {
+    ensureRunsDir();
+    mkdirSync(getRunDir(record.runId), { recursive: true });
+    mkdirSync(getRunStepsDir(record.runId), { recursive: true });
+    const { eventIds: _eventIds, childSpanIds: _childSpanIds, ...persisted } = record;
+    atomicWriteUtf8(getStepRecordPath(record.runId, record.stepId), JSON.stringify(persisted, null, 2) + '\n');
+}
+export function loadArtifactManifest(runId, artifactManifestId) {
+    const manifestPath = getArtifactManifestPath(runId, artifactManifestId);
+    if (!existsSync(manifestPath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(readFileSync(manifestPath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function saveArtifactManifest(runId, manifest) {
+    withRunLock(runId, () => {
+        ensureRunsDir();
+        mkdirSync(getRunDir(runId), { recursive: true });
+        mkdirSync(getRunArtifactsDir(runId), { recursive: true });
+        atomicWriteUtf8(getArtifactManifestPath(runId, manifest.artifactManifestId), JSON.stringify(manifest, null, 2) + '\n');
+    });
+}
+export function loadBrowserStateSnapshot(runId, snapshotId) {
+    const snapshotPath = getBrowserStateSnapshotPath(runId, snapshotId);
+    if (!existsSync(snapshotPath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(readFileSync(snapshotPath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function recordStepSnapshot(options) {
+    return withRunLock(options.runId, () => {
+        const step = loadStepRecord(options.runId, options.stepId);
+        if (!step) {
+            return null;
+        }
+        const snapshot = {
+            snapshotId: randomUUID(),
+            runId: options.runId,
+            stepId: options.stepId,
+            phase: options.phase,
+            capturedAt: options.capturedAt ?? new Date().toISOString(),
+            pageRef: options.pageRef,
+            url: options.url,
+            ...(options.title ? { title: options.title } : {}),
+            tabs: options.tabs.map((tab) => ({ ...tab })),
+            runtimeSummary: {
+                ...options.runtimeSummary,
+            },
+            ...(options.protectionState ? { protectionState: { ...options.protectionState } } : {}),
+            ...(options.artifactRefs ? { artifactRefs: { ...options.artifactRefs } } : {}),
+        };
+        mkdirSync(getRunDir(options.runId), { recursive: true });
+        mkdirSync(getRunSnapshotsDir(options.runId), { recursive: true });
+        atomicWriteUtf8(getBrowserStateSnapshotPath(options.runId, snapshot.snapshotId), JSON.stringify(snapshot, null, 2) + '\n');
+        if (options.phase === 'before' || options.phase === 'after') {
+            const nextStep = {
+                ...step,
+                ...(options.phase === 'before'
+                    ? { beforeSnapshotId: step.beforeSnapshotId ?? snapshot.snapshotId }
+                    : { afterSnapshotId: step.afterSnapshotId ?? snapshot.snapshotId }),
+            };
+            saveStepRecord(nextStep);
+        }
+        return snapshot;
+    });
+}
+export function loadRunEventRecord(runId, eventId) {
+    const eventPath = getRunEventRecordPath(runId, eventId);
+    if (!existsSync(eventPath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(readFileSync(eventPath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function listRunEventRecordsForStep(runId, stepId) {
+    return listRunEventRecords(runId, stepId);
+}
+export function appendRunEvent(options) {
+    return withRunLock(options.runId, () => {
+        const step = loadStepRecord(options.runId, options.stepId);
+        if (!step) {
+            return null;
+        }
+        const event = {
+            eventId: randomUUID(),
+            runId: options.runId,
+            stepId: options.stepId,
+            traceId: step.otel.traceId,
+            spanId: step.otel.spanId,
+            emittedAt: options.emittedAt ?? new Date().toISOString(),
+            source: options.source,
+            name: options.name,
+            attributes: { ...(options.attributes ?? {}) },
+        };
+        mkdirSync(getRunDir(options.runId), { recursive: true });
+        mkdirSync(getRunEventsDir(options.runId), { recursive: true });
+        atomicWriteUtf8(getRunEventRecordPath(options.runId, event.eventId), JSON.stringify(event, null, 2) + '\n');
+        return event;
+    });
+}
+export function startRunStep(options) {
+    if (!existsSync(getRunRecordPath(options.runId))) {
+        return null;
+    }
+    return withRunLock(options.runId, () => {
+        const run = loadRunRecord(options.runId);
+        if (!run) {
+            return null;
+        }
+        const previousStep = listRunStepRecords(run.runId).at(-1) ?? null;
+        const ordinal = run.stepIds.length + 1;
+        const stepId = randomUUID();
+        const step = {
+            stepId,
+            runId: run.runId,
+            ordinal,
+            command: options.command,
+            startedAt: (options.now ?? new Date()).toISOString(),
+            otel: {
+                traceId: run.traceContext.traceId,
+                spanId: randomHex(8),
+                parentSpanId: run.traceContext.rootSpanId,
+                ...(previousStep ? { linkedSpanIds: [previousStep.otel.spanId] } : {}),
+                spanName: `agentbrowse.${options.command}`,
+                spanKind: 'internal',
+                statusCode: 'unset',
+                instrumentationScope: 'agentbrowse.local-run-store',
+            },
+            input: { ...(options.input ?? {}) },
+            ...(options.refs ? { refs: options.refs } : {}),
+            eventIds: [],
+            childSpanIds: [],
+            childSpans: [],
+            protectedStep: options.protectedStep === true,
+        };
+        saveStepRecord(step);
+        return step;
+    });
+}
+export function finishRunStep(options) {
+    return withRunLock(options.runId, () => {
+        const step = loadStepRecord(options.runId, options.stepId);
+        if (!step) {
+            return null;
+        }
+        const finished = {
+            ...step,
+            endedAt: step.endedAt ?? (options.now ?? new Date()).toISOString(),
+            otel: {
+                ...step.otel,
+                statusCode: step.otel.statusCode === 'unset'
+                    ? options.success
+                        ? 'ok'
+                        : 'error'
+                    : step.otel.statusCode,
+                ...(step.otel.statusMessage
+                    ? { statusMessage: step.otel.statusMessage }
+                    : options.reason
+                        ? { statusMessage: options.reason }
+                        : {}),
+            },
+            outputSummary: step.outputSummary ?? {
+                success: options.success,
+                ...(options.outcomeType ? { outcomeType: options.outcomeType } : {}),
+                ...(options.message ? { message: options.message } : {}),
+                ...(options.reason ? { reason: options.reason } : {}),
+            },
+            artifactManifestId: step.artifactManifestId ?? options.artifactManifestId,
+        };
+        saveStepRecord(finished);
+        return finished;
+    });
+}
+export function appendStepChildSpan(options) {
+    return withRunLock(options.runId, () => {
+        const step = loadStepRecord(options.runId, options.stepId);
+        if (!step) {
+            return null;
+        }
+        const childSpan = {
+            spanId: randomHex(8),
+            parentSpanId: step.otel.spanId,
+            name: options.name,
+            kind: options.kind ?? 'client',
+            startedAt: options.startedAt,
+            endedAt: options.endedAt,
+            statusCode: options.statusCode,
+            ...(options.statusMessage ? { statusMessage: options.statusMessage } : {}),
+            attributes: { ...(options.attributes ?? {}) },
+        };
+        const nextStep = {
+            ...step,
+            childSpanIds: [...(step.childSpanIds ?? []), childSpan.spanId],
+            childSpans: [...(step.childSpans ?? []), childSpan],
+        };
+        saveStepRecord(nextStep);
+        return childSpan;
+    });
+}
+export function finishRunRecord(runId, options) {
+    return withRunLock(runId, () => {
+        const existing = loadRunRecord(runId);
+        if (!existing) {
+            return null;
+        }
+        const record = {
+            ...existing,
+            status: existing.endedAt ? existing.status : options.status,
+            endedAt: existing.endedAt ?? (options.now ?? new Date()).toISOString(),
+            finalOutcome: existing.finalOutcome ?? options.finalOutcome,
+        };
+        saveRunRecord(record);
+        return record;
+    });
+}
+export function setRunIngestState(runId, ingestState) {
+    return withRunLock(runId, () => {
+        const existing = loadRunRecord(runId);
+        if (!existing) {
+            return null;
+        }
+        if (existing.ingestState === ingestState) {
+            return existing;
+        }
+        const record = {
+            ...existing,
+            ingestState,
+        };
+        saveRunRecord(record);
+        return record;
+    });
+}
+export function pruneLocalRuns(options = {}) {
+    const now = options.now ?? new Date();
+    const retentionDays = options.retentionDays ?? DEFAULT_RUN_RETENTION_DAYS;
+    const cutoffMs = now.getTime() - retentionDays * 24 * 60 * 60 * 1000;
+    const runsDir = getRunsDir();
+    if (!existsSync(runsDir)) {
+        return {
+            deletedRunIds: [],
+            keptRunIds: [],
+            failedRunIds: [],
+        };
+    }
+    const deletedRunIds = [];
+    const keptRunIds = [];
+    const failedRunIds = [];
+    for (const entry of readdirSync(runsDir, { withFileTypes: true })) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const runId = entry.name;
+        if (runId === RUN_LOCK_DIRNAME) {
+            continue;
+        }
+        if (runId === options.activeRunId) {
+            keptRunIds.push(runId);
+            continue;
+        }
+        const runDir = getRunDir(runId);
+        if (existsSync(getRunLockDir(runId))) {
+            keptRunIds.push(runId);
+            continue;
+        }
+        const record = loadRunRecord(runId);
+        const fallbackMtimeMs = statSync(runDir).mtimeMs;
+        const referenceTimeMs = parseTimestamp(record?.endedAt) ??
+            parseTimestamp(record?.startedAt) ??
+            (Number.isFinite(fallbackMtimeMs) ? fallbackMtimeMs : null);
+        const isPrunableRecord = !record || isTerminalStatus(record.status);
+        if (!isPrunableRecord || referenceTimeMs === null || referenceTimeMs > cutoffMs) {
+            keptRunIds.push(runId);
+            continue;
+        }
+        try {
+            rmSync(runDir, { recursive: true, force: true });
+            deletedRunIds.push(runId);
+        }
+        catch (error) {
+            failedRunIds.push({
+                runId,
+                reason: formatUnknownError(error),
+            });
+            keptRunIds.push(runId);
+        }
+    }
+    return {
+        deletedRunIds,
+        keptRunIds,
+        failedRunIds,
+    };
+}
+export function deleteLocalRun(runId) {
+    const runDir = getRunDir(runId);
+    if (!existsSync(runDir)) {
+        return false;
+    }
+    rmSync(runDir, { recursive: true, force: true });
+    return true;
+}

package/dist/runtime-metrics.d.ts

@@ -0,0 +1,27 @@
+import type { BrowseSession } from './session.js';
+import { type BrowsePayloadBudgetMetrics, type BrowseRuntimeMetrics } from './runtime-state.js';
+type NumericBrowseRuntimeMetricKey = Exclude<{
+    [K in keyof BrowseRuntimeMetrics]: BrowseRuntimeMetrics[K] extends number | undefined ? K : never;
+}[keyof BrowseRuntimeMetrics], undefined>;
+type LlmUsageLike = Partial<{
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+    cached_input_tokens: number;
+    reasoning_tokens: number;
+}>;
+export declare function incrementMetric(session: BrowseSession, metric: NumericBrowseRuntimeMetricKey, by?: number): number;
+export declare function recordActionResult(session: BrowseSession, success: boolean, durationMs: number): BrowseRuntimeMetrics;
+export declare function recordLlmUsage(session: BrowseSession, params: {
+    purpose: string;
+    usage?: LlmUsageLike | null;
+    inputChars?: number;
+    promptTokens?: number;
+    completionTokens?: number;
+    totalTokens?: number;
+    cachedInputTokens?: number;
+    reasoningTokens?: number;
+}): BrowseRuntimeMetrics;
+export declare function recordPayloadBudget(session: BrowseSession, patch: Partial<BrowsePayloadBudgetMetrics>): BrowseRuntimeMetrics;
+export {};
+//# sourceMappingURL=runtime-metrics.d.ts.map

package/dist/runtime-metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-metrics.d.ts","sourceRoot":"","sources":["../src/runtime-metrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAKL,KAAK,0BAA0B,EAC/B,KAAK,oBAAoB,EAC1B,MAAM,oBAAoB,CAAC;AAE5B,KAAK,6BAA6B,GAAG,OAAO,CAC1C;KACG,CAAC,IAAI,MAAM,oBAAoB,GAAG,oBAAoB,CAAC,CAAC,CAAC,SAAS,MAAM,GAAG,SAAS,GACjF,CAAC,GACD,KAAK;CACV,CAAC,MAAM,oBAAoB,CAAC,EAC7B,SAAS,CACV,CAAC;AAEF,KAAK,YAAY,GAAG,OAAO,CAAC;IAC1B,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,gBAAgB,EAAE,MAAM,CAAC;CAC1B,CAAC,CAAC;AAEH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,6BAA6B,EACrC,EAAE,SAAI,GACL,MAAM,CAIR;AAED,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,MAAM,GACjB,oBAAoB,CAetB;AAED,wBAAgB,cAAc,CAC5B,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE;IACN,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,GACA,oBAAoB,CAmCtB;AAED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,aAAa,EACtB,KAAK,EAAE,OAAO,CAAC,0BAA0B,CAAC,GACzC,oBAAoB,CAgBtB"}