agent-inbox 0.0.1 → 0.1.1

package/CLAUDE.md

@@ -0,0 +1,113 @@
+# CLAUDE.md — Agent Guide for agent-inbox
+
+## What this repo is
+
+Agent Inbox is a MAP-native message router for multi-agent systems. It provides structured inbox/outbox semantics, threading, delivery tracking, and cross-system federation on top of MAP (Multi-Agent Protocol) transport.
+
+## Build and test
+
+```bash
+npm install           # Install dependencies
+npm run build         # TypeScript compile (tsc)
+npm test              # Run all tests (vitest)
+npm run test:watch    # Watch mode
+```
+
+All tests use vitest. Run the full suite before committing — there are 210+ tests across 16 files. Tests run fast (<2s total).
+
+## Project layout
+
+```
+src/
+  index.ts                      Entry point — wires storage, router, federation, IPC, MCP, MAP
+  types.ts                      All type definitions (Message, Agent, Federation types, etc.)
+  storage/interface.ts          Storage interface (getAgent, putMessage, getInbox, etc.)
+  storage/memory.ts             InMemoryStorage — Map-based, used in all tests
+  storage/sqlite.ts             SQLiteStorage — persistent with FTS5 search
+  router/message-router.ts      Core routing: resolveRecipients, normalizeContent, routeMessage
+  federation/
+    connection-manager.ts       Manages MAP connections + federation peer links + queue flush
+    routing-engine.ts           Table/broadcast/hierarchical routing strategies
+    delivery-queue.ts           Offline message queue with TTL, retry, overflow policies
+    address.ts                  Parse "agent@system" addresses (parseAddress, isRemoteAddress)
+    trust.ts                    Allow-list federation trust (canConnect, canRoute stubs)
+  registry/warm-registry.ts     Agent lifecycle: active → away → expired with TTL timers
+  traceability/traceability.ts  Auto-create conversations/turns/threads from message events
+  ipc/ipc-server.ts             UNIX socket server (NDJSON protocol)
+  map/map-client.ts             MAP SDK wrapper (dynamic import, optional peer dependency)
+  mcp/mcp-server.ts             MCP tool server (send_message, check_inbox, read_thread, list_agents)
+  jsonrpc/mail-server.ts        MAP JSON-RPC mail methods
+  push/notifier.ts              Push notification support
+
+test/
+  federation/                   Federation tests (connection-manager, routing, queue, address, trust, integration, sdk-integration)
+  registry/                     Warm registry tests
+  *.test.ts                     Core tests (storage, router, traceability, IPC, mail-server, push)
+```
+
+## Key architecture concepts
+
+### Message flow
+
+1. Message comes in via IPC socket, MCP tool, or MAP connection
+2. `MessageRouter.routeMessage()` resolves recipients, normalizes content, stores the message
+3. Local recipients: message stored in their inbox via storage
+4. Remote recipients (`agent@system`): delegated to `ConnectionManager.route()`
+5. Federation sends via MAP SDK transport (or queues if peer is offline)
+6. Traceability layer auto-creates conversations/threads from events
+
+### Federation addressing
+
+- `"bob"` — local agent
+- `"bob@system-2"` — agent on a federated system
+- `"@system-2"` — broadcast to system
+
+Parsed by `parseAddress()` in `src/federation/address.ts`.
+
+### Storage interface
+
+All storage operations go through `Storage` interface (`src/storage/interface.ts`). Two implementations: `InMemoryStorage` (tests + ephemeral) and `SQLiteStorage` (persistent). Tests always use `InMemoryStorage`.
+
+### MAP SDK is optional
+
+The `@multi-agent-protocol/sdk` is a peer dependency loaded dynamically in `src/map/map-client.ts`. Agent Inbox works without it (IPC + MCP only, no MAP transport). The SDK class is injected into `ConnectionManager` when available.
+
+### Event-driven internals
+
+Components communicate via `EventEmitter`. Key events:
+- `message.created` — emitted by router, consumed by traceability
+- `federation.route` — emitted when no transport, for testing
+- `federation.message.received` — incoming federation message
+- `federation.broadcast` — broadcast strategy fired
+- `routing.updated` — routing table changed
+
+## Conventions
+
+- **TypeScript strict mode**, ESM output
+- **vitest** for all tests — no jest
+- **No mocking frameworks** — tests use hand-rolled mocks and the `InMemoryStorage` directly
+- IDs generated with `ulid` or `crypto.randomUUID()`
+- Content normalization: string payloads auto-wrapped to `{ type: "text", text: "..." }`
+- Federation tests use `MockMapServer` (in-process broker) in `test/federation/sdk-integration.test.ts`
+
+## Known design gaps
+
+- **Broadcast/hierarchical routing strategies** are unreachable through `ConnectionManager.route()` for system-qualified addresses (`bob@system-2`). `resolveRoute()` always returns `addr.system` directly, never falling through to `handleUnknownRoute()`. Agent-only addresses that would trigger it are filtered by `isRemoteAddress()`. Documented in `test/federation/integration.test.ts` and `test/federation/sdk-integration.test.ts`.
+
+## Common tasks
+
+### Adding a new MCP tool
+1. Add tool definition in `src/mcp/mcp-server.ts`
+2. Implement handler that delegates to router/storage
+3. Add test in `test/` (currently no dedicated mcp test file — tools tested through integration)
+
+### Adding a new federation feature
+1. Types go in `src/types.ts`
+2. Logic in `src/federation/` (connection-manager, routing-engine, etc.)
+3. Unit test in `test/federation/`
+4. Integration test in `test/federation/integration.test.ts` or `test/federation/sdk-integration.test.ts`
+
+### Adding a new storage method
+1. Add to interface in `src/storage/interface.ts`
+2. Implement in both `memory.ts` and `sqlite.ts`
+3. Test in `test/storage.test.ts` and `test/sqlite-storage.test.ts`

package/README.md

@@ -1 +1,195 @@
-# agent-inbox
+# Agent Inbox
+
+A MAP-native message router for multi-agent systems. Provides structured inbox/outbox semantics, message threading, delivery tracking, and cross-system federation on top of the [Multi-Agent Protocol](https://github.com/anthropics/multi-agent-protocol) transport layer.
+
+Built to work with [claude-code-swarm](https://github.com/alexngai/claude-code-swarm) and any MAP-compatible agent framework.
+
+## What it does
+
+- **Message routing** — Send messages between agents with `to`, `cc`, `bcc` semantics. Messages are stored in per-agent inboxes with delivery and read tracking.
+- **Threading** — Messages can be grouped by `thread_tag` and linked via `in_reply_to` for conversation threading.
+- **Traceability** — Auto-creates conversations, turns, and threads from messaging events following MAP's mail conventions.
+- **Federation** — Route messages across independent systems via MAP federation. Supports configurable routing strategies (table, broadcast, hierarchical).
+- **Multiple interfaces** — IPC (UNIX socket), MCP tools (stdio), MAP JSON-RPC, and push notifications.
+
+## Architecture
+
+```
+Claude Code Session
+  |
+  Plugin (map-hook.mjs)
+  |
+  +-- spawn/done/trajectory --> MAP Sidecar (lifecycle)
+  |
+  +-- send/emit (messaging) --> Agent Inbox (routing + storage)
+                                  |
+                                  +-- Local delivery (same system)
+                                  +-- Federation (cross-system via MAP)
+```
+
+Agent Inbox runs as an independent service alongside the MAP sidecar. The plugin dispatches messaging commands to Agent Inbox and lifecycle commands to the sidecar.
+
+## Quick start
+
+```bash
+npm install
+npm run build
+npm start
+```
+
+### Environment variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `INBOX_SOCKET_PATH` | `~/.claude/agent-inbox/inbox.sock` | IPC socket path |
+| `INBOX_SCOPE` | `default` | Default message scope |
+| `INBOX_SYSTEM_ID` | auto-generated | System identity for federation |
+| `MAP_SERVER_URL` | — | MAP server URL (optional) |
+| `MAP_AGENT_NAME` | `agent-inbox` | Agent name for MAP connection |
+
+### As an MCP tool server
+
+Agent Inbox exposes 4 MCP tools that agents can call directly:
+
+| Tool | Description |
+|------|-------------|
+| `send_message` | Send a message to one or more agents (supports replies via `inReplyTo`) |
+| `check_inbox` | Check an agent's inbox for unread messages (auto-registers the agent) |
+| `read_thread` | Read all messages in a thread by `threadTag` |
+| `list_agents` | List registered agents (local and optionally federated) |
+
+### IPC protocol
+
+NDJSON over UNIX socket. Commands:
+
+```json
+{"action": "send", "from": "alice", "to": "bob", "payload": "Hello"}
+{"action": "notify", "event": {"type": "agent.spawn", "agent": {...}}}
+{"action": "ping"}
+```
+
+### MAP JSON-RPC
+
+When connected to a MAP server, Agent Inbox registers JSON-RPC methods:
+
+- `mail/send` — Send a message
+- `mail/inbox` — Check inbox
+- `mail/thread` — Read a thread
+- `mail/ack` — Acknowledge a message
+- `mail/search` — Full-text search (requires SQLite storage)
+
+## Federation
+
+Agents on different systems can message each other using `agent@system` addressing:
+
+```
+alice@system-1  -->  bob@system-2
+```
+
+### Configuration
+
+Federation peers are configured explicitly:
+
+```typescript
+await inbox.federate({
+  systemId: "partner-system",
+  url: "ws://partner.example.com:3001",
+  exposure: { agents: "all" },
+});
+```
+
+### Routing strategies
+
+| Strategy | Behavior |
+|----------|----------|
+| `table` (default) | In-memory routing table populated from peer exposure data. TTL-based expiry. |
+| `broadcast` | Forward to all connected peers. First responder wins. |
+| `hierarchical` | Local table first, then delegate to upstream hubs. |
+
+### Trust
+
+Federation connections are gated by an allow-list. Only systems in `allowedServers` can establish federation links.
+
+### Delivery queue
+
+Messages to offline peers are queued with configurable TTL, overflow policy, and retry strategy. Queues flush automatically on reconnect.
+
+## Storage
+
+Two storage backends:
+
+- **InMemoryStorage** — Default. Fast, no dependencies. Data lost on restart.
+- **SQLiteStorage** — Persistent storage with FTS5 full-text search. Requires `better-sqlite3`.
+
+## Project structure
+
+```
+src/
+  index.ts                      Entry point — wires all components
+  types.ts                      Core type definitions
+  storage/
+    interface.ts                Storage interface
+    memory.ts                   In-memory implementation
+    sqlite.ts                   SQLite implementation (persistent + FTS5)
+  router/
+    message-router.ts           Message routing: resolve recipients, local vs remote
+  federation/
+    connection-manager.ts       MAP connections + federation peer management
+    routing-engine.ts           Configurable routing (table/broadcast/hierarchical)
+    delivery-queue.ts           Offline message queue with TTL + retry
+    address.ts                  Parse/resolve agent@system addresses
+    trust.ts                    Federation trust policies (allow-list)
+  registry/
+    warm-registry.ts            Agent lifecycle: active/away/expired + TTL
+  traceability/
+    traceability.ts             Auto-create conversations/turns/threads
+  ipc/
+    ipc-server.ts               UNIX socket server (NDJSON protocol)
+  map/
+    map-client.ts               MAP SDK connection wrapper
+  mcp/
+    mcp-server.ts               MCP tool server (stdio transport)
+  jsonrpc/
+    mail-server.ts              MAP JSON-RPC mail methods
+  push/
+    notifier.ts                 Push notification support
+```
+
+## Testing
+
+```bash
+npm test              # Run all tests
+npm run test:watch    # Watch mode
+```
+
+210 tests across 16 test files covering:
+
+- Storage (in-memory + SQLite)
+- Message routing and content normalization
+- Traceability (auto-conversation/thread creation)
+- IPC server (NDJSON protocol, concurrent clients)
+- Federation (connection manager, routing engine, delivery queue, address parsing, trust)
+- Federation integration (end-to-end multi-system scenarios)
+- SDK integration (two-system tests with in-process mock MAP server)
+- MAP JSON-RPC mail methods
+- Warm agent registry lifecycle
+- Push notifications
+
+## Development
+
+```bash
+npm run dev           # TypeScript watch mode
+npm test              # Run tests
+npm run build         # Production build
+```
+
+Requires Node.js >= 18.
+
+## Further reading
+
+- [docs/DESIGN.md](docs/DESIGN.md) — Detailed architecture and design decisions
+- [docs/PLAN.md](docs/PLAN.md) — Implementation plan and phasing
+
+## License
+
+MIT

package/dist/federation/address.d.ts

@@ -0,0 +1,24 @@
+import type { FederatedAddress } from "../types.js";
+/**
+ * Parse a federated address string into its components.
+ *
+ * Formats:
+ *   "agent-id"              → { agent: "agent-id" }               (local)
+ *   "agent-id@system-id"    → { agent: "agent-id", system: "system-id" } (federated)
+ *   "@system-id"            → { system: "system-id" }             (broadcast to system)
+ *   "agent-id@system/scope" → { agent: "agent-id", system: "system", scope: "scope" }
+ */
+export declare function parseAddress(address: string): FederatedAddress;
+/**
+ * Serialize a FederatedAddress back to string form.
+ */
+export declare function formatAddress(addr: FederatedAddress): string;
+/**
+ * Check if an address targets a remote system.
+ */
+export declare function isRemoteAddress(addr: FederatedAddress): boolean;
+/**
+ * Check if an address is a broadcast (no specific agent).
+ */
+export declare function isBroadcastAddress(addr: FederatedAddress): boolean;
+//# sourceMappingURL=address.d.ts.map

package/dist/federation/address.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"address.d.ts","sourceRoot":"","sources":["../../src/federation/address.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,gBAAgB,CAqB9D;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,gBAAgB,GAAG,MAAM,CAS5D;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAE/D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAElE"}

package/dist/federation/address.js

@@ -0,0 +1,54 @@
+/**
+ * Parse a federated address string into its components.
+ *
+ * Formats:
+ *   "agent-id"              → { agent: "agent-id" }               (local)
+ *   "agent-id@system-id"    → { agent: "agent-id", system: "system-id" } (federated)
+ *   "@system-id"            → { system: "system-id" }             (broadcast to system)
+ *   "agent-id@system/scope" → { agent: "agent-id", system: "system", scope: "scope" }
+ */
+export function parseAddress(address) {
+    const atIdx = address.indexOf("@");
+    if (atIdx === -1) {
+        // No @ — local address
+        return { agent: address };
+    }
+    const agent = atIdx > 0 ? address.slice(0, atIdx) : undefined;
+    const rest = address.slice(atIdx + 1);
+    // Check for scope separator (/)
+    const slashIdx = rest.indexOf("/");
+    if (slashIdx === -1) {
+        return { agent, system: rest };
+    }
+    return {
+        agent,
+        system: rest.slice(0, slashIdx),
+        scope: rest.slice(slashIdx + 1),
+    };
+}
+/**
+ * Serialize a FederatedAddress back to string form.
+ */
+export function formatAddress(addr) {
+    let result = addr.agent ?? "";
+    if (addr.system) {
+        result += `@${addr.system}`;
+        if (addr.scope) {
+            result += `/${addr.scope}`;
+        }
+    }
+    return result;
+}
+/**
+ * Check if an address targets a remote system.
+ */
+export function isRemoteAddress(addr) {
+    return addr.system !== undefined;
+}
+/**
+ * Check if an address is a broadcast (no specific agent).
+ */
+export function isBroadcastAddress(addr) {
+    return addr.system !== undefined && addr.agent === undefined;
+}
+//# sourceMappingURL=address.js.map

package/dist/federation/address.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"address.js","sourceRoot":"","sources":["../../src/federation/address.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,MAAM,UAAU,YAAY,CAAC,OAAe;IAC1C,MAAM,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IACnC,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC;QACjB,uBAAuB;QACvB,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;IAC5B,CAAC;IAED,MAAM,KAAK,GAAG,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAC9D,MAAM,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;IAEtC,gCAAgC;IAChC,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IACnC,IAAI,QAAQ,KAAK,CAAC,CAAC,EAAE,CAAC;QACpB,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;IACjC,CAAC;IAED,OAAO;QACL,KAAK;QACL,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,QAAQ,CAAC;QAC/B,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ,GAAG,CAAC,CAAC;KAChC,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,aAAa,CAAC,IAAsB;IAClD,IAAI,MAAM,GAAG,IAAI,CAAC,KAAK,IAAI,EAAE,CAAC;IAC9B,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;QAChB,MAAM,IAAI,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;QAC5B,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;QAC7B,CAAC;IACH,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,eAAe,CAAC,IAAsB;IACpD,OAAO,IAAI,CAAC,MAAM,KAAK,SAAS,CAAC;AACnC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,kBAAkB,CAAC,IAAsB;IACvD,OAAO,IAAI,CAAC,MAAM,KAAK,SAAS,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,CAAC;AAC/D,CAAC"}

package/dist/federation/connection-manager.d.ts

@@ -0,0 +1,118 @@
+import { EventEmitter } from "node:events";
+import type { FederationConfig, FederationLink, FederationPeerConfig, Message, SystemId } from "../types.js";
+import type { MapAgentConnectionClass } from "../map/map-client.js";
+import { RoutingEngine } from "./routing-engine.js";
+import { DeliveryQueue } from "./delivery-queue.js";
+import { TrustManager } from "./trust.js";
+export interface DeliveryResult {
+    delivered: boolean;
+    peerId?: string;
+    queued?: boolean;
+    error?: string;
+}
+/**
+ * Callback for handling incoming federation messages.
+ * Wired to router.routeMessage() by index.ts.
+ */
+export type IncomingMessageHandler = (incoming: {
+    from: string;
+    peerId: string;
+    payload: unknown;
+    meta?: Record<string, unknown>;
+}) => void;
+/**
+ * Manages MAP connections and federation peer links.
+ *
+ * Coordinates routing, delivery queuing, and trust enforcement
+ * for cross-system messaging. When an SDK connect function is provided,
+ * opens real MAP connections to federation peers for actual message transport.
+ */
+export declare class ConnectionManager {
+    private events;
+    private config;
+    private peers;
+    private connections;
+    private systemId;
+    private sdkClass;
+    private onIncoming;
+    readonly routing: RoutingEngine;
+    readonly queue: DeliveryQueue;
+    readonly trust: TrustManager;
+    constructor(events: EventEmitter, config?: FederationConfig, opts?: {
+        sdkClass?: MapAgentConnectionClass;
+        onIncomingMessage?: IncomingMessageHandler;
+    });
+    /**
+     * Get the resolved system ID for this Agent Inbox instance.
+     */
+    getSystemId(): SystemId;
+    /**
+     * Establish federation with a peer. Uses MAP federation/connect protocol.
+     * If an SDK class was injected, opens a real MAP connection to the peer.
+     * Returns the federation link, or throws if trust check fails.
+     */
+    federate(peer: FederationPeerConfig): Promise<FederationLink>;
+    /**
+     * Disconnect from a federation peer.
+     * Closes the real MAP connection if one exists.
+     */
+    disconnect(peerId: string): Promise<void>;
+    /**
+     * Route a message to the correct federation peer.
+     * Resolves the address, checks trust, and delivers or queues.
+     * If a real connection exists, sends via conn.send(); otherwise emits event.
+     */
+    route(message: Message): Promise<DeliveryResult>;
+    /**
+     * Send a message to a peer via real connection or event emission.
+     * Returns true if send succeeded (or event was emitted).
+     */
+    private sendToPeer;
+    /**
+     * Handle an incoming message from a federation peer connection.
+     * Delegates to the injected message handler (wired to router.routeMessage).
+     */
+    private handlePeerMessage;
+    /**
+     * Handle routing to an unknown agent. Behavior depends on strategy.
+     */
+    private handleUnknownRoute;
+    /**
+     * Get all federation peer links.
+     */
+    getPeers(): FederationLink[];
+    /**
+     * Get only connected peers.
+     */
+    getConnectedPeers(): FederationLink[];
+    /**
+     * Get a specific peer link.
+     */
+    getPeer(peerId: string): FederationLink | undefined;
+    /**
+     * Check if a peer is connected.
+     */
+    isConnected(peerId: string): boolean;
+    /**
+     * Check if a real MAP SDK connection exists for a peer.
+     */
+    hasTransport(peerId: string): boolean;
+    /**
+     * Clean up all state. Call on shutdown.
+     */
+    destroy(): Promise<void>;
+    /**
+     * Resolve the system ID using tiered precedence:
+     * 1. Explicit config (INBOX_SYSTEM_ID)
+     * 2. Auto-generated (persisted to file for stability across restarts)
+     *
+     * Note: Tier 2 (MAP systemInfo) is handled after MAP connection is established.
+     */
+    private resolveSystemId;
+    /**
+     * Update system ID from MAP server's systemInfo (Tier 2).
+     * Only used if no explicit config was set.
+     */
+    updateSystemIdFromMap(mapSystemName: string): void;
+}
+//# sourceMappingURL=connection-manager.d.ts.map

package/dist/federation/connection-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-manager.d.ts","sourceRoot":"","sources":["../../src/federation/connection-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAK3C,OAAO,KAAK,EAEV,gBAAgB,EAChB,cAAc,EACd,oBAAoB,EACpB,OAAO,EACP,QAAQ,EACT,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAEV,uBAAuB,EAExB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG1C,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,QAAQ,EAAE;IAC9C,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC,KAAK,IAAI,CAAC;AAEX;;;;;;GAMG;AACH,qBAAa,iBAAiB;IAW1B,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,MAAM;IAXhB,OAAO,CAAC,KAAK,CAAqC;IAClD,OAAO,CAAC,WAAW,CAAoC;IACvD,OAAO,CAAC,QAAQ,CAAW;IAC3B,OAAO,CAAC,QAAQ,CAAiC;IACjD,OAAO,CAAC,UAAU,CAAgC;IAClD,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;gBAGnB,MAAM,EAAE,YAAY,EACpB,MAAM,GAAE,gBAAqB,EACrC,IAAI,CAAC,EAAE;QACL,QAAQ,CAAC,EAAE,uBAAuB,CAAC;QACnC,iBAAiB,CAAC,EAAE,sBAAsB,CAAC;KAC5C;IA6BH;;OAEG;IACH,WAAW,IAAI,QAAQ;IAIvB;;;;OAIG;IACG,QAAQ,CAAC,IAAI,EAAE,oBAAoB,GAAG,OAAO,CAAC,cAAc,CAAC;IAyDnE;;;OAGG;IACG,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAqB/C;;;;OAIG;IACG,KAAK,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,cAAc,CAAC;IA6CtD;;;OAGG;YACW,UAAU;IAkCxB;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAazB;;OAEG;YACW,kBAAkB;IA0DhC;;OAEG;IACH,QAAQ,IAAI,cAAc,EAAE;IAI5B;;OAEG;IACH,iBAAiB,IAAI,cAAc,EAAE;IAMrC;;OAEG;IACH,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS;IAInD;;OAEG;IACH,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAIpC;;OAEG;IACH,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAIrC;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAgB9B;;;;;;OAMG;IACH,OAAO,CAAC,eAAe;IAgCvB;;;OAGG;IACH,qBAAqB,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI;CAKnD"}