@nuanu-ai/agentbrowse 0.2.47 → 0.2.49

package/dist/commands/semantic-observe.js

@@ -1,7 +1,8 @@
+import { createHash } from 'node:crypto';
 import { z } from 'zod';
 import { AgentpayStagehandLlmClient } from '../agentpay-stagehand-llm.js';
 import { resolveAgentpayGatewayConfig } from '../agentpay-gateway.js';
-import { recordLlmUsage, recordPayloadBudget } from '../runtime-state.js';
+import { recordLlmUsage, recordPayloadBudget } from '../runtime-metrics.js';
 import { analyzeSemanticObserveText, buildSemanticObserveBm25CorpusStats, buildSemanticObserveLexicalDocument, normalizeSemanticObserveText, scoreSemanticObserveBm25, } from './semantic-observe-lexical.js';
 const rerankSchema = z.object({
     matches: z
@@ -55,6 +56,12 @@ const HIGH_SIGNAL_SCOPE_KINDS = new Set([
     'card',
     'form',
 ]);
+const SEMANTIC_OBSERVE_SNAPSHOT_CACHE_VERSION = 1;
+const SEMANTIC_OBSERVE_SNAPSHOT_CACHE_KEY_VERSION = 'semantic-observe-snapshot-v1';
+const SEMANTIC_OBSERVE_GOAL_CACHE_KEY_VERSION = 'semantic-observe-goal-v1';
+const SEMANTIC_OBSERVE_MAX_SNAPSHOT_CACHE_ENTRIES = 4;
+const SEMANTIC_OBSERVE_MAX_GOAL_SHORTLISTS_PER_SNAPSHOT = 6;
+const semanticObserveSnapshotCacheBySession = new WeakMap();
 function isFieldLikeTarget(target) {
     const kind = (target.kind ?? '').trim().toLowerCase();
     const role = (target.role ?? '').trim().toLowerCase();
@@ -135,12 +142,31 @@ function isPrimaryFormControlTarget(target) {
         acceptancePolicy === 'disclosure' &&
         (kind === 'button' || role === 'button'));
 }
+function isConcreteFormChoiceTarget(target) {
+    if (!Boolean(formBucketKey(target)) ||
+        isScopeLikeCandidate(target) ||
+        isFieldLikeTarget(target) ||
+        !isActionLikeTargetCandidate(target) ||
+        isPrimaryFormControlTarget(target)) {
+        return false;
+    }
+    const acceptancePolicy = (target.acceptancePolicy ?? '').trim().toLowerCase();
+    const controlFamily = (target.controlFamily ?? '').trim().toLowerCase();
+    const surfaceKind = (target.surfaceKind ?? '').trim().toLowerCase();
+    const hasGoalIdentity = Boolean(goalLabelOf(target));
+    if (!hasGoalIdentity) {
+        return false;
+    }
+    return (controlFamily === 'trigger' ||
+        acceptancePolicy === 'selection' ||
+        ['listbox', 'menu', 'dropdown', 'popover'].includes(surfaceKind));
+}
 function shouldPreserveStandaloneFormActionEntity(target) {
     return (Boolean(formBucketKey(target)) &&
         !isScopeLikeCandidate(target) &&
         !isFieldLikeTarget(target) &&
         isActionLikeTargetCandidate(target) &&
-        isPrimaryFormControlTarget(target));
+        (isPrimaryFormControlTarget(target) || isConcreteFormChoiceTarget(target)));
 }
 function primaryFormTargetPriority(target) {
     const acceptancePolicy = (target.acceptancePolicy ?? '').trim().toLowerCase();
@@ -190,6 +216,322 @@ function contentItemBucketKey(target) {
     }
     return undefined;
 }
+function cachedContextNodeValue(node) {
+    if (!node) {
+        return undefined;
+    }
+    return {
+        ...(node.kind ? { kind: node.kind } : {}),
+        ...(node.label ? { label: node.label } : {}),
+        ...(node.text ? { text: node.text } : {}),
+    };
+}
+function cachedStateEntries(states) {
+    if (!states) {
+        return undefined;
+    }
+    const entries = Object.entries(states).sort(([left], [right]) => left.localeCompare(right));
+    return entries.length > 0 ? entries : undefined;
+}
+function cachedStructureValue(structure) {
+    if (!structure) {
+        return undefined;
+    }
+    return {
+        ...(structure.family ? { family: structure.family } : {}),
+        ...(structure.variant ? { variant: structure.variant } : {}),
+        ...(structure.row ? { row: structure.row } : {}),
+        ...(structure.column ? { column: structure.column } : {}),
+        ...(structure.zone ? { zone: structure.zone } : {}),
+        ...(structure.cellLabel ? { cellLabel: structure.cellLabel } : {}),
+    };
+}
+function normalizeGoalIdentityValue(value, maxLength = 180) {
+    const normalized = value?.replace(/\s+/g, ' ').trim();
+    if (!normalized) {
+        return undefined;
+    }
+    return normalized.length > maxLength ? `${normalized.slice(0, maxLength - 1)}…` : normalized;
+}
+function appendGoalIdentityAlias(values, value) {
+    const normalized = normalizeGoalIdentityValue(value);
+    if (!normalized) {
+        return;
+    }
+    const normalizedKey = normalized.toLowerCase();
+    if (values.some((existing) => existing.toLowerCase() === normalizedKey)) {
+        return;
+    }
+    values.push(normalized);
+}
+function goalIdentityValuesOf(target) {
+    const values = [];
+    appendGoalIdentityAlias(values, target.goalLabel);
+    for (const value of target.goalAliases ?? []) {
+        appendGoalIdentityAlias(values, value);
+    }
+    if (values.length > 0) {
+        return values;
+    }
+    if (isFieldLikeTarget(target)) {
+        appendGoalIdentityAlias(values, target.label);
+        appendGoalIdentityAlias(values, target.displayLabel);
+        appendGoalIdentityAlias(values, target.placeholder);
+        appendGoalIdentityAlias(values, target.title);
+        return values;
+    }
+    appendGoalIdentityAlias(values, target.label);
+    appendGoalIdentityAlias(values, target.displayLabel);
+    appendGoalIdentityAlias(values, target.text);
+    appendGoalIdentityAlias(values, target.title);
+    return values;
+}
+function goalLabelOf(target) {
+    return goalIdentityValuesOf(target)[0];
+}
+function goalAliasesOf(target) {
+    return goalIdentityValuesOf(target).slice(1, 5);
+}
+function serializeObserveSnapshotTarget(target) {
+    const itemContext = cachedContextNodeValue(target.context?.item);
+    const groupContext = cachedContextNodeValue(target.context?.group);
+    const containerContext = cachedContextNodeValue(target.context?.container);
+    const landmarkContext = cachedContextNodeValue(target.context?.landmark);
+    const stateEntries = cachedStateEntries(target.states);
+    const structure = cachedStructureValue(target.structure);
+    const goalLabel = goalLabelOf(target);
+    const goalAliases = goalAliasesOf(target);
+    return {
+        goalInventoryType: target.goalInventoryType,
+        ...(target.goalInventoryType === 'scope' && target.goalSurfaceId
+            ? { goalSurfaceId: target.goalSurfaceId }
+            : {}),
+        ...(goalLabel ? { goalLabel } : {}),
+        ...(goalAliases.length ? { goalAliases } : {}),
+        ...(target.kind ? { kind: target.kind } : {}),
+        ...(target.label ? { label: target.label } : {}),
+        ...(target.displayLabel ? { displayLabel: target.displayLabel } : {}),
+        ...(target.role ? { role: target.role } : {}),
+        ...(target.interactionHint ? { interactionHint: target.interactionHint } : {}),
+        ...(target.text ? { text: target.text } : {}),
+        ...(target.placeholder ? { placeholder: target.placeholder } : {}),
+        ...(target.title ? { title: target.title } : {}),
+        ...(target.capability ? { capability: target.capability } : {}),
+        ...(target.allowedActions?.length
+            ? { allowedActions: [...target.allowedActions].sort() }
+            : {}),
+        ...(target.acceptancePolicy ? { acceptancePolicy: target.acceptancePolicy } : {}),
+        ...(target.controlFamily ? { controlFamily: target.controlFamily } : {}),
+        ...(target.surfaceRef ? { surfaceRef: target.surfaceRef } : {}),
+        ...(target.surfaceKind ? { surfaceKind: target.surfaceKind } : {}),
+        ...(target.surfaceLabel ? { surfaceLabel: target.surfaceLabel } : {}),
+        ...(typeof target.surfacePriority === 'number' ? { surfacePriority: target.surfacePriority } : {}),
+        ...(target.framePath?.length ? { framePath: [...target.framePath] } : {}),
+        ...(target.frameUrl ? { frameUrl: target.frameUrl } : {}),
+        ...(target.formSelector ? { formSelector: target.formSelector } : {}),
+        ...(target.pageSignature ? { pageSignature: target.pageSignature } : {}),
+        ...(target.controlsSurfaceSelector
+            ? { controlsSurfaceSelector: target.controlsSurfaceSelector }
+            : {}),
+        ...(stateEntries ? { states: stateEntries } : {}),
+        ...(target.context
+            ? {
+                context: {
+                    ...(itemContext ? { item: itemContext } : {}),
+                    ...(groupContext ? { group: groupContext } : {}),
+                    ...(containerContext ? { container: containerContext } : {}),
+                    ...(landmarkContext ? { landmark: landmarkContext } : {}),
+                    ...(target.context.hintText ? { hintText: target.context.hintText } : {}),
+                },
+            }
+            : {}),
+        ...(structure ? { structure } : {}),
+    };
+}
+function semanticObserveSnapshotKey(targets) {
+    const payload = JSON.stringify(targets.map((target) => serializeObserveSnapshotTarget(target)));
+    return createHash('sha256')
+        .update(SEMANTIC_OBSERVE_SNAPSHOT_CACHE_KEY_VERSION)
+        .update(payload)
+        .digest('hex');
+}
+function semanticObserveGoalKey(goal) {
+    return createHash('sha256')
+        .update(SEMANTIC_OBSERVE_GOAL_CACHE_KEY_VERSION)
+        .update(normalizedGoalText(goal))
+        .digest('hex');
+}
+function serializeLexicalDocument(lexicalDocument) {
+    return {
+        analyzerKey: lexicalDocument.analyzerKey,
+        weightedLength: lexicalDocument.weightedLength,
+        weightedTermFrequencies: [...lexicalDocument.weightedTermFrequencies.entries()],
+    };
+}
+function deserializeLexicalDocument(lexicalDocument) {
+    return {
+        analyzerKey: lexicalDocument.analyzerKey,
+        weightedLength: lexicalDocument.weightedLength,
+        weightedTermFrequencies: new Map(lexicalDocument.weightedTermFrequencies),
+    };
+}
+function ensureSemanticObserveSnapshotCache(session) {
+    const existing = semanticObserveSnapshotCacheBySession.get(session);
+    if (existing &&
+        existing.version === SEMANTIC_OBSERVE_SNAPSHOT_CACHE_VERSION &&
+        Array.isArray(existing.order) &&
+        existing.snapshotsByKey &&
+        typeof existing.snapshotsByKey === 'object') {
+        return existing;
+    }
+    const nextCache = {
+        version: SEMANTIC_OBSERVE_SNAPSHOT_CACHE_VERSION,
+        order: [],
+        snapshotsByKey: {},
+    };
+    semanticObserveSnapshotCacheBySession.set(session, nextCache);
+    return nextCache;
+}
+function touchSemanticObserveSnapshotCacheEntry(cache, snapshotKey) {
+    cache.order = [snapshotKey, ...cache.order.filter((key) => key !== snapshotKey)].slice(0, SEMANTIC_OBSERVE_MAX_SNAPSHOT_CACHE_ENTRIES);
+    for (const key of Object.keys(cache.snapshotsByKey)) {
+        if (!cache.order.includes(key)) {
+            delete cache.snapshotsByKey[key];
+        }
+    }
+}
+function materializeCachedRetrievalEntities(targets, cachedEntities) {
+    const materialized = [];
+    for (const cachedEntity of cachedEntities) {
+        const representative = targets[cachedEntity.representativeIndex];
+        if (!representative) {
+            return null;
+        }
+        if (cachedEntity.memberIndexes.some((index) => !targets[index])) {
+            return null;
+        }
+        materialized.push({
+            entityKind: cachedEntity.entityKind,
+            entityKey: cachedEntity.entityKey,
+            firstIndex: cachedEntity.firstIndex,
+            memberIndexes: [...cachedEntity.memberIndexes],
+            representative,
+            label: pickEntityLabel(cachedEntity.entityKind, representative),
+            kind: cachedEntity.entityKind === 'form'
+                ? 'form'
+                : cachedEntity.entityKind === 'item'
+                    ? (representative.surfaceKind ?? representative.kind)
+                    : representative.kind,
+            surfaceKind: representative.surfaceKind,
+            surfaceLabel: representative.surfaceLabel,
+            surfacePriority: representative.surfacePriority,
+            framePath: representative.framePath,
+            frameUrl: representative.frameUrl,
+            context: representative.context,
+            structure: representative.structure,
+            representativeLabels: [],
+            analyzerKey: cachedEntity.analyzerKey,
+            lexicalDocument: deserializeLexicalDocument(cachedEntity.lexicalDocument),
+        });
+    }
+    return materialized;
+}
+function loadCachedRetrievalEntities(session, snapshotKey, targets) {
+    if (!session) {
+        return null;
+    }
+    const cache = ensureSemanticObserveSnapshotCache(session);
+    const entry = cache.snapshotsByKey[snapshotKey];
+    if (!entry || entry.targetCount !== targets.length || !entry.retrievalEntities) {
+        return null;
+    }
+    const materialized = materializeCachedRetrievalEntities(targets, entry.retrievalEntities);
+    if (!materialized) {
+        delete cache.snapshotsByKey[snapshotKey];
+        cache.order = cache.order.filter((key) => key !== snapshotKey);
+        return null;
+    }
+    touchSemanticObserveSnapshotCacheEntry(cache, snapshotKey);
+    return materialized;
+}
+function saveCachedRetrievalEntities(session, snapshotKey, targets, entities) {
+    if (!session) {
+        return;
+    }
+    const cache = ensureSemanticObserveSnapshotCache(session);
+    const indexByTarget = new Map(targets.map((target, index) => [target, index]));
+    const existingEntry = cache.snapshotsByKey[snapshotKey];
+    cache.snapshotsByKey[snapshotKey] = {
+        snapshotKey,
+        targetCount: targets.length,
+        cachedAt: new Date().toISOString(),
+        retrievalEntities: entities.map((entity) => ({
+            entityKind: entity.entityKind,
+            entityKey: entity.entityKey,
+            firstIndex: entity.firstIndex,
+            representativeIndex: indexByTarget.get(entity.representative) ?? entity.firstIndex,
+            memberIndexes: [...entity.memberIndexes],
+            analyzerKey: entity.analyzerKey,
+            lexicalDocument: serializeLexicalDocument(entity.lexicalDocument),
+        })),
+        goalShortlists: existingEntry?.goalShortlists ?? {},
+        goalOrder: existingEntry?.goalOrder ?? [],
+    };
+    touchSemanticObserveSnapshotCacheEntry(cache, snapshotKey);
+}
+function loadCachedGoalShortlist(session, snapshotKey, goalKey, targets) {
+    if (!session || !goalKey) {
+        return null;
+    }
+    const cache = ensureSemanticObserveSnapshotCache(session);
+    const entry = cache.snapshotsByKey[snapshotKey];
+    const shortlist = entry?.goalShortlists?.[goalKey];
+    if (!entry || entry.targetCount !== targets.length || !shortlist) {
+        return null;
+    }
+    const candidates = shortlist.candidateIndexes.map((index) => targets[index]).filter(Boolean);
+    if (candidates.length !== shortlist.candidateIndexes.length) {
+        delete entry.goalShortlists?.[goalKey];
+        entry.goalOrder = (entry.goalOrder ?? []).filter((key) => key !== goalKey);
+        return null;
+    }
+    entry.goalOrder = [goalKey, ...(entry.goalOrder ?? []).filter((key) => key !== goalKey)].slice(0, SEMANTIC_OBSERVE_MAX_GOAL_SHORTLISTS_PER_SNAPSHOT);
+    touchSemanticObserveSnapshotCacheEntry(cache, snapshotKey);
+    return candidates;
+}
+function saveCachedGoalShortlist(session, snapshotKey, goalKey, targets, shortlist) {
+    if (!session || !goalKey) {
+        return;
+    }
+    const cache = ensureSemanticObserveSnapshotCache(session);
+    const existingEntry = cache.snapshotsByKey[snapshotKey];
+    const entry = existingEntry ?? {
+        snapshotKey,
+        targetCount: targets.length,
+        cachedAt: new Date().toISOString(),
+        goalShortlists: {},
+        goalOrder: [],
+    };
+    const indexByTarget = new Map(targets.map((target, index) => [target, index]));
+    entry.targetCount = targets.length;
+    entry.cachedAt = new Date().toISOString();
+    entry.goalShortlists ??= {};
+    entry.goalOrder = [goalKey, ...(entry.goalOrder ?? []).filter((key) => key !== goalKey)].slice(0, SEMANTIC_OBSERVE_MAX_GOAL_SHORTLISTS_PER_SNAPSHOT);
+    entry.goalShortlists[goalKey] = {
+        goalKey,
+        candidateIndexes: shortlist
+            .map((candidate) => indexByTarget.get(candidate))
+            .filter((index) => index !== undefined),
+        cachedAt: entry.cachedAt,
+    };
+    for (const cachedGoalKey of Object.keys(entry.goalShortlists)) {
+        if (!entry.goalOrder.includes(cachedGoalKey)) {
+            delete entry.goalShortlists[cachedGoalKey];
+        }
+    }
+    cache.snapshotsByKey[snapshotKey] = entry;
+    touchSemanticObserveSnapshotCacheEntry(cache, snapshotKey);
+}
 function scopeCandidatePriority(target) {
     const kind = (target.kind ?? '').trim().toLowerCase();
     if (kind === 'dialog' || kind === 'listbox' || kind === 'menu') {
@@ -276,7 +618,7 @@ function pickEntityLabel(entityKind, representative) {
             representative.surfaceLabel ??
             representative.label);
     }
-    return (representative.label ??
+    return (goalLabelOf(representative) ??
         representative.context?.container?.label ??
         representative.context?.item?.label ??
         representative.surfaceLabel ??
@@ -286,13 +628,14 @@ function pickEntityLabel(entityKind, representative) {
 function collectRepresentativeLabels(targets) {
     const labels = [];
     for (const target of targets) {
-        const label = target.label?.replace(/\s+/g, ' ').trim();
-        if (!label || label === 'Button' || label === 'Link' || labels.includes(label)) {
-            continue;
-        }
-        labels.push(label);
-        if (labels.length >= 4) {
-            break;
+        for (const label of [goalLabelOf(target), ...goalAliasesOf(target)]) {
+            if (!label || label === 'Button' || label === 'Link' || labels.includes(label)) {
+                continue;
+            }
+            labels.push(label);
+            if (labels.length >= 4) {
+                return labels;
+            }
         }
     }
     return labels;
@@ -368,9 +711,10 @@ function latentActionHintText(target) {
     return hints.size > 0 ? [...hints].join(' ') : undefined;
 }
 function buildEntityLexicalFields(entityLabel, representative, representativeLabels) {
+    const representativeGoalLabel = goalLabelOf(representative);
     return [
         { value: entityLabel, weight: RETRIEVAL_FIELD_WEIGHTS.entityLabel },
-        { value: representative.label, weight: RETRIEVAL_FIELD_WEIGHTS.representativeLabel },
+        { value: representativeGoalLabel, weight: RETRIEVAL_FIELD_WEIGHTS.representativeLabel },
         ...representativeLabels.map((value) => ({
             value,
             weight: RETRIEVAL_FIELD_WEIGHTS.representativeLabels,
@@ -857,6 +1201,8 @@ function buildSurfaceSummaries(targets) {
 function buildCompactCandidateSummary(target, index, surfaceSummaryIdBySurfaceKey) {
     const parts = [`id=c${index + 1}`];
     const compactContext = compactCandidateContext(target);
+    const goalLabel = goalLabelOf(target);
+    const goalAliases = goalAliasesOf(target).map((value) => compactContextValue(value, 120) ?? value);
     const surfaceSummaryId = surfaceIdentityOf(target)
         ? surfaceSummaryIdBySurfaceKey?.get(surfaceIdentityOf(target))
         : undefined;
@@ -864,8 +1210,10 @@ function buildCompactCandidateSummary(target, index, surfaceSummaryIdBySurfaceKe
         parts.push(`kind=${JSON.stringify(target.kind)}`);
     if (target.role)
         parts.push(`role=${JSON.stringify(target.role)}`);
-    if (target.label)
-        parts.push(`label=${JSON.stringify(target.label)}`);
+    if (goalLabel)
+        parts.push(`label=${JSON.stringify(goalLabel)}`);
+    if (goalAliases.length)
+        parts.push(`aliases=${JSON.stringify(goalAliases)}`);
     if (target.allowedActions?.length) {
         parts.push(`actions=${JSON.stringify(target.allowedActions)}`);
     }
@@ -910,11 +1258,34 @@ export async function rerankDomTargetsForGoal(instruction, targets, options = {}
         });
     const gateway = resolveAgentpayGatewayConfig();
     const client = new AgentpayStagehandLlmClient(gateway);
-    const retrievalEntities = buildGoalRetrievalEntities(relevantTargets);
-    const retrievedCandidates = relevantTargets.length > RERANK_CANDIDATE_LIMIT
-        ? expandRetrievalEntitiesToCandidates(relevantTargets, preselectRetrievalEntities(instruction, retrievalEntities))
-        : [...relevantTargets];
+    const snapshotKey = options.session ? semanticObserveSnapshotKey(relevantTargets) : undefined;
+    const goalKey = snapshotKey ? semanticObserveGoalKey(instruction) : undefined;
+    const cachedCandidates = snapshotKey && goalKey
+        ? loadCachedGoalShortlist(options.session, snapshotKey, goalKey, relevantTargets)
+        : null;
+    let retrievedCandidates;
+    if (cachedCandidates) {
+        retrievedCandidates = cachedCandidates;
+    }
+    else if (relevantTargets.length > RERANK_CANDIDATE_LIMIT) {
+        let retrievalEntities = snapshotKey
+            ? loadCachedRetrievalEntities(options.session, snapshotKey, relevantTargets)
+            : null;
+        if (!retrievalEntities) {
+            retrievalEntities = buildGoalRetrievalEntities(relevantTargets);
+            if (snapshotKey) {
+                saveCachedRetrievalEntities(options.session, snapshotKey, relevantTargets, retrievalEntities);
+            }
+        }
+        retrievedCandidates = expandRetrievalEntitiesToCandidates(relevantTargets, preselectRetrievalEntities(instruction, retrievalEntities));
+    }
+    else {
+        retrievedCandidates = [...relevantTargets];
+    }
     const candidates = diversifyCandidates(retrievedCandidates.length > 0 ? retrievedCandidates : [...relevantTargets]);
+    if (!cachedCandidates && snapshotKey && goalKey) {
+        saveCachedGoalShortlist(options.session, snapshotKey, goalKey, relevantTargets, candidates);
+    }
     const { summaries: surfaceSummaries, summaryIdBySurfaceKey } = buildSurfaceSummaries(candidates);
     options.session &&
         recordPayloadBudget(options.session, {

package/dist/commands/start-session.d.ts

@@ -0,0 +1,31 @@
+/**
+ * browse start-session — Start the workflow/run context on top of an existing browser session.
+ */
+export type StartSessionSuccessResult = {
+    success: true;
+    runId: string;
+    startedAt: string;
+    browserSessionId: string;
+    intentSessionId: string;
+    lastEventSeq: number;
+    status: string;
+    currentRequestId: string | null;
+    replacedPreviousRun: boolean;
+    profile?: string;
+    pageRef?: string;
+    url?: string;
+    title?: string;
+};
+export type StartSessionFailureResult = {
+    success: false;
+    error: 'browser_session_unavailable' | 'backend_session_start_failed' | 'workflow_session_unavailable' | 'workflow_run_unavailable' | 'workflow_step_unavailable' | 'workflow_session_complete_failed';
+    outcomeType: 'blocked' | 'failed';
+    message: 'Session start failed.';
+    reason: string;
+};
+export type StartSessionResult = StartSessionSuccessResult | StartSessionFailureResult;
+export interface StartSessionOptions {
+    merchantName?: string;
+}
+export declare function startSession(requestedName?: string, options?: StartSessionOptions): Promise<StartSessionResult>;
+//# sourceMappingURL=start-session.d.ts.map

package/dist/commands/start-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"start-session.d.ts","sourceRoot":"","sources":["../../src/commands/start-session.ts"],"names":[],"mappings":"AAAA;;GAEG;AAyBH,MAAM,MAAM,yBAAyB,GAAG;IACtC,OAAO,EAAE,IAAI,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;IACzB,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,mBAAmB,EAAE,OAAO,CAAC;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,OAAO,EAAE,KAAK,CAAC;IACf,KAAK,EACD,6BAA6B,GAC7B,8BAA8B,GAC9B,8BAA8B,GAC9B,0BAA0B,GAC1B,2BAA2B,GAC3B,kCAAkC,CAAC;IACvC,WAAW,EAAE,SAAS,GAAG,QAAQ,CAAC;IAClC,OAAO,EAAE,uBAAuB,CAAC;IACjC,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,yBAAyB,GAAG,yBAAyB,CAAC;AAIvF,MAAM,WAAW,mBAAmB;IAClC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAgLD,wBAAsB,YAAY,CAChC,aAAa,CAAC,EAAE,MAAM,EACtB,OAAO,GAAE,mBAAwB,GAChC,OAAO,CAAC,kBAAkB,CAAC,CA4N7B"}