@latitude-data/openclaw-telemetry 0.0.4 → 0.0.6

package/README.md

@@ -4,71 +4,178 @@ OpenClaw plugin that streams every agent run to [Latitude](https://latitude.so)
 
 ## Install
 
-Requires OpenClaw **2026.4.25 or newer** on PATH. Older versions are detected up-front and the installer aborts with an upgrade message.
+Requires OpenClaw **2026.4.25 or newer**. Get a Latitude API key + project slug from `https://console.latitude.so/settings/api-keys` first.
+
+> **One-shot installer coming soon.** A separate `@latitude-data/openclaw-telemetry-cli` package is in flight that will collapse the steps below into `npx -y @latitude-data/openclaw-telemetry-cli install`. For now, the manual flow below is the supported path.
+
+### Step 1 — Install the plugin runtime
+
+```bash
+openclaw plugins install @latitude-data/openclaw-telemetry
+```
+
+OpenClaw fetches the package from npm, runs its security scan, copies files into `~/.openclaw/extensions/<id>/`, and creates a (disabled) `plugins.entries["@latitude-data/openclaw-telemetry"]` entry in `~/.openclaw/openclaw.json`. The gateway will print:
+
+> Plugin installed but disabled. Configure it, then run `openclaw plugins enable @latitude-data/openclaw-telemetry`.
+
+That's expected — the next step does the configure-and-enable.
+
+### Step 2 — Configure and enable
+
+Run these `openclaw config set` commands (use bracket notation so the scoped package name parses correctly). Substitute your real API key and project slug in the first two:
+
+```bash
+openclaw config set 'plugins.entries["@latitude-data/openclaw-telemetry"].config.apiKey' "lat_xxx"
+openclaw config set 'plugins.entries["@latitude-data/openclaw-telemetry"].config.project' "my-project-slug"
+openclaw config set 'plugins.entries["@latitude-data/openclaw-telemetry"].config.allowConversationAccess' true
+openclaw config set 'plugins.entries["@latitude-data/openclaw-telemetry"].hooks.allowConversationAccess' true
+openclaw config set 'plugins.entries["@latitude-data/openclaw-telemetry"].enabled' true
+```
+
+Why two `allowConversationAccess` writes? They mean different things — `hooks.*` is OpenClaw's dispatch gate (without it the plugin's hook handlers never fire), `config.*` is the plugin's payload-content gate (without it the plugin emits structural-only spans). For full content capture they must both be `true`. See [The two flags](#the-two-flags) for details.
+
+### Step 3 — Add to `plugins.allow` (optional but loud)
+
+OpenClaw warns at every gateway restart about non-bundled plugins that auto-load without provenance via `plugins.allow`. Silence the warning by adding the id:
+
+```bash
+# `config set` can't append to arrays — set the whole list. If you already have
+# entries in `plugins.allow`, include them here too:
+openclaw config set 'plugins.allow' '["@latitude-data/openclaw-telemetry"]'
+```
+
+### Step 4 — Restart the gateway
 
 ```bash
-npx -y @latitude-data/openclaw-telemetry install
 openclaw gateway restart
 ```
 
-The installer prompts for your Latitude API key and project slug, then:
+Verify everything's wired:
+
+```bash
+openclaw config validate --json
+# → {"valid": true, ...}
+
+grep -E "blocked|plugin not found|latitude" /tmp/openclaw/openclaw-*.log | tail
+# → ready (N plugins: ..., @latitude-data/openclaw-telemetry, ...)
+# → no "blocked", no "plugin not found"
+```
+
+Send a message to one of your OpenClaw agents — within a few seconds, traces appear at `https://console.latitude.so/projects/<your-slug>`.
+
+### Alternative: hand-edit `~/.openclaw/openclaw.json`
+
+If you'd rather paste a JSON block than run six commands, the equivalent edit is:
+
+```jsonc
+{
+  "plugins": {
+    "allow": ["@latitude-data/openclaw-telemetry"],
+    "entries": {
+      "@latitude-data/openclaw-telemetry": {
+        "enabled": true,
+        "hooks": {
+          "allowConversationAccess": true
+        },
+        "config": {
+          "apiKey": "lat_xxx",
+          "project": "my-project-slug",
+          "allowConversationAccess": true
+        }
+      }
+    }
+  }
+}
+```
+
+Merge this with whatever else is in `openclaw.json`. Then `openclaw config validate` and `openclaw gateway restart` as above.
 
-1. Verifies your OpenClaw version (aborts on `< 2026.4.25`).
-2. Hands plugin placement to OpenClaw via `openclaw plugins install <package-path> --force`. OpenClaw copies files into `~/.openclaw/extensions/<id>/`, writes the install record to `~/.openclaw/plugins/installs.json`, and creates the `plugins.entries[id]` block.
-3. Layers our config on top in `~/.openclaw/openclaw.json`:
-   - **`config.*`** — credentials, baseUrl, and `allowConversationAccess` (the payload-content gate the plugin's runtime reads).
-   - **`hooks.allowConversationAccess`** — the dispatch gate OpenClaw's runtime checks before forwarding LLM/tool/agent events to non-bundled plugins. Always mirrored to the same value as `config.allowConversationAccess`.
-4. Adds the plugin id to `plugins.allow` (running `npx install` is the trust signal). Pass `--no-trust` to opt out.
+### Targeting a different environment
 
-Traces show up at `https://console.latitude.so/projects/<your-slug>` once the gateway restarts.
+For staging or local-dev, also set `baseUrl`:
 
-### Install flags
+```bash
+# Staging:
+openclaw config set 'plugins.entries["@latitude-data/openclaw-telemetry"].config.baseUrl' "https://staging-ingest.latitude.so"
 
-| Flag | What it does |
-| --- | --- |
-| `--api-key=<key>` | Pass the API key instead of being prompted. |
-| `--project=<slug>` | Pass the project slug instead of being prompted. |
-| `--staging` | Target `https://staging.latitude.so` / `https://staging-ingest.latitude.so`. |
-| `--dev` | Target `http://localhost:3000` / `http://localhost:3002`. |
-| `--yes` / `--no-prompt` | Skip all prompts. Required for non-TTY / CI invocations. |
-| `--no-content` | Skip raw prompt/response/tool I/O capture. Spans still emit with timing, token usage, model name, and ids. Mirrored into both `config.allowConversationAccess` and `hooks.allowConversationAccess`. |
-| `--no-trust` | Skip auto-adding the plugin id to `plugins.allow`. OpenClaw will keep printing `plugins.allow is empty` warnings until you add it manually. |
+# Local dev:
+openclaw config set 'plugins.entries["@latitude-data/openclaw-telemetry"].config.baseUrl' "http://localhost:3002"
+```
 
-Re-running `install` is idempotent — credentials/baseUrl are overwritten from prompts, but hand-edited `enabled`, `debug`, and `allowConversationAccess` values in `openclaw.json` are preserved unless you pass the corresponding flag.
+### Structural-only telemetry (no content capture)
+
+If you want trace metadata (timings, token usage, model name, agent name, ids) without the prompt/response content, keep `hooks.allowConversationAccess` at `true` (so OpenClaw still dispatches events to us) and set only `config.allowConversationAccess` to `false`:
+
+```bash
+openclaw config set 'plugins.entries["@latitude-data/openclaw-telemetry"].config.allowConversationAccess' false
+openclaw config set 'plugins.entries["@latitude-data/openclaw-telemetry"].hooks.allowConversationAccess' true
+```
+
+Setting `hooks.allowConversationAccess=false` would block dispatch entirely — see [The two flags](#the-two-flags). The plugin still emits the full span tree; just the content attributes (`gen_ai.input.messages`, `gen_ai.output.messages`, `gen_ai.system_instructions`, tool args/results) are scrubbed. Each span carries a `latitude.captured.content: false` boolean so the gate state is visible in the Latitude UI.
 
 ## Uninstall
 
 ```bash
-npx -y @latitude-data/openclaw-telemetry uninstall
+openclaw plugins uninstall @latitude-data/openclaw-telemetry --force
 ```
 
-Shows a plan, asks for confirmation, then runs `openclaw plugins uninstall @latitude-data/openclaw-telemetry --force` (which removes files, the install record, the plugin entry, and the `plugins.allow` entry). Defensive cleanup follows for any leftover keys, with a backup at `openclaw.json.latitude-bak`.
+OpenClaw removes the files, install record, plugin entry, and the `plugins.allow` entry. After that, restart the gateway:
+
+```bash
+openclaw gateway restart
+```
 
 ## What gets sent
 
-For each agent run, the plugin emits one trace with three span kinds:
+For each agent run, the plugin emits one trace shaped like the actual run:
+
+```
+agent (root, traceId = hash(runId))
+├─ compaction         (0..1, rare; budget-triggered)
+├─ model_call         (1..N, one per provider API call)
+├─ tool_call: foo     (between model_calls; sibling of agent)
+├─ model_call
+├─ tool_call: bar
+├─ subagent           (0..N — the child's full agent tree nests under here)
+│   └─ agent
+│       ├─ model_call
+│       └─ tool_call: ...
+└─ model_call         (final)
+```
+
+Five span kinds:
+
+- **`agent`** — root of the run. Carries `openclaw.session.key`, `openclaw.agent.id`, `openclaw.agent.name`, aggregated token usage across all generations, run duration, success/error status, the first user prompt, and the full final message list. This is where attempt-aggregate `gen_ai.*` lands.
+- **`model_call`** — one per actual provider API call inside the run. Carries provider, request/response model, `openclaw.api`, `openclaw.transport`, per-call duration, outcome, error category, time-to-first-byte, request payload bytes, response stream bytes, upstream request id hash, and `gen_ai.input.messages` snapshotted at the moment that generation started. Per-call output messages and per-call token usage aren't surfaced by OpenClaw today (attempt-aggregate only); those stay on `agent`.
+- **`tool_call:<name>`** — one per tool invocation. Canonical `gen_ai.tool.*` attributes: `name`, `call.id`, `call.arguments`, `call.result`. Sibling of `agent`, NOT child of `model_call` — tools run between generations, not during them.
+- **`compaction`** — rare; fires when OpenClaw hits the message budget mid-run. Records before/after message counts and the compacted-out count.
+- **`subagent`** — one per child run spawned by this agent. The child's entire `agent` subtree (its own `model_call`s, `tool_call`s, even further-nested `subagent`s) parents itself underneath via cross-runId trace propagation, so a spawn tree is one waterfall in one trace.
 
-- **`interaction`** — the agent run. Carries `openclaw.session.key`, `openclaw.agent.id`, `openclaw.agent.name`, aggregated token usage across all LLM calls, run duration, success/error status, and the first user prompt.
-- **`llm_request`** — one per LLM call. Carries provider, request/response model, `gen_ai.system_instructions`, `gen_ai.input.messages` (full history + current prompt), `gen_ai.output.messages` (assistant text + tool_call parts), and full token usage (input/output/cache_read/cache_creation/total) — under both canonical `gen_ai.*` keys and legacy aliases.
-- **`tool_execution`** — one per tool call. Canonical `gen_ai.tool.*` attributes: `name`, `call.id`, `call.arguments`, `call.result`. Failures set `error.type`, `error.message`, and OTel status code 2.
+Every span carries `openclaw.agent.id` and `openclaw.agent.name`. Multi-agent setups produce spans tagged with the invoking agent's id, letting you filter and group by agent in the Latitude UI.
 
-Every span carries `openclaw.agent.id` and `openclaw.agent.name`. Multi-agent OpenClaw setups (sub-agents) naturally produce spans tagged with the invoking agent's id, letting you filter and group by agent in the Latitude UI.
+All spans share the same `traceId` so they group as one trace per agent run (and one trace per spawn tree, by virtue of the subagent linkage).
 
-All spans share the run id and trace id so they group together.
+### Backend caveat: Codex / Claude-Code-style providers
+
+OpenClaw's `model_call_started` / `model_call_ended` hooks fire from its `selection` layer, which wraps the agent's `streamFn` invocation. For "agentic" backends (Codex, Claude Code) the inner generations happen inside the backend's own loop and don't surface as separate `model_call` events. Result: a Codex-backed run shows ONE `model_call` per attempt instead of N. Anthropic and OpenAI direct don't have this issue. The fix is upstream in OpenClaw — out of scope for this plugin.
 
 ## How it works
 
-OpenClaw ships typed plugin hooks that fire per-LLM-call with the complete payload (`src/plugins/hook-types.ts` in the OpenClaw source). We subscribe to:
+We subscribe to OpenClaw's typed plugin hooks (`src/plugins/hook-types.ts` upstream). The model is "one span per paired before/after (or start/end) event":
+
+| Span | Start hook | End hook |
+| --- | --- | --- |
+| `agent` | `before_agent_start` | `agent_end` |
+| `model_call` | `model_call_started` | `model_call_ended` |
+| `tool_call` | `before_tool_call` | `after_tool_call` |
+| `compaction` | `before_compaction` | `after_compaction` |
+| `subagent` | `subagent_spawned` | `subagent_ended` |
 
-- `llm_input` — full system prompt, prompt text, history messages, provider, model.
-- `llm_output` — assistant text, last assistant message, full token usage (input/output/cacheRead/cacheWrite/total), resolved provider/model ref.
-- `before_tool_call` / `after_tool_call` — tool name, arguments, result, error, duration.
-- `agent_end` — run completion signal. This is when we build the OTLP trace and POST it.
-- `session_start` — currently a no-op; reserved for future session-level metadata.
+Two more hooks (`llm_input`, `llm_output`) are subscribed to for **content only** — they don't open or close spans, they just enrich the `agent` span with attempt-aggregate data and seed the rolling history snapshot used by per-call `model_call.gen_ai.input.messages`.
 
-OpenClaw runs LLM hooks **fire-and-forget** (see [`src/plugins/hooks.ts`](https://github.com/openclaw/openclaw/blob/main/src/plugins/hooks.ts) — `runLlmInput`/`runLlmOutput` are documented as parallel, and the call site in [`src/agents/pi-embedded-runner/run/attempt.ts`](https://github.com/openclaw/openclaw/blob/main/src/agents/pi-embedded-runner/run/attempt.ts) wraps them with `void hookRunner.run*(...).catch(...)`). Our handlers can never slow down the agent loop.
+The hook system runs handlers fire-and-forget (see [`src/plugins/hooks.ts`](https://github.com/openclaw/openclaw/blob/main/src/plugins/hooks.ts) upstream), so nothing we do here can slow the agent loop. The one exception is `before_tool_call`, which is a `runModifyingHook` — our handler returns `undefined` so OpenClaw dispatches the tool normally. Returning anything else (e.g. `{block: true}`) would block every tool call.
 
-**No runtime wrapping.** Unlike existing third-party OpenClaw observability plugins that try to monkey-patch `@mariozechner/pi-ai` (and run into jiti's CJS/ESM module isolation), we stay inside the supported plugin API. The hooks give us everything, at lower risk of breaking on OpenClaw updates.
+**No runtime wrapping.** Unlike third-party OpenClaw observability plugins that try to monkey-patch `@mariozechner/pi-ai` (and run into jiti's CJS/ESM module isolation), we stay inside the supported plugin API. The hooks give us everything, at lower risk of breaking on OpenClaw updates.
 
 ## Configuration reference
 

package/dist/plugin.d.ts

@@ -20,68 +20,56 @@ interface Logger {
   warn: (msg: string) => void;
 }
 //#endregion
-//#region src/types.d.ts
-interface OpenClawLlmUsage {
-  input?: number;
-  output?: number;
-  cacheRead?: number;
-  cacheWrite?: number;
-  total?: number;
-}
-interface LlmCallRecord {
-  runId: string;
-  sessionId: string;
-  sessionKey: string | undefined;
-  agentId: string | undefined;
-  provider: string;
-  requestModel: string;
-  responseModel: string | undefined;
-  resolvedRef: string | undefined;
-  systemPrompt: string | undefined;
-  prompt: string;
-  historyMessages: unknown[];
-  imagesCount: number;
-  assistantTexts: string[];
-  lastAssistant: unknown;
-  usage: OpenClawLlmUsage | undefined;
-  startMs: number;
-  endMs: number | undefined;
-  error: string | undefined;
-  toolCalls: ToolCallRecord[];
-}
-interface ToolCallRecord {
-  toolCallId: string;
-  toolName: string;
-  params: Record<string, unknown>;
-  result: unknown;
-  error: string | undefined;
+//#region src/span-builder.d.ts
+/**
+ * Builds the per-trace span tree for an OpenClaw agent run from the granular
+ * paired hooks. Replaces the older `turn-builder.ts` model that collapsed the
+ * whole attempt into a single `llm_request` span — that shape was wrong on
+ * two counts: `llm_input` / `llm_output` fire ONCE per attempt (not per
+ * generation), and an attempt is a sequence of generations interleaved with
+ * tool executions.
+ *
+ * Span set this builder produces:
+ *
+ *   agent (root)
+ *   ├─ compaction        (0..1, rare)
+ *   ├─ model_call        (1..N, one per provider API call)
+ *   ├─ tool_call: ...    (interleaved between model_calls; siblings of agent)
+ *   ├─ subagent          (0..N; child agent runs nest INSIDE these via
+ *   │   └─ agent ...      cross-runId trace propagation)
+ *   └─ model_call        (final)
+ *
+ * Tool spans are siblings of `agent`, not children of `model_call`, because
+ * tools run BETWEEN generations — not during them. Nesting under model_call
+ * would falsely imply concurrency.
+ *
+ * `llm_input` / `llm_output` are NOT span boundaries here. They're data-only
+ * feeds that enrich the parent `agent` span (full message history, output
+ * messages, aggregate token usage).
+ */
+interface SpanRecord {
+  /** Stable id for the span (16 hex chars). */
+  spanId: string;
+  /** Span tree id (32 hex chars). */
+  traceId: string;
+  /** Empty string for root agent spans, parent's spanId otherwise. */
+  parentSpanId: string;
+  /** OpenClaw event noun (`agent` / `model_call` / `tool_call` / `compaction` / `subagent`). */
+  name: string;
   startMs: number;
   endMs: number | undefined;
-  durationMs: number | undefined;
-  agentId: string | undefined;
+  /** Free-form attribute bag — flattened to OTLP key/value at emit time. */
+  attrs: Record<string, AttrValue>;
+  /** Status — set at close from the event payload's outcome/error. */
+  outcome?: "ok" | "error";
+  errorMessage?: string | undefined;
 }
-interface RunRecord {
+type AttrValue = string | number | boolean | unknown[] | Record<string, unknown> | undefined;
+interface BuildResult {
+  /** Run id this batch belongs to. */
   runId: string;
-  sessionId: string | undefined;
-  sessionKey: string | undefined;
-  agentId: string | undefined;
-  workspaceDir: string | undefined;
-  messageProvider: string | undefined;
-  trigger: string | undefined;
-  channelId: string | undefined;
-  modelProviderId: string | undefined;
-  modelId: string | undefined;
-  startMs: number;
-  endMs: number | undefined;
-  success: boolean | undefined;
-  error: string | undefined;
-  llmCalls: LlmCallRecord[];
-  /**
-   * Tool calls queued by `before_tool_call` but not yet matched to an `llm_call`
-   * because the most recent `llm_output` has already closed the call for this
-   * runId. Retained so `after_tool_call` can still complete the record.
-   */
-  orphanTools: ToolCallRecord[];
+  /** All spans ready to be exported (agent + everything beneath it). */
+  spans: SpanRecord[];
 }
 //#endregion
 //#region src/plugin.d.ts
@@ -112,17 +100,19 @@ interface RegisterOptions {
    * Hook to observe the emitted run right before it's posted. Used by tests;
    * not a stable public API.
    */
-  onEmit?: (run: RunRecord) => void;
+  onEmit?: (result: BuildResult) => void;
 }
 /**
  * Register the Latitude plugin against an OpenClaw plugin API. OpenClaw calls
- * this once at plugin activation; we wire up `llm_input`, `llm_output`, tool
- * and lifecycle hooks to stream traces to Latitude.
+ * this once at plugin activation; we wire up the granular paired hooks
+ * (model_call_started/_ended, before_/after_tool_call, before_/after_compaction,
+ * subagent_spawned/_ended, before_agent_start/agent_end) plus the
+ * data-only feeds (llm_input/llm_output) that enrich the agent span.
  *
- * Every handler is fire-and-forget on OpenClaw's side (see
- * `src/plugins/hooks.ts` — runLlmInput/runLlmOutput are documented as
- * parallel and wrapped with `.catch()` at the call site in attempt.ts), so
- * nothing we do here can slow the agent loop.
+ * Every typed hook on OpenClaw's side fires fire-and-forget for non-modifying
+ * hooks; before_tool_call is a `runModifyingHook` where returning anything
+ * other than undefined blocks the tool call. Our handler returns nothing —
+ * keep it that way.
  */
 declare function registerLatitudePlugin(api: OpenClawPluginApiLike, opts?: RegisterOptions): void;
 //#endregion

package/dist/plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.ts","names":[],"sources":["../src/config.ts","../src/logger.ts","../src/types.ts","../src/plugin.ts"],"mappings":";UAAiB,MAAA;EACf,MAAA;EACA,OAAA;EACA,OAAA;EACA,OAAA;EACA,KAAA;EAHA;;;;;;EAUA,uBAAA;AAAA;;;UCVe,MAAA;EACf,KAAA,GAAQ,GAAA;EACR,IAAA,GAAO,GAAA;AAAA;;;UCwDQ,gBAAA;EACf,KAAA;EACA,MAAA;EACA,SAAA;EACA,UAAA;EACA,KAAA;AAAA;AAAA,UA4De,aAAA;EACf,KAAA;EACA,SAAA;EACA,UAAA;EACA,OAAA;EACA,QAAA;EACA,YAAA;EACA,aAAA;EACA,WAAA;EACA,YAAA;EACA,MAAA;EACA,eAAA;EACA,WAAA;EACA,cAAA;EACA,aAAA;EACA,KAAA,EAAO,gBAAA;EACP,OAAA;EACA,KAAA;EACA,KAAA;EACA,SAAA,EAAW,cAAA;AAAA;AAAA,UAGI,cAAA;EACf,UAAA;EACA,QAAA;EACA,MAAA,EAAQ,MAAA;EACR,MAAA;EACA,KAAA;EACA,OAAA;EACA,KAAA;EACA,UAAA;EACA,OAAA;AAAA;AAAA,UAGe,SAAA;EACf,KAAA;EACA,SAAA;EACA,UAAA;EACA,OAAA;EACA,YAAA;EACA,eAAA;EACA,OAAA;EACA,SAAA;EACA,eAAA;EACA,OAAA;EACA,OAAA;EACA,KAAA;EACA,OAAA;EACA,KAAA;EACA,QAAA,EAAU,aAAA;ECnHmC;;;;;EDyH7C,WAAA,EAAa,cAAA;AAAA;;;;;;;;;;;;;;UCzJE,qBAAA;EACf,MAAA,GAAS,MAAA;EACT,YAAA,GAAe,MAAA;EACf,EAAA,qBACE,QAAA,EAAU,CAAA,EACV,OAAA,GAAU,KAAA,WAAgB,GAAA,uBAC1B,IAAA;IAAS,QAAA;EAAA;AAAA;AAAA,UAII,eAAA;EFjCf;EEmCA,MAAA,GAAS,MAAA;EFnCS;EEqClB,MAAA,GAAS,MAAA;;;;ADmBX;ECdE,MAAA,IAAU,GAAA,EAAK,SAAA;AAAA;;;;;;;;;AD+EjB;;iBClEwB,sBAAA,CAAuB,GAAA,EAAK,qBAAA,EAAuB,IAAA,GAAM,eAAA"}
+{"version":3,"file":"plugin.d.ts","names":[],"sources":["../src/config.ts","../src/logger.ts","../src/span-builder.ts","../src/plugin.ts"],"mappings":";UAAiB,MAAA;EACf,MAAA;EACA,OAAA;EACA,OAAA;EACA,OAAA;EACA,KAAA;EAHA;;;;;;EAUA,uBAAA;AAAA;;;UCVe,MAAA;EACf,KAAA,GAAQ,GAAA;EACR,IAAA,GAAO,GAAA;AAAA;;;ADJT;;;;;;;;;;;;;;;ACEA;;;;;;;;;;;ADFA,UEsDiB,UAAA;;EAEf,MAAA;EAFyB;EAIzB,OAAA;EAQa;EANb,YAAA;EAFA;EAIA,IAAA;EACA,OAAA;EACA,KAAA;EAAA;EAEA,KAAA,EAAO,MAAA,SAAe,SAAA;EAAf;EAEP,OAAA;EACA,YAAA;AAAA;AAAA,KAGU,SAAA,2CAAoD,MAAA;AAAA,UAoD/C,WAAA;EApDL;EAsDV,KAAA;;EAEA,KAAA,EAAO,UAAA;AAAA;;;;;;;;;;;;;;UChGQ,qBAAA;EACf,MAAA,GAAS,MAAA;EACT,YAAA,GAAe,MAAA;EACf,EAAA,qBACE,QAAA,EAAU,CAAA,EACV,OAAA,GAAU,KAAA,WAAgB,GAAA,uBAC1B,IAAA;IAAS,QAAA;EAAA;AAAA;AAAA,UAII,eAAA;EFtCf;EEwCA,MAAA,GAAS,MAAA;EFxCS;EE0ClB,MAAA,GAAS,MAAA;;;;ADQX;ECHE,MAAA,IAAU,MAAA,EAAQ,WAAA;AAAA;;;;;;;;;;;;;iBAeI,sBAAA,CAAuB,GAAA,EAAK,qBAAA,EAAuB,IAAA,GAAM,eAAA"}