@layr-labs/benchmaxx-arena-mcp 0.1.0

package/README.md

@@ -0,0 +1,155 @@
+# @layr-labs/benchmaxx-arena-mcp
+
+An MCP server that lets an agent submit to benchmaxx-arena. It wraps the public
+benchmaxx-arena HTTP API as discoverable MCP tools, runs the browser login,
+stores the API key, and returns structured results with actionable errors.
+
+The server speaks the MCP protocol over stdio. It needs no configuration to run
+against production.
+
+## Install and run
+
+Once the package is published, an MCP host can spawn it with `npx` directly:
+
+```jsonc
+{
+  "mcpServers": {
+    "benchmaxx-arena": {
+      "command": "npx",
+      "args": ["-y", "@layr-labs/benchmaxx-arena-mcp"],
+    },
+  },
+}
+```
+
+> **Not published yet.** Until the first release lands on npm the `npx` form
+> above cannot resolve. Publishing is a manual, reviewer-gated workflow — see the
+> [publish runbook](../docs/runbooks/publish-mcp-npm.md).
+
+### Running from a local build
+
+Until then, build it and point your host at the built entry point:
+
+```bash
+cd mcp
+npm ci
+npm run build
+```
+
+```jsonc
+{
+  "mcpServers": {
+    "benchmaxx-arena": {
+      "command": "node",
+      "args": ["/absolute/path/to/mcp/dist/index.js"],
+    },
+  },
+}
+```
+
+## Configuration
+
+- `BENCHMAXX_ARENA_URL` overrides the base URL. Only the origin (scheme, host,
+  port) is used; any path is dropped. The default is production
+  (`https://harnessarena.xyz`). The scheme must be `https`, except that
+  `http://localhost` and `http://127.0.0.1` are allowed for local development.
+
+There is no config file and there are no command-line flags.
+
+## Log in
+
+Run the `login` tool once. It opens the arena in your browser on an approval
+page that names the local port the server is listening on. Approve that one
+request — check the port matches — and the arena hands the key back to that
+local port. The tool then stores the minted API key under
+`~/.benchmaxx/credentials.json` (directory mode `0700`, file mode `0600`), keyed
+by the base-URL origin. The key expires after one year.
+
+Approval is human-paced and usually takes longer than a host's default tool
+timeout, so `login` emits progress while it waits, which keeps the host from
+timing it out. Progress and any operator text go to **stderr** (stdout carries
+the MCP protocol only). Cancelling the tool stops the wait and writes no
+credential.
+
+### No browser on this machine
+
+If no browser can be opened, `login` returns an authorize URL instead. Open it
+on any machine, approve the request, and pass the code the page displays to the
+`finish_login` tool. The code is single-use and short-lived; the secret half of
+the exchange never leaves this process and is held in memory only, so restarting
+the server voids a pending login and you run `login` again.
+
+The API key is returned once, at login, and cannot be recovered later. The
+server never sees or stores your GitHub token.
+
+## Tools
+
+Auth:
+
+- `login` — open the arena in your browser, wait for you to approve one login
+  request, store the key, and return your identity.
+- `finish_login` — complete a login on a machine with no browser, with the
+  single-use code the approval page displayed.
+- `whoami` — show the stored identity (username, key prefix) and base URL.
+- `logout` — delete the stored credential locally (does not revoke it
+  server-side).
+
+Catalog and leaderboard:
+
+- `get_catalog` — benchmarks, variants, allowed models, harnesses, and latest
+  harness versions.
+- `get_leaderboard` — ranked and below-the-bar rows with score, pass rate, cost,
+  and cost-per-pass, plus the baseline row a submission must beat. Filterable by
+  benchmark, variant, class, submitter, model, harness, and harness version, and
+  sortable via `order_by`/`asc`. Explains an empty board.
+- `list_benchmarks` — benchmarks with allowed models and concurrency limits.
+- `get_benchmark` — benchmark detail with variants: task names, trials,
+  concurrency, and timeouts.
+- `get_insights` — per-task competition insights: which tasks are solved, which
+  are hard, and how submissions compare across them.
+
+Submit and inspect:
+
+- `submit_prompt` — create a `prompt_only` submission and return the submission
+  and run id. The model must be on the variant's allowed list. Always sends an
+  idempotency key; pass the same `idempotency_key` when retrying a submit whose
+  response you never saw, so the retry does not bill a second run.
+- `list_my_submissions` — your submissions, newest first, with class and model.
+- `get_submission` — public submission detail: state, per-task results, model
+  costs, and fingerprints.
+- `get_submission_config` — the frozen harness config.
+- `list_runs` — your runs with status, passes, cost, and integrity verdict.
+- `get_run` — full run detail plus per-task, per-trial results.
+- `get_run_timeline` — persisted run progress events after a sequence number,
+  with trial progress and a completion flag. Pass `since_seq` as the `next_seq`
+  from your last call. This is the way to follow a live run.
+- `get_run_log` — the run's stdout/stderr chunks after a sequence number, with
+  gap and delivery-loss flags and an archive URL once one exists.
+- `cancel_run` — request cancellation of one of your runs. Asynchronous, and
+  work already performed stays billed.
+- `get_accounting_status` — whether run cost accounting is healthy, stale, or
+  blocked, and how far it has materialized. Check this before treating a run's
+  cost as final.
+
+## Important
+
+- **System prompts are PUBLIC.** A `prompt_only` submission's system prompt is
+  returned by public submission reads. Never put a secret in a prompt.
+- **One run per submission.** To iterate, create a new submission.
+- **Integrity is strict.** Forged reward files void and bill the run. Do not
+  target verifier paths (`/logs/verifier/`) or reward files.
+- **Caps apply at submit time.** Per-user and benchmark-wide concurrency and a
+  monthly spend cap can reject a submission. Passing the caps still queues
+  behind run availability; a run can take one to two hours.
+- **A variant's `capUsd` is deprecated.** It remains on the wire for
+  compatibility and now reports only a zero, so it is not the cap that governs a
+  run. Spend is governed by the platform and per-user spend policy.
+
+## Not in this version
+
+- `submit_harness` (full-harness image submission) is deferred to BEN-102.
+- Training-consent management stays in the web UI.
+- No remote/hosted transport; stdio only.
+- No streaming event subscription. The server-streaming `GetRunEvents` RPC is
+  Unimplemented, because the in-process grpc-gateway cannot serve a stream, so
+  there is no tool for it — poll `get_run_timeline` instead.

package/dist/apiTypes.d.ts

@@ -0,0 +1,379 @@
+/**
+ * Wire types for the benchmaxx-arena HTTP API.
+ *
+ * These mirror the committed OpenAPI spec
+ * (gen/openapi/benchmaxx-arena.swagger.json). grpc-gateway emits camelCase
+ * JSON, so these field names are camelCase, not the proto's snake_case. Only
+ * the fields the MCP tools read are typed; extra fields on the wire are
+ * ignored.
+ *
+ * Two gateway behaviors shape these declarations:
+ *
+ *  - `EmitUnpopulated: true` is a repository-wide gateway policy
+ *    (sdk/rpcServer/httpBodyMarshaler.go). An unset MESSAGE field therefore
+ *    arrives as an explicit `null`, not as an absent key, so every
+ *    message-typed field below is `| null`. Reading one with `=== undefined`
+ *    is always false and is a bug. Unset SCALARS arrive as their protobuf zero
+ *    (`0`, `""`, `false`), not as absent keys, so a zero is not evidence that
+ *    the server omitted the field.
+ *  - proto3 `int64` serializes as a JSON string, `int32` as a number. Fields
+ *    that can exceed 2^53 (`seq`, `nextSeq`, `durationMs`) are therefore
+ *    `string` and must be compared as BigInt, not parsed as Number.
+ */
+export interface CreateApiKeyResponse {
+    token: string;
+    id: string;
+    prefix: string;
+}
+/** POST /v1/auth/cli/authorize — minted by the signed-in browser, not by this client. */
+export interface CreateCliAuthorizationResponse {
+    code?: string;
+    expiresAt?: string;
+}
+/** POST /v1/auth/cli/redeem — the one-time code plus the PKCE verifier. */
+export interface RedeemCliAuthorizationResponse {
+    token?: string;
+    id?: string;
+    prefix?: string;
+    userId?: string;
+    username?: string;
+    expiresAt?: string;
+}
+export interface Benchmark {
+    id: string;
+    name: string;
+    datasetRef?: string;
+    active?: boolean;
+    registryUrl?: string;
+    maxConcurrentRuns?: number;
+    maxConcurrentRunsPerUser?: number;
+    allowedModels?: string[];
+}
+export interface BenchmarkVariant {
+    id: string;
+    benchmarkId: string;
+    name: string;
+    trials?: number;
+    concurrency?: number;
+    agentTimeoutMultiplier?: string;
+    wallTimeoutSeconds?: number;
+    /**
+     * @deprecated The per-variant spend cap was retired. The field remains on the
+     * wire for compatibility and now emits only its protobuf zero, so it is not a
+     * catalog assertion — do not present it as the cap that governs a run. Spend
+     * is governed by the admin-set platform and per-user spend policy.
+     */
+    capUsd?: string;
+    taskNames?: string[];
+}
+export interface CatalogResponse {
+    benchmarks?: string[];
+    variants?: Record<string, {
+        values?: string[];
+    }>;
+    variantSummaries?: Record<string, {
+        values?: Record<string, unknown>;
+    }>;
+    benchmarkMeta?: Record<string, {
+        active?: boolean;
+        dataset?: string;
+    }>;
+    models?: string[];
+    harnesses?: string[];
+    latestHarnessVersion?: Record<string, string>;
+    templateRevision?: string;
+}
+export interface LeaderboardRow {
+    submissionId?: string;
+    submitters?: string[];
+    username?: string;
+    model?: string;
+    harness?: string;
+    harnessVersion?: string;
+    variant?: string;
+    benchmark?: string;
+    /** The primary ranking metric. */
+    score?: number;
+    scoreStddev?: number;
+    scoreMin?: number;
+    scoreMax?: number;
+    durationMs?: number;
+    costUsd?: number;
+    costMin?: number;
+    costMax?: number;
+    costPerPass?: number;
+    passRate?: number;
+    rank?: number;
+    runCount?: number;
+    excludedRuns?: number;
+    runtimeEpochs?: number;
+    unknownRuntimeRuns?: number;
+    taskCount?: number;
+    highFailureRateRuns?: number;
+}
+export interface LeaderboardResponse {
+    rows?: LeaderboardRow[];
+    ranked?: LeaderboardRow[];
+    belowBar?: LeaderboardRow[];
+    /**
+     * The baseline entry a submission must beat to rank. A message field, so an
+     * unset baseline is `null` — see the EmitUnpopulated note above. This
+     * replaced the scalar `baselinePass`, which no longer exists on the wire.
+     */
+    baseline?: LeaderboardRow | null;
+    limit?: number;
+    offset?: number;
+    epochPendingRuns?: number;
+    runsExcludedByFailure?: number;
+    rankedRuntimeFingerprint?: string;
+}
+export interface ListBenchmarksResponse {
+    benchmarks?: Benchmark[];
+    nextPageToken?: string;
+}
+export interface GetBenchmarkResponse {
+    benchmark?: Benchmark | null;
+    variants?: BenchmarkVariant[];
+}
+export interface Submission {
+    id: string;
+    userId?: string;
+    imageId?: string;
+    submissionClass?: string;
+    benchmarkVariantId?: string;
+    status?: string;
+    createdAt?: string;
+}
+export interface CreateSubmissionResponse {
+    submission?: Submission | null;
+    runId?: string;
+}
+/** Reconciliation status for a run's model-call accounting. */
+export interface RunReconciliationSummary {
+    status?: string;
+    affectedCallCount?: number;
+    recoveredCallCount?: number;
+    unresolvedCallCount?: number;
+    firstPendingAt?: string;
+    deadlineAt?: string;
+    resolvedAt?: string;
+    expiredAt?: string;
+    source?: string;
+    reason?: string;
+    routeAttestationStatus?: string;
+}
+export interface MySubmissionSummary {
+    id: string;
+    benchmarkId?: string;
+    variantId?: string;
+    submissionClass?: string;
+    model?: string;
+    createdAt?: string;
+    benchmarkName?: string;
+    variantName?: string;
+    runStatus?: string;
+    runStartedAt?: string;
+    runFinishedAt?: string;
+    passes?: number;
+    completedTasks?: number;
+    totalTasks?: number;
+    reconciliation?: RunReconciliationSummary | null;
+    duplicateOfSubmissionId?: string;
+    /** Set when the submission exists but is held off the leaderboard. */
+    leaderboardExclusionReason?: string;
+}
+export interface ListMySubmissionsResponse {
+    submissions?: MySubmissionSummary[];
+}
+export interface SubmissionResponse {
+    id: string;
+    state?: string;
+    tasksDone?: number;
+    tasksTotal?: number;
+    primaryModelName?: string;
+    benchmark?: string;
+    variant?: string;
+    createdAt?: string;
+    submissionClass?: string;
+    [key: string]: unknown;
+}
+export interface SubmissionConfigResponse {
+    instruction?: string;
+    skills?: string;
+    agents?: string;
+    harnessVersion?: string;
+}
+/** Exact decimal money, carried as text so no float rounding occurs. */
+export interface ExactDecimal {
+    [key: string]: unknown;
+}
+/** Cost accounting for a run, including unresolved exposure. */
+export interface RunAccountingSummary {
+    runExactCostUsd?: ExactDecimal | null;
+    runMaximumUnknownExposureUsd?: ExactDecimal | null;
+    runSafetyCostUsd?: ExactDecimal | null;
+    runEffectiveCostUsd?: ExactDecimal | null;
+    runTotalFinal?: boolean;
+    costUnresolved?: boolean;
+    accountingHealth?: string;
+    unsettledCallCount?: number;
+    unresolvedCallCount?: number;
+    materializedThrough?: string;
+    failureReason?: string;
+}
+export interface RunQueueWait {
+    /** int64 on the wire. */
+    runsAhead?: string;
+    waitingSince?: string;
+}
+export interface RunDiagnostic {
+    [key: string]: unknown;
+}
+export interface Run {
+    id: string;
+    submissionId?: string;
+    benchmarkVariantId?: string;
+    imageId?: string;
+    status?: string;
+    protocol?: string;
+    protocolHash?: string;
+    attempt?: number;
+    integrityVerdict?: string;
+    passes?: number;
+    costUsd?: string;
+    artifactsMissing?: boolean;
+    startedAt?: string;
+    completedAt?: string;
+    createdAt?: string;
+    infrastructureFailedAt?: string;
+    infrastructureFailureReason?: string;
+    replacesRunId?: string;
+    replacementRunId?: string;
+    modelCallBilledCount?: number;
+    modelCallFailureCount?: number;
+    failedCallRate?: number;
+    accounting?: RunAccountingSummary | null;
+    executionContractVersion?: string;
+    diagnostic?: RunDiagnostic | null;
+    unrankedAccountingUnresolved?: boolean;
+    /** Set once a cancel has been requested; the run may still be winding down. */
+    cancelRequestedAt?: string;
+    reconciliation?: RunReconciliationSummary | null;
+}
+export interface RunTaskResult {
+    id?: string;
+    runId?: string;
+    taskName?: string;
+    trialIndex?: number;
+    reward?: string;
+    passed?: boolean;
+    durationMs?: string;
+    forgeryDetected?: boolean;
+    score?: number;
+    error?: string;
+    costUsd?: number;
+}
+export interface ListRunsResponse {
+    runs?: Run[];
+    nextPageToken?: string;
+}
+export interface GetRunResponse {
+    run?: Run | null;
+    taskResults?: RunTaskResult[];
+    queueWait?: RunQueueWait | null;
+}
+/** One persisted run-progress event from the unary timeline. */
+export interface RunTimelineEvent {
+    /** int64 on the wire; compare as BigInt. */
+    seq?: string;
+    eventType?: string;
+    occurredAt?: string;
+    taskName?: string;
+    trialIndex?: number;
+    /** int64 on the wire. */
+    durationMs?: string;
+    phase?: string;
+    passed?: boolean;
+}
+export interface RunTimelineProgress {
+    completedTrials?: number;
+    totalTrials?: number;
+    flaggedTrials?: number;
+}
+/**
+ * GET /v1/runs/{id}/timeline. The unary reader for persisted run events.
+ *
+ * This replaced the server-streaming GetRunEvents RPC, which stays
+ * Unimplemented because the in-process grpc-gateway cannot serve a stream (see
+ * sdk/arenarpc/registrar.go). `nextSeq` is the resume cursor for the next poll
+ * and `complete` reports whether the run has finished producing events.
+ */
+export interface GetRunTimelineResponse {
+    events?: RunTimelineEvent[];
+    /** int64 on the wire. Pass back as `sinceSeq` to resume. */
+    nextSeq?: string;
+    complete?: boolean;
+    progress?: RunTimelineProgress | null;
+}
+/** One chunk of run stdout/stderr. */
+export interface RunLogChunk {
+    /** int64 on the wire. */
+    seq?: string;
+    trialName?: string;
+    text?: string;
+    ts?: string;
+    /** True when this chunk continues the previous chunk's line. */
+    continuesLine?: boolean;
+}
+/** GET /v1/runs/{id}/log. */
+export interface GetRunLogResponse {
+    chunks?: RunLogChunk[];
+    /** int64 on the wire. Pass back as `sinceSeq` to resume. */
+    nextSeq?: string;
+    complete?: boolean;
+    attempt?: number;
+    archiveAvailable?: boolean;
+    archiveUrl?: string;
+    /** True when chunks are missing from the middle of the log. */
+    hasGap?: boolean;
+    /** True when chunks were lost in delivery and cannot be recovered. */
+    hasDeliveryLoss?: boolean;
+}
+/** GET /v1/insights. */
+export interface CompetitionInsightsResponse {
+    benchmark?: string;
+    variant?: string;
+    taskCount?: number;
+    rows?: Record<string, unknown>[];
+    tasks?: Record<string, unknown>[];
+}
+/** GET /v1/accounting/status. */
+export interface GetAccountingStatusResponse {
+    /** One of ACCOUNTING_HEALTH_{UNSPECIFIED,HEALTHY,STALE,DLQ_BLOCKED}. */
+    health?: string;
+    materializedThrough?: string;
+    reason?: string;
+    retryGuidance?: string;
+    supportReference?: string;
+}
+/** POST /v1/runs/{runId}/cancel. */
+export interface CancelRunResponse {
+    cancelRequestedAt?: string;
+    runStatus?: string;
+}
+export interface ApiKeyMetadata {
+    id: string;
+    name?: string;
+    prefix?: string;
+    createdAt?: string;
+    lastUsedAt?: string;
+    revoked?: boolean;
+}
+export interface ListApiKeysResponse {
+    keys?: ApiKeyMetadata[];
+}
+/** grpc-gateway error body. */
+export interface RpcStatus {
+    code?: number;
+    message?: string;
+}

package/dist/apiTypes.js

@@ -0,0 +1,24 @@
+/**
+ * Wire types for the benchmaxx-arena HTTP API.
+ *
+ * These mirror the committed OpenAPI spec
+ * (gen/openapi/benchmaxx-arena.swagger.json). grpc-gateway emits camelCase
+ * JSON, so these field names are camelCase, not the proto's snake_case. Only
+ * the fields the MCP tools read are typed; extra fields on the wire are
+ * ignored.
+ *
+ * Two gateway behaviors shape these declarations:
+ *
+ *  - `EmitUnpopulated: true` is a repository-wide gateway policy
+ *    (sdk/rpcServer/httpBodyMarshaler.go). An unset MESSAGE field therefore
+ *    arrives as an explicit `null`, not as an absent key, so every
+ *    message-typed field below is `| null`. Reading one with `=== undefined`
+ *    is always false and is a bug. Unset SCALARS arrive as their protobuf zero
+ *    (`0`, `""`, `false`), not as absent keys, so a zero is not evidence that
+ *    the server omitted the field.
+ *  - proto3 `int64` serializes as a JSON string, `int32` as a number. Fields
+ *    that can exceed 2^53 (`seq`, `nextSeq`, `durationMs`) are therefore
+ *    `string` and must be compared as BigInt, not parsed as Number.
+ */
+export {};
+//# sourceMappingURL=apiTypes.js.map

package/dist/apiTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiTypes.js","sourceRoot":"","sources":["../src/apiTypes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG"}

package/dist/browser.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Open a URL in the user's default browser.
+ *
+ * The opener is invoked with an argv ARRAY and never through a shell, so no part
+ * of the URL can be interpreted as a shell metacharacter. A failure is reported
+ * as `false` rather than thrown: a machine with no browser is an ordinary case
+ * that falls back to printing the URL, not an error.
+ */
+import type { EventEmitter } from 'node:events';
+/** The spawn shape this module depends on, injected for testing. */
+export type SpawnLike = (command: string, args: string[], options: {
+    stdio: 'ignore';
+    detached: boolean;
+}) => EventEmitter & {
+    unref: () => void;
+};
+export interface BrowserDeps {
+    spawn?: SpawnLike;
+    platform?: NodeJS.Platform | string;
+    /** How long to wait for the opener to report. */
+    timeoutMs?: number;
+}
+/** The platform opener and its arguments. */
+export declare function browserCommand(platform: NodeJS.Platform | string, url: string): {
+    command: string;
+    args: string[];
+};
+/**
+ * Try to open `url`. Resolves true when the opener reported success. Resolves
+ * false when no browser could be opened, which is the signal to fall back to
+ * printing the URL.
+ */
+export declare function openInBrowser(url: string, deps?: BrowserDeps): Promise<boolean>;

package/dist/browser.js

@@ -0,0 +1,65 @@
+/**
+ * Open a URL in the user's default browser.
+ *
+ * The opener is invoked with an argv ARRAY and never through a shell, so no part
+ * of the URL can be interpreted as a shell metacharacter. A failure is reported
+ * as `false` rather than thrown: a machine with no browser is an ordinary case
+ * that falls back to printing the URL, not an error.
+ */
+import { spawn as nodeSpawn } from 'node:child_process';
+/** The platform opener and its arguments. */
+export function browserCommand(platform, url) {
+    if (platform === 'darwin') {
+        return { command: 'open', args: [url] };
+    }
+    if (platform === 'win32') {
+        // The empty string is `start`'s title argument; without it a URL containing
+        // '&' is mis-parsed.
+        return { command: 'cmd', args: ['/c', 'start', '', url] };
+    }
+    return { command: 'xdg-open', args: [url] };
+}
+/**
+ * Try to open `url`. Resolves true when the opener reported success. Resolves
+ * false when no browser could be opened, which is the signal to fall back to
+ * printing the URL.
+ */
+export async function openInBrowser(url, deps = {}) {
+    // Only ever hand a web URL to the platform opener.
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return false;
+    }
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+        return false;
+    }
+    const spawn = deps.spawn ?? nodeSpawn;
+    const platform = deps.platform ?? process.platform;
+    const timeoutMs = deps.timeoutMs ?? 5000;
+    const { command, args } = browserCommand(platform, url);
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(value);
+        };
+        const timer = setTimeout(() => finish(false), timeoutMs);
+        let child;
+        try {
+            child = spawn(command, args, { stdio: 'ignore', detached: false });
+        }
+        catch {
+            finish(false);
+            return;
+        }
+        child.on('error', () => finish(false));
+        child.on('close', (code) => finish(code === 0));
+    });
+}
+//# sourceMappingURL=browser.js.map

package/dist/browser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.js","sourceRoot":"","sources":["../src/browser.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,KAAK,IAAI,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAiBvD,6CAA6C;AAC7C,MAAM,UAAU,cAAc,CAC5B,QAAkC,EAClC,GAAW;IAEX,IAAI,QAAQ,KAAK,QAAQ,EAAE,CAAC;QAC1B,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,EAAE,CAAA;IACzC,CAAC;IACD,IAAI,QAAQ,KAAK,OAAO,EAAE,CAAC;QACzB,4EAA4E;QAC5E,qBAAqB;QACrB,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,GAAG,CAAC,EAAE,CAAA;IAC3D,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,EAAE,CAAA;AAC7C,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CAAC,GAAW,EAAE,OAAoB,EAAE;IACrE,mDAAmD;IACnD,IAAI,MAAW,CAAA;IACf,IAAI,CAAC;QACH,MAAM,GAAG,IAAI,GAAG,CAAC,GAAG,CAAC,CAAA;IACvB,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAA;IACd,CAAC;IACD,IAAI,MAAM,CAAC,QAAQ,KAAK,OAAO,IAAI,MAAM,CAAC,QAAQ,KAAK,QAAQ,EAAE,CAAC;QAChE,OAAO,KAAK,CAAA;IACd,CAAC;IAED,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,IAAK,SAAkC,CAAA;IAC/D,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,IAAI,OAAO,CAAC,QAAQ,CAAA;IAClD,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,IAAI,IAAI,CAAA;IACxC,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,cAAc,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAA;IAEvD,OAAO,IAAI,OAAO,CAAU,CAAC,OAAO,EAAE,EAAE;QACtC,IAAI,OAAO,GAAG,KAAK,CAAA;QACnB,MAAM,MAAM,GAAG,CAAC,KAAc,EAAQ,EAAE;YACtC,IAAI,OAAO;gBAAE,OAAM;YACnB,OAAO,GAAG,IAAI,CAAA;YACd,YAAY,CAAC,KAAK,CAAC,CAAA;YACnB,OAAO,CAAC,KAAK,CAAC,CAAA;QAChB,CAAC,CAAA;QACD,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC,CAAA;QAExD,IAAI,KAA2C,CAAA;QAC/C,IAAI,CAAC;YACH,KAAK,GAAG,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,CAAA;QACpE,CAAC;QAAC,MAAM,CAAC;YACP,MAAM,CAAC,KAAK,CAAC,CAAA;YACb,OAAM;QACR,CAAC;QACD,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAA;QACtC,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,IAAY,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,CAAA;IACzD,CAAC,CAAC,CAAA;AACJ,CAAC"}