@cortexkit/opencode-magic-context 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ualtinok
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,274 @@
+<h1 align="center">Magic Context</h1>
+
+<p align="center">
+  <strong>Cache-aware infinite context, cross-session memory, and background history compression for AI coding agents.</strong><br>
+  An <a href="https://github.com/anomalyco/opencode">OpenCode</a> plugin that keeps your agent's memory intact — no matter how long the session runs.
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@cortexkit/opencode-magic-context"><img src="https://img.shields.io/npm/v/@cortexkit/opencode-magic-context?color=blue&style=flat-square" alt="npm"></a>
+  <a href="https://github.com/cortexkit/opencode-magic-context/blob/master/LICENSE"><img src="https://img.shields.io/badge/license-MIT-green?style=flat-square" alt="MIT License"></a>
+</p>
+
+<p align="center">
+  <img src="docs/animation/out/optimized2.gif" alt="Magic Context in action" width="720">
+</p>
+
+<p align="center">
+  <a href="#get-started">Get Started</a> ·
+  <a href="#what-is-magic-context">What is Magic Context?</a> ·
+  <a href="#what-your-agent-gets">What Your Agent Gets</a> ·
+  <a href="#how-it-works">How It Works</a> ·
+  <a href="#commands">Commands</a> ·
+  <a href="#configuration">Configuration</a>
+</p>
+
+---
+
+## Get Started
+
+Add to your OpenCode config (`opencode.json` or `opencode.jsonc`):
+
+```jsonc
+{
+  "plugins": ["@cortexkit/opencode-magic-context@latest"]
+}
+```
+
+Magic Context conflicts with OpenCode's built-in compaction — the two cannot run together. To disable it:
+
+```jsonc
+{
+  "compaction": {
+    "auto": false,
+    "prune": false
+  }
+}
+```
+
+Create `magic-context.jsonc` in your project root, `.opencode/`, or `~/.config/opencode/`:
+
+```jsonc
+{
+  "enabled": true,
+
+  // Which model the historian uses for background compression, 
+  // Prefer providers that charge by request instead of tokens
+  "historian": {
+    "model": "github-copilot/gpt-5.4",
+    "fallback_models": ["opencode-go/glm-5"]
+  }
+}
+```
+
+That's it. Everything else has sensible defaults. Project config merges on top of user-wide settings.
+
+---
+
+## What is Magic Context?
+
+AI coding agents forget everything the moment a conversation gets long enough. Context windows fill up, old messages get dropped, and the agent loses track of decisions it made twenty minutes ago.
+
+Magic Context fixes this with a background historian — a separate, lightweight model that compresses older conversation into structured summaries and durable facts while the main agent keeps working. The agent never stops to summarize its own history. It never notices the rewriting happening beneath it.
+
+Every mutation is **cache-aware**. Drops and rewrites are queued until the provider's cached prefix expires, so you're not paying to throw away work that's already cached.
+
+Across sessions, architecture decisions, constraints, and preferences persist in a **cross-session memory** system. A new conversation starts with everything the previous one learned, without replaying old transcripts.
+
+And overnight, a **dreamer** agent consolidates, verifies, and improves memories — checking them against the actual codebase and merging duplicates into clean canonical facts.
+
+---
+
+## What Your Agent Gets
+
+Magic Context injects structured context automatically and gives the agent four tools.
+
+### `ctx_reduce` — Shed weight
+
+After tool-heavy turns (large grep results, file reads, bash output), the agent calls `ctx_reduce` to mark stale content for removal. Drops are queued — not applied immediately — until the cache expires or context pressure forces it.
+
+```
+ctx_reduce(drop="3-5,12")     // Drop tags 3, 4, 5, and 12
+```
+
+Recent tags (last 20 by default) are protected. Drops targeting them stay queued until they age out.
+
+### `ctx_expand` — Decompress history
+
+When the agent needs to recall details from a compressed history range, it can expand specific compartment ranges back to the original conversation transcript.
+
+```
+ctx_expand(start=100, end=200)   // Expand raw messages 100-200
+```
+
+Returns the same compact `U:`/`A:` transcript format the historian sees, capped at ~15K tokens per request. Use `start`/`end` from compartment attributes visible in `<session-history>`.
+
+### `ctx_note` — Deferred intentions
+
+Session notes are the agent's scratchpad for things to tackle later — not task tracking (that's what todos are for), but deferred work and reminders that should surface at the right time.
+
+```
+ctx_note(action="write", content="After this fix, check if the compressor budget formula is correct")
+ctx_note(action="read")
+```
+
+Notes surface automatically at natural work boundaries: after commits, after historian runs, and after all todos complete.
+
+### `ctx_memory` — Persistent cross-session knowledge
+
+Architecture decisions, naming conventions, user preferences — anything that should survive across conversations. Memories are project-scoped and automatically promoted from session facts by the historian.
+
+```
+ctx_memory(action="write", category="ARCHITECTURE_DECISIONS", content="Event sourcing for orders.")
+ctx_memory(action="search", query="authentication approach")
+ctx_memory(action="delete", id=42)
+```
+
+### Automatic context injection
+
+Every turn, Magic Context injects a `<session-history>` block containing:
+
+- **Project memories** — cross-session decisions, constraints, and preferences
+- **Compartments** — structured summaries replacing older raw history
+- **Session facts** — durable categorized facts from the current session
+
+This block is stable between historian runs. Memory writes persist immediately for search but don't change the injected block until the next historian run — so writes never bust the cache mid-conversation.
+
+---
+
+## How It Works
+
+### Tagging
+
+Every message, tool output, and file attachment gets a monotonically increasing `§N§` tag. The agent sees these inline and uses them to reference specific content when calling `ctx_reduce`. Tags persist in the database and resume across restarts.
+
+### Queued reductions
+
+When the agent calls `ctx_reduce`, drops go into a pending queue — not applied immediately. Two conditions trigger execution:
+
+- **Cache expired** — enough time has passed that the cached prefix is likely stale (configurable per model, default 5 minutes)
+- **Threshold reached** — context usage hits `execute_threshold_percentage` (default 65%)
+
+Between triggers, the conversation continues unchanged. The agent doesn't need to think about timing.
+
+### Background historian
+
+When local drops aren't buying enough headroom, Magic Context starts a historian — a separate lightweight model that reads an eligible prefix of raw history and produces:
+
+- **Compartments** — chronological blocks that replace older raw messages
+- **Facts** — durable decisions, constraints, and preferences (categorized)
+
+The historian runs asynchronously. The main agent never waits for it. When the historian finishes, its output is materialized on the next transform pass.
+
+A **separate compressor** pass fires when the rendered history block exceeds the configured history budget, merging the oldest compartments to keep the injected context lean.
+
+### Nudging
+
+As context usage grows, Magic Context sends rolling reminders suggesting the agent reduce. Cadence tightens as usage approaches the threshold — from gentle reminders to urgent warnings. If the agent recently called `ctx_reduce`, reminders are suppressed. An emergency nudge at 80% always fires.
+
+### Cross-session memory
+
+After each historian run, qualifying facts are promoted to the persistent memory store. On every subsequent turn, active memories are injected in `<session-history>`. New sessions inherit all project memories from previous sessions.
+
+Memories are searchable via `ctx_memory(action="search", ...)` using semantic embeddings (local by default) with full-text search as fallback.
+
+### Dreamer
+
+An optional background agent that maintains memory quality overnight:
+
+- **Consolidate** — merge semantically similar memories into canonical facts
+- **Verify** — check memories against current codebase (configs, paths, code patterns)
+- **Archive stale** — retire memories referencing removed features or old paths
+- **Improve** — rewrite verbose memories into terse operational form
+- **Maintain docs** — update ARCHITECTURE.md and STRUCTURE.md from codebase changes
+
+The dreamer runs during a configurable schedule window and creates ephemeral OpenCode child sessions for each task. Since it runs during idle time (typically overnight), it works well with local models — even slower ones like `ollama/mlx-qwen3.5-27b-claude-4.6-opus-reasoning-distilled` are fine since there's no user waiting.
+
+---
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `/ctx-status` | Debug view: tags, pending drops, cache TTL, nudge state, historian progress, compartment coverage, history compression budget |
+| `/ctx-flush` | Force all queued operations immediately, bypassing cache TTL |
+| `/ctx-recomp` | Rebuild compartments and facts from raw history — use when stored state seems wrong |
+| `/ctx-aug` | Run sidekick augmentation on a prompt — retrieves relevant memories via a separate model |
+| `/ctx-dream` | Run dreamer maintenance on demand — consolidate, verify, archive, improve memories |
+
+---
+
+## Configuration
+
+All settings live in `magic-context.jsonc` as flat top-level keys. See **[CONFIGURATION.md](./CONFIGURATION.md)** for the full reference — cache TTL tuning, per-model execute thresholds, historian model selection, embedding providers, memory settings, sidekick, and dreamer.
+
+**Config locations** (merged in order, project overrides user):
+1. `<project-root>/magic-context.jsonc`
+2. `<project-root>/.opencode/magic-context.jsonc`
+3. `~/.config/opencode/magic-context.jsonc`
+
+---
+
+## Storage
+
+All durable states live in a local SQLite database. If the database can't be opened, Magic Context disables itself and notifies the user.
+
+```
+~/.local/share/opencode/storage/plugin/magic-context/context.db
+```
+
+| Table | Purpose |
+|-------|---------|
+| `tags` | Tag assignments — message ID, tag number, session, status |
+| `pending_ops` | Queued drop operations |
+| `source_contents` | Raw content snapshots for persisted reductions |
+| `compartments` | Historian-produced structured history blocks |
+| `session_facts` | Categorized durable facts from historian runs |
+| `session_notes` | Session-scoped `ctx_note` content |
+| `session_meta` | Per-session state — usage, nudge flags, anchors |
+| `memories` | Cross-session persistent memories |
+| `memory_embeddings` | Embedding vectors for semantic search |
+| `dream_state` | Dreamer lease locking and task progress |
+| `dream_queue` | Queued projects awaiting dream processing |
+| `recomp_compartments` | Staging for `/ctx-recomp` partial progress |
+| `recomp_facts` | Staging for `/ctx-recomp` partial progress |
+
+---
+
+## Development
+
+**Requirements:** [Bun](https://bun.sh) ≥ 1.0
+
+```sh
+bun install              # Install dependencies
+bun run build            # Build the plugin
+bun run typecheck        # Type-check without emitting
+bun test                 # Run tests
+bun run lint             # Lint (Biome)
+bun run lint:fix         # Lint with auto-fix
+bun run format           # Format (Biome)
+```
+
+**Utility scripts:**
+
+```sh
+bun scripts/tail-view.ts             # Show post-compartment message tail
+bun scripts/context-dump.ts          # Dump full context state for a session
+bun scripts/backfill-embeddings.ts   # Backfill missing memory embeddings
+```
+
+Dream execution requires a live OpenCode server — the dreamer creates ephemeral child sessions. Use `/ctx-dream` inside OpenCode for on-demand maintenance.
+
+---
+
+## Contributing
+
+Bug reports and pull requests are welcome. For larger changes, open an issue first to discuss the approach.
+
+Run `bun run format` before submitting — CI rejects unformatted code.
+
+---
+
+## License
+
+[MIT](LICENSE)

package/dist/agents/builtin-agents.d.ts

@@ -0,0 +1,8 @@
+export interface BuiltinAgentDefinition {
+    id: string;
+    category: "utility";
+    description: string;
+    hidden: boolean;
+}
+export declare const BUILTIN_AGENTS: BuiltinAgentDefinition[];
+//# sourceMappingURL=builtin-agents.d.ts.map

package/dist/agents/builtin-agents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtin-agents.d.ts","sourceRoot":"","sources":["../../src/agents/builtin-agents.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,sBAAsB;IACnC,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,SAAS,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,OAAO,CAAC;CACnB;AAED,eAAO,MAAM,cAAc,EAAE,sBAAsB,EAalD,CAAC"}

package/dist/agents/dreamer.d.ts

@@ -0,0 +1,2 @@
+export declare const DREAMER_AGENT = "dreamer";
+//# sourceMappingURL=dreamer.d.ts.map

package/dist/agents/dreamer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dreamer.d.ts","sourceRoot":"","sources":["../../src/agents/dreamer.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,YAAY,CAAC"}

package/dist/agents/historian.d.ts

@@ -0,0 +1,2 @@
+export declare const HISTORIAN_AGENT = "historian";
+//# sourceMappingURL=historian.d.ts.map

package/dist/agents/historian.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"historian.d.ts","sourceRoot":"","sources":["../../src/agents/historian.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,eAAe,cAAc,CAAC"}

package/dist/agents/magic-context-prompt.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Per-agent magic context system prompt sections.
+ * Each agent gets tailored guidance based on its workflow patterns.
+ */
+type AgentType = "sisyphus" | "atlas" | "hephaestus" | "sisyphus-junior" | "oracle" | "athena" | "athena-junior";
+/**
+ * Detect which agent is active by scanning the system prompt for known signatures.
+ * Returns the detected agent type or null for unknown agents.
+ * Order matters — more specific signatures (e.g., "Sisyphus-Junior") are checked first.
+ */
+export declare function detectAgentFromSystemPrompt(systemPrompt: string): AgentType | null;
+export declare function buildMagicContextSection(agent: AgentType | null, protectedTags: number): string;
+export {};
+//# sourceMappingURL=magic-context-prompt.d.ts.map

package/dist/agents/magic-context-prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"magic-context-prompt.d.ts","sourceRoot":"","sources":["../../src/agents/magic-context-prompt.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,KAAK,SAAS,GACR,UAAU,GACV,OAAO,GACP,YAAY,GACZ,iBAAiB,GACjB,QAAQ,GACR,QAAQ,GACR,eAAe,CAAC;AA8JtB;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,YAAY,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAOlF;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CAQ/F"}

package/dist/agents/sidekick.d.ts

@@ -0,0 +1,2 @@
+export declare const SIDEKICK_AGENT = "sidekick";
+//# sourceMappingURL=sidekick.d.ts.map

package/dist/agents/sidekick.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sidekick.d.ts","sourceRoot":"","sources":["../../src/agents/sidekick.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,aAAa,CAAC"}

package/dist/agents/types.d.ts

@@ -0,0 +1,19 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+export type AgentMode = "primary" | "subagent" | "all";
+export interface AgentPromptMetadata {
+    category: "exploration" | "specialist" | "advisor" | "utility";
+    cost: "FREE" | "CHEAP" | "EXPENSIVE";
+    triggers: Array<{
+        domain: string;
+        trigger: string;
+    }>;
+    useWhen?: string[];
+    avoidWhen?: string[];
+    dedicatedSection?: string;
+    promptAlias?: string;
+    keyTrigger?: string;
+}
+export type AgentFactory = ((model?: string) => AgentConfig) & {
+    mode: AgentMode;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/agents/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/agents/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,MAAM,MAAM,SAAS,GAAG,SAAS,GAAG,UAAU,GAAG,KAAK,CAAC;AAEvD,MAAM,WAAW,mBAAmB;IAChC,QAAQ,EAAE,aAAa,GAAG,YAAY,GAAG,SAAS,GAAG,SAAS,CAAC;IAC/D,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,WAAW,CAAC;IACrC,QAAQ,EAAE,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACrD,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,EAAE,MAAM,KAAK,WAAW,CAAC,GAAG;IAC3D,IAAI,EAAE,SAAS,CAAC;CACnB,CAAC"}

package/dist/cli/model-fallback-requirements.d.ts

@@ -0,0 +1,2 @@
+export declare function getAgentModelFallbackRequirements(agent: string): string[] | undefined;
+//# sourceMappingURL=model-fallback-requirements.d.ts.map

package/dist/cli/model-fallback-requirements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-fallback-requirements.d.ts","sourceRoot":"","sources":["../../src/cli/model-fallback-requirements.ts"],"names":[],"mappings":"AAEA,wBAAgB,iCAAiC,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAErF"}

package/dist/config/index.d.ts

@@ -0,0 +1,13 @@
+import { type MagicContextConfig } from "./schema/magic-context";
+export interface MagicContextPluginConfig extends MagicContextConfig {
+    disabled_hooks?: string[];
+    command?: Record<string, {
+        template: string;
+        description?: string;
+        agent?: string;
+        model?: string;
+        subtask?: boolean;
+    }>;
+}
+export declare function loadPluginConfig(directory: string): MagicContextPluginConfig;
+//# sourceMappingURL=index.d.ts.map

package/dist/config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,kBAAkB,EAA4B,MAAM,wBAAwB,CAAC;AAE3F,MAAM,WAAW,wBAAyB,SAAQ,kBAAkB;IAChE,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,OAAO,CAAC,EAAE,MAAM,CACZ,MAAM,EACN;QACI,QAAQ,EAAE,MAAM,CAAC;QACjB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,OAAO,CAAC,EAAE,OAAO,CAAC;KACrB,CACJ,CAAC;CACL;AA4FD,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,wBAAwB,CAsB5E"}

package/dist/config/schema/agent-overrides.d.ts

@@ -0,0 +1,55 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import { z } from "zod";
+export declare const MAGIC_CONTEXT_AGENT_OVERRIDE_KEYS: readonly ["historian", "dreamer", "sidekick"];
+export declare const AgentOverrideConfigSchema: z.ZodObject<{
+    model: z.ZodOptional<z.ZodString>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    top_p: z.ZodOptional<z.ZodNumber>;
+    prompt: z.ZodOptional<z.ZodString>;
+    tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+    disable: z.ZodOptional<z.ZodBoolean>;
+    description: z.ZodOptional<z.ZodString>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        subagent: "subagent";
+        primary: "primary";
+        all: "all";
+    }>>;
+    color: z.ZodOptional<z.ZodString>;
+    maxSteps: z.ZodOptional<z.ZodNumber>;
+    permission: z.ZodOptional<z.ZodObject<{
+        edit: z.ZodOptional<z.ZodEnum<{
+            ask: "ask";
+            allow: "allow";
+            deny: "deny";
+        }>>;
+        bash: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            ask: "ask";
+            allow: "allow";
+            deny: "deny";
+        }>, z.ZodRecord<z.ZodString, z.ZodEnum<{
+            ask: "ask";
+            allow: "allow";
+            deny: "deny";
+        }>>]>>;
+        webfetch: z.ZodOptional<z.ZodEnum<{
+            ask: "ask";
+            allow: "allow";
+            deny: "deny";
+        }>>;
+        doom_loop: z.ZodOptional<z.ZodEnum<{
+            ask: "ask";
+            allow: "allow";
+            deny: "deny";
+        }>>;
+        external_directory: z.ZodOptional<z.ZodEnum<{
+            ask: "ask";
+            allow: "allow";
+            deny: "deny";
+        }>>;
+    }, z.core.$strip>>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+    variant: z.ZodOptional<z.ZodString>;
+    fallback_models: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+}, z.core.$strip>;
+export type AgentOverrideConfig = z.infer<typeof AgentOverrideConfigSchema> & Partial<AgentConfig>;
+//# sourceMappingURL=agent-overrides.d.ts.map

package/dist/config/schema/agent-overrides.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-overrides.d.ts","sourceRoot":"","sources":["../../../src/config/schema/agent-overrides.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,iCAAiC,+CAAgD,CAAC;AAgB/F,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkBpC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC"}