@mutirolabs/openclaw-brain 0.1.1 → 0.2.1

package/CHANGELOG.md

@@ -7,6 +7,71 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.1] - 2026-05-23
+
+### Fixed
+
+- Ship compiled JavaScript in `dist/` so `openclaw plugins install
+  @mutirolabs/openclaw-brain` works. 0.2.0 published TypeScript source only,
+  which OpenClaw's plugin loader rejects for npm-installed packages with
+  "package install requires compiled runtime output for TypeScript entry
+  ./index.ts: expected ./dist/index.js". Source-checkout installs
+  (`file:./path`) were unaffected.
+
+### Changed
+
+- `prepublishOnly` now runs `npm run build` in addition to `npm run check`,
+  emitting `dist/` from a new `tsconfig.build.json`. Source files
+  (`index.ts`, `src/`) continue to ship alongside `dist/` for source-map
+  debugging and the source-checkout fallback path.
+
+## [0.2.0] - 2026-04-19
+
+### Added
+
+- Threading adapter: the agent's first reply in a turn threads under the
+  inbound message by default (visible quoted pill in every Mutiro client).
+  `channels.mutiro.replyToMode` overrides with `off` | `first` | `all` |
+  `batched`. `allowExplicitReplyTagsWhenOff: true` keeps agent-directed reply
+  markers working when the user opts out.
+- `replyToMode` exposed in `openclaw.plugin.json` configSchema.
+- Status adapter (`ChannelStatusAdapter.buildAccountSnapshot`):
+  `openclaw channels status mutiro` now reports `healthState` (stopped |
+  restarting | connecting | healthy), `mode: "bridge"`, and `dbPath`
+  pointing at the Mutiro agent workspace.
+- Bridge crash backoff: unexpected host exits track a per-account crash
+  streak with a 5-minute reset window and hold the gateway lifecycle promise
+  through an exponential delay (1s → 2s → 5s → 15s → 60s). Clean exits
+  (code 0 or abort) short-circuit immediately. Surfaces `restartPending`,
+  `reconnectAttempts`, and structured `lastDisconnect` on the snapshot.
+- Setup wizard pre-flight: runs `mutiro agent host status` and warns if a
+  Mutiro agent host is already running for this agent before starting the
+  gateway.
+
+### Changed
+
+- README rewrite: sharper tagline, hero screenshot (`docs/assets/mutiro-openclaw-ui.png`),
+  Prerequisites section folded into the setup wizard, `tools.alsoAllow`
+  switched from YAML hand-edit to
+  `openclaw config set tools.alsoAllow '["mutiro*"]'`, allowlist reframed
+  as an edge-enforced security feature, sibling link to `pi-brain`.
+- Doc links drop `.md` suffixes so they render as HTML; `/docs` replaced
+  with `/docs/manual` + `/docs/cli`.
+- Prerequisites "built-in brain stopped" check now references
+  `mutiro agent host status` (runtime liveness) instead of
+  `mutiro agent doctor` (which only validates config).
+- Internal cleanup: removed `pi-brain` references from source comments
+  and changelog.
+- User-facing metadata aligned with OpenClaw's "channel" + "extension"
+  language: npm `description`, `keywords`, channel `selectionLabel`,
+  `blurb`, plugin entry `description`, and the setup wizard title no
+  longer leak the internal `chatbridge` protocol name.
+
+### Removed
+
+- Unused `MUTIRO_AGENT_API_KEY` from `openclaw.plugin.json` `channelEnvVars`;
+  the chathost reads that env var, not this plugin.
+
 ## [0.1.1] - 2026-04-18
 
 ### Added
@@ -20,8 +85,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
-- Initial OpenClaw channel plugin for the Mutiro `chatbridge` protocol.
-- NDJSON envelope codec ported from `pi-brain`.
+- Initial OpenClaw Channel extension for Mutiro.
+- NDJSON envelope codec for `mutiro.agent.bridge.v1`.
 - Subprocess lifecycle for `mutiro agent host --mode=bridge`, one per configured account.
 - Inbound pipeline: `message.observed` → OpenClaw reply dispatch.
 - Outbound surface: `message.send`, `message.send_voice`, `message.react`,
@@ -55,6 +120,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   with concrete fix commands, plus the paste-into-AI prompt as an alternative
   for users who'd rather have their AI assistant drive the setup.
 
-[Unreleased]: https://github.com/mutirolabs/openclaw-brain/compare/v0.1.1...HEAD
+[Unreleased]: https://github.com/mutirolabs/openclaw-brain/compare/v0.2.1...HEAD
+[0.2.1]: https://github.com/mutirolabs/openclaw-brain/compare/v0.2.0...v0.2.1
+[0.2.0]: https://github.com/mutirolabs/openclaw-brain/compare/v0.1.1...v0.2.0
 [0.1.1]: https://github.com/mutirolabs/openclaw-brain/compare/v0.1.0...v0.1.1
 [0.1.0]: https://github.com/mutirolabs/openclaw-brain/releases/tag/v0.1.0

package/README.md

@@ -1,138 +1,62 @@
-# Mutiro OpenClaw Channel Reference
+# Mutiro Channel for OpenClaw
 
-Use this repo if you want to plug [OpenClaw](https://openclaw.ai) into a Mutiro agent over `chatbridge`, so OpenClaw becomes the external brain and Mutiro becomes just another OpenClaw channel.
+The official Mutiro Channel extension for OpenClaw.
 
-This is the OpenClaw-shaped sibling of [`../pi-brain`](../pi-brain). The bridge codec is a faithful port of `mutiro-pi-bridge.ts`; the brain side is structured as an OpenClaw third-party channel plugin instead of a one-off standalone adapter.
+OpenClaw handles the cognition. Mutiro handles the messaging surface, identity, and state.
 
-## Prerequisites
+![Mutiro UI with OpenClaw Badge](docs/assets/mutiro-openclaw-ui.png)
 
-This plugin assumes you already have a working Mutiro agent. Before the Quick
-Start below, confirm each of these passes:
+## Why this exists
 
-| Check | Fix if it fails |
-|-------|-----------------|
-| `mutiro version` prints a version | `curl -sSL https://mutiro.com/downloads/install.sh \| bash` |
-| `mutiro auth whoami` prints your username | sign up: `mutiro auth signup <email> <username> "<Display Name>"` — or log in: `mutiro auth login <email>` |
-| `mutiro agents list` shows at least one agent you own | `mutiro agents create <username> "<Display>" --engine genie --bio "<short bio>" --badge lobster` |
-| The built-in Mutiro brain for that agent is **not** running | `mutiro agent doctor`, and stop any `mutiro agent run` / `mutiro start` process for that agent |
-
-Want an AI assistant to drive you through those steps instead? Paste this into
-Claude, Cursor, or Windsurf:
-
-```text
-Read this page from the Mutiro docs: https://mutiro.com/docs/guides/create-agent.md and help me create an agent step by step.
-```
-
-Canonical reference: [Mutiro create-agent guide](https://www.mutiro.com/docs/guides/create-agent.md).
-
-> **Show the 🦞 badge.** Pass `--badge lobster` on `mutiro agents create` to mark
-> the agent as OpenClaw-powered in the Mutiro UI. Already have an agent? Flip
-> the badge with:
-> ```bash
-> mutiro agents update-profile <agent-username> --badge lobster
-> ```
-
-> **Two brains, one agent = trouble.** Mutiro ships its own built-in brain. If
-> you leave it running, it will race OpenClaw for the same conversations and
-> both will reply (or neither will, depending on ordering). Stop it before
-> starting the OpenClaw gateway.
+Sovereign intelligence deserves a professional interface. Hiding a powerful OpenClaw brain behind a generic Telegram bot or a clunky webview breaks the user experience and obscures ownership. This extension implements an OpenClaw Channel that connects your agent to Mutiro's native clients (Desktop, Mobile, Web, CLI), enforcing the `by @owner` accountability standard out of the box.
 
 ## Quick Start
 
-### 1. Install this plugin into OpenClaw
+Install the Mutiro channel using OpenClaw's native extension manager:
 
 ```bash
 openclaw plugins install --dangerously-force-unsafe-install @mutirolabs/openclaw-brain
 ```
 
-Or, for local development:
-
-```bash
-# Skip node_modules if you've run `npm install` here — the install scanner
-# walks the source tree and caps at 10k directories.
-rm -rf node_modules
-openclaw plugins install --dangerously-force-unsafe-install "file:$(pwd)"
-```
-
-> **Why the `--dangerously-force-unsafe-install` flag?**
-> This plugin legitimately spawns `mutiro agent host --mode=bridge` as a
-> subprocess — that is the entire point of the `chatbridge` adapter. OpenClaw's
-> install scanner correctly flags any plugin that uses `child_process` as
-> sensitive, and requires this flag as an explicit acknowledgement. Before you
-> pass it, **confirm you are installing from the signed [mutirolabs/openclaw-brain](https://github.com/mutirolabs/openclaw-brain)
-> source** (or the `@mutirolabs/openclaw-brain` npm package). Review the
-> `spawn` call at [`src/bridge-client.ts`](./src/bridge-client.ts) if you want
-> to see exactly what the plugin executes.
-
-### 2. Configure the channel
+> The flag is required because this extension launches a Mutiro host process to carry the channel. Install only from the signed [`@mutirolabs/openclaw-brain`](https://github.com/mutirolabs/openclaw-brain) source.
 
-The plugin ships a setup wizard. Run the bare command (no `--channel` flag —
-passing one skips the wizard and falls through to the non-interactive adapter):
+Add the channel:
 
 ```bash
 openclaw channels add
 ```
 
-Pick `mutiro` from the list. The wizard will:
+Pick `mutiro` from the list. The setup wizard detects the Mutiro CLI, validates your agent directory, and confirms you are authenticated.
 
-- detect the `mutiro` CLI (and point you at the install command if missing)
-- ask for your Mutiro agent directory (the folder containing `.mutiro-agent.yaml`)
-- validate the directory and run `mutiro auth whoami`
-- remind you to stop the built-in Mutiro brain before starting the gateway
-
-Or set the config manually:
-
-```bash
-openclaw config set channels.mutiro.accounts.default.agentDir /path/to/agent-directory
-```
-
-### 3. Run the OpenClaw gateway
+Start the gateway:
 
 ```bash
 openclaw gateway run
 ```
 
-Or use the shortcut:
-
-```bash
-./run-brain.sh /path/to/agent-directory
-```
-
-### 4. Talk to your agent
-
-Once the gateway is running, your agent is reachable from any Mutiro surface:
+Your agent is now live on every Mutiro surface — Web, Desktop, Mobile, and CLI.
 
-- **Web app:** [https://app.mutiro.com](https://app.mutiro.com)
-- **CLI chat:** `mutiro chat`
-- **Mobile:** Mutiro app on iOS / Android
-- **Desktop:** Mutiro desktop app on macOS / Windows / Linux
-
-For a quick shell smoke test:
+Send a smoke-test message:
 
 ```bash
 mutiro user message send <agent-username> "Hello! Who are you?"
 ```
 
-### 5. Allow Mutiro-specific agent tools
+## Enable Mutiro-native tools
 
-To let the OpenClaw agent send voice messages, interactive cards, or forward
-messages through Mutiro, add `mutiro*` to your agent's `tools.alsoAllow`:
+Let your OpenClaw agent send voice messages, interactive cards, and forward messages through Mutiro by allowing the `mutiro*` tools:
 
-```yaml
-tools:
-  profile: messaging
-  alsoAllow:
-    - "mutiro*"
+```bash
+openclaw config set tools.alsoAllow '["mutiro*"]'
 ```
 
-See [`docs/guides/use-openclaw-as-brain.md`](./docs/guides/use-openclaw-as-brain.md)
-for a full walkthrough.
+If you already curate `tools.alsoAllow`, merge `"mutiro*"` into your existing list instead of overwriting — the command above replaces the array.
+
+## Access control, enforced at the edge
 
-### 6. Share the agent with other users
+Mutiro runs the allowlist on its servers — not in your agent. Denied users are rejected before their messages reach OpenClaw, so agent-side bugs can never leak access to someone who shouldn't have it. This is a stronger posture than in-agent filtering and a real differentiator over generic bot channels.
 
-Mutiro has a **server-side allowlist** that's separate from OpenClaw's own
-`allowFrom`. Denied users are blocked at the Mutiro server — their messages
-never reach OpenClaw at all. Manage it with the `mutiro` CLI:
+One extra CLI step buys you that posture:
 
 ```bash
 mutiro agents allowlist get <agent-username>
@@ -140,134 +64,37 @@ mutiro agents allow <agent-username> <username>
 mutiro agents deny <agent-username> <username>
 ```
 
-See [`docs/guides/manage-allowlist.md`](./docs/guides/manage-allowlist.md) for
-the full command reference and a paste-into-AI prompt you can hand to your
-assistant when you want help managing sharing and security posture.
-
-## What This Repo Is
-
-A small reference package showing how to plug OpenClaw into Mutiro `chatbridge` as a channel plugin. Pi is a good reference for swapping Mutiro's brain with a standalone runtime; this one shows the same shape routed through OpenClaw's channel plugin contract.
-
-- `mutiro agent host --mode=bridge` is spawned by the plugin, one process per configured Mutiro agent
-- NDJSON envelope traffic is translated into OpenClaw inbound messages and outbound send/react/forward actions
-- one subprocess per Mutiro agent, long-lived across conversations
-- all outbound chat actions go back through the bridge
+As adoption grows, we may expose the allowlist directly through the OpenClaw channel. For now it stays behind the `mutiro` CLI — a deliberate boundary that keeps access control outside the agent sandbox.
 
-## What Is Here
+## FAQ
 
-- `index.ts` — plugin entry via `defineBundledChannelEntry`
-- `src/bridge-protocol.ts` — NDJSON envelope constants and `@type` URLs
-- `src/bridge-messages.ts` — normalized message extraction and observed-turn assembly
-- `src/bridge-client.ts` — NDJSON envelope codec plus host subprocess spawn
-- `src/bridge-session.ts` — per-conversation observed/task/snapshot handlers
-- `src/inbound.ts` — bridge observed message → OpenClaw inbound envelope
-- `src/outbound.ts` — OpenClaw outbound adapter → `message.send` / `message.react` / `message.forward`
-- `src/channel.ts` — Mutiro channel plugin definition
-- `src/channel.runtime.ts` — runtime barrel consumed by the plugin entry
-- `src/setup-surface.ts` — setup wizard driven by `openclaw channels add` (pick `mutiro` from the list)
-- `src/agent-tools.ts` — `mutiro_send_voice_message`, `mutiro_send_card`, `mutiro_forward_message`
-- `src/signal-forwarder.ts` — OpenClaw tool events → Mutiro `signal.emit` (26-entry map)
-- `src/live-snapshot.ts` — `session.snapshot` + `task.request` handlers for live call handoff
-- `openclaw.plugin.json` — channel manifest
-- `run-brain.sh` — convenience launcher that boots OpenClaw's gateway against a Mutiro agent directory
-- `docs/guides/use-openclaw-as-brain.md` — end-to-end setup guide
-- `docs/guides/manage-allowlist.md` — paste-into-AI guide for Mutiro's server-side allowlist
+**How do I show the OpenClaw badge on my agent?**
 
-## Why This Exists
+Pass `--badge lobster` when creating the agent so every Mutiro client renders the lobster next to the avatar:
 
-Use this folder as a reference if you want to consume Mutiro's chatbridge from OpenClaw, or another gateway-shaped runtime that already owns its own channel/plugin contract.
-
-It shows how to:
-
-1. Spawn `mutiro agent host --mode=bridge` from inside an OpenClaw channel plugin
-2. Complete `ready → session.initialize → subscription.set`
-3. Receive `message.observed` and turn it into an OpenClaw inbound envelope
-4. Route OpenClaw outbound replies through bridge-local commands (`message.send`, `message.react`, `message.forward`, `media.upload`, `signal.emit`, `recall.search/get`)
-5. Finish turns with `turn.end`
-
-## Important Bridge Notes
-
-- `message.send` is a bridge-local command, not a raw backend `SendToConversationRequest`
-- the portable payload type is `mutiro.chatbridge.ChatBridgeSendMessageCommand`
-- `message.send_voice` is also bridge-local and keeps TTS inside the host
-- this reference usually replies by `conversation_id`
-- the bridge also supports `to_username` for direct sends
-
-## Adapter Model
-
-The plugin process is an OpenClaw channel. It:
-
-- spawns `mutiro agent host --mode=bridge` (one per configured Mutiro agent directory)
-- reads and writes bridge envelopes on stdio
-- delivers `message.observed` payloads as OpenClaw inbound messages
-- exposes outbound send/react/forward through the standard OpenClaw `ChannelOutboundAdapter`
-
-OpenClaw's agent runtime owns the brain layer. The plugin does not talk to Mutiro SDKs directly; everything portable flows through the chatbridge envelope.
-
-## Supported Bridge Operations
-
-This adapter exercises:
-
-- `message.send`
-- `message.send_voice`
-- `message.react`
-- `message.forward`
-- `media.upload`
-- `signal.emit`
-- `turn.end`
-- `recall.search`
-- `recall.get`
-
-## Session Model
-
-- one Mutiro `conversation_id` maps to one OpenClaw conversation binding
-- later turns in the same conversation reuse the same OpenClaw session, just as pi-brain reuses a Pi session
-- `session.snapshot` is answered from recent messages cached per-conversation in the plugin
-
-OpenClaw already owns transcript continuity across turns, so the plugin keeps its own cache narrow — just enough to answer `session.snapshot` for bridge consumers.
-
-## Handshake
-
-Startup flow:
-
-1. host sends `ready`
-2. plugin sends `session.initialize`
-3. plugin sends `subscription.set`
-4. host starts delivering `message.observed`
-
-Per turn:
-
-1. plugin acknowledges `message.observed`
-2. plugin dispatches the observed envelope into OpenClaw's inbound pipeline
-3. OpenClaw's reply-dispatch drives zero or more outbound bridge operations
-4. plugin sends `turn.end`
-
-## Debugging
-
-Useful signals while integrating:
-
-- `Handshake failed`
-  Bridge startup or negotiation problem.
-- `Host error`
-  A bridge request failed outside a pending request path.
-- `outbound bridge call failed`
-  The plugin reached the bridge and got a real host-side error.
+```bash
+mutiro agents create <username> "<Display>" --engine genie --badge lobster
+```
 
-## Type Checking
+For an agent that already exists, flip the badge on with:
 
 ```bash
-npm run check
+mutiro agents update-profile <agent-username> --badge lobster
 ```
 
-It runs with `skipLibCheck` because the OpenClaw plugin SDK's dependency tree includes external type issues that are not specific to this reference code.
+**I don't have a Mutiro agent yet — what's the fastest way to create one?**
+
+Paste this prompt into your AI assistant (Claude, Cursor, Windsurf, …):
+
+> Read https://mutiro.com/docs/guides/create-agent and help me create a Mutiro agent step by step. Use `--badge lobster` on `mutiro agents create` so the agent shows the OpenClaw badge.
 
-## What To Copy
+Or follow the [Mutiro create-agent guide](https://www.mutiro.com/docs/guides/create-agent) by hand.
 
-If you are integrating another gateway-shaped runtime, the most useful pieces to copy are:
+## Resources
 
-- bridge handshake flow (`src/bridge-session.ts` + `src/bridge-client.ts`)
-- pending-request correlation by `request_id`
-- `message.observed` acknowledgement behavior (ack delivery now, reply later)
-- per-conversation recent-message cache for `session.snapshot`
-- outbound operation wrappers (`src/outbound.ts`)
-- final `turn.end` behavior
+- [Use OpenClaw as brain](./docs/guides/use-openclaw-as-brain.md)
+- [Manage the Mutiro allowlist](./docs/guides/manage-allowlist.md)
+- [Mutiro manual](https://mutiro.com/docs/manual)
+- [Mutiro CLI reference](https://mutiro.com/docs/cli)
+- [OpenClaw documentation](https://openclaw.ai)
+- Sibling repo: [`pi-brain`](https://github.com/mutirolabs/pi-brain) — the Pi equivalent, a standalone bridge rather than an OpenClaw extension

package/dist/index.js

@@ -0,0 +1,20 @@
+// Plugin entry. Consumed by OpenClaw's bundled channel loader via the
+// `openclaw.extensions` field in package.json.
+//
+// `defineBundledChannelEntry` wires the channel plugin descriptor (loaded
+// from ./src/channel.ts) into OpenClaw's registry. The heavier runtime
+// module (./src/channel.runtime.ts) is loaded lazily from inside the channel
+// plugin itself (via `createLazyRuntimeNamedExport`), so we do not need to
+// register it here as a `PluginRuntime` setter.
+import { defineBundledChannelEntry } from "openclaw/plugin-sdk/channel-entry-contract";
+export default defineBundledChannelEntry({
+    id: "mutiro",
+    name: "Mutiro",
+    description: "The official Mutiro Channel extension for OpenClaw.",
+    importMetaUrl: import.meta.url,
+    plugin: {
+        specifier: "./src/channel.js",
+        exportName: "mutiroPlugin",
+    },
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,sEAAsE;AACtE,+CAA+C;AAC/C,EAAE;AACF,0EAA0E;AAC1E,uEAAuE;AACvE,6EAA6E;AAC7E,2EAA2E;AAC3E,gDAAgD;AAEhD,OAAO,EAAE,yBAAyB,EAAE,MAAM,4CAA4C,CAAC;AAEvF,eAAe,yBAAyB,CAAC;IACvC,EAAE,EAAE,QAAQ;IACZ,IAAI,EAAE,QAAQ;IACd,WAAW,EAAE,qDAAqD;IAClE,aAAa,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG;IAC9B,MAAM,EAAE;QACN,SAAS,EAAE,kBAAkB;QAC7B,UAAU,EAAE,cAAc;KAC3B;CACF,CAAC,CAAC"}

package/dist/src/actions.js

@@ -0,0 +1,40 @@
+// Message-action adapter for the shared `message` tool. Teaches OpenClaw
+// which actions our plugin handles (react, forward) and dispatches them
+// into the bridge via `channel.runtime.ts`. Without this adapter the tool
+// rejects with "Channel mutiro is unavailable for message actions".
+//
+// Kept compact: `describeMessageTool` returns a fixed action list, and
+// `handleAction` does a dynamic import so the heavy runtime stays off the
+// hot plugin-registration path.
+const MUTIRO_HANDLED_ACTIONS = [
+    "react",
+];
+const MUTIRO_HANDLED_ACTION_SET = new Set(MUTIRO_HANDLED_ACTIONS);
+const readStringArg = (params, ...keys) => {
+    for (const key of keys) {
+        const value = params[key];
+        if (typeof value === "string") {
+            const trimmed = value.trim();
+            if (trimmed)
+                return trimmed;
+        }
+    }
+    return undefined;
+};
+export const mutiroMessageActions = {
+    describeMessageTool: () => ({
+        actions: MUTIRO_HANDLED_ACTIONS,
+        capabilities: [],
+    }),
+    supportsAction: ({ action }) => MUTIRO_HANDLED_ACTION_SET.has(action),
+    handleAction: async (ctx) => {
+        const { handleMutiroMessageAction } = await import("./channel.runtime.js");
+        return handleMutiroMessageAction({
+            action: ctx.action,
+            params: ctx.params,
+            accountId: ctx.accountId ?? undefined,
+            readStringArg,
+        });
+    },
+};
+//# sourceMappingURL=actions.js.map

package/dist/src/actions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.js","sourceRoot":"","sources":["../../src/actions.ts"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,wEAAwE;AACxE,0EAA0E;AAC1E,oEAAoE;AACpE,EAAE;AACF,uEAAuE;AACvE,0EAA0E;AAC1E,gCAAgC;AAQhC,MAAM,sBAAsB,GAAwC;IAClE,OAAO;CACC,CAAC;AAEX,MAAM,yBAAyB,GAAG,IAAI,GAAG,CAA2B,sBAAsB,CAAC,CAAC;AAE5F,MAAM,aAAa,GAAG,CACpB,MAA+B,EAC/B,GAAG,IAAc,EACG,EAAE;IACtB,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;QAC1B,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YAC9B,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;YAC7B,IAAI,OAAO;gBAAE,OAAO,OAAO,CAAC;QAC9B,CAAC;IACH,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,oBAAoB,GAAgC;IAC/D,mBAAmB,EAAE,GAAG,EAAE,CAAC,CAAC;QAC1B,OAAO,EAAE,sBAAsB;QAC/B,YAAY,EAAE,EAAE;KACjB,CAAC;IAEF,cAAc,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,yBAAyB,CAAC,GAAG,CAAC,MAAM,CAAC;IAErE,YAAY,EAAE,KAAK,EAAE,GAAgC,EAAE,EAAE;QACvD,MAAM,EAAE,yBAAyB,EAAE,GAAG,MAAM,MAAM,CAAC,sBAAsB,CAAC,CAAC;QAC3E,OAAO,yBAAyB,CAAC;YAC/B,MAAM,EAAE,GAAG,CAAC,MAAM;YAClB,MAAM,EAAE,GAAG,CAAC,MAAM;YAClB,SAAS,EAAE,GAAG,CAAC,SAAS,IAAI,SAAS;YACrC,aAAa;SACd,CAAC,CAAC;IACL,CAAC;CACF,CAAC"}