@lloyal-labs/lloyal-agents 1.0.0 → 1.2.0

package/README.md

@@ -1,20 +1,21 @@
 # @lloyal-labs/lloyal-agents
 
-Structured concurrency agent runtime for the lloyal inference platform.
+Continuous Context agent runtime.
 
-`lloyal-agents` runs multi-agent inference inside the decode loop. Agents are branches of a single running process — forked from shared KV cache state, advancing through one GPU forward pass per tick, spawning sub-agents from their own live branches at arbitrary depth. Orchestration is not a layer above inference. It is inference.
+`lloyal-agents` runs multi-agent inference inside the decode loop. Instead of N independent model calls rebuilding the prompt each step, all agents advance inside one continuous decode process — forked from shared KV cache state, driven through a single GPU forward pass per tick, spawning sub-agents from their own live branches at arbitrary depth.
 
-```bash
-npm i @lloyal-labs/lloyal-agents
-```
-
-**Backends:** [lloyal.node](https://github.com/lloyal-ai/lloyal.node) — prebuilt binaries for macOS (Metal, CPU), Linux (CPU, CUDA, Vulkan), and Windows (CPU, CUDA, Vulkan). GPU selection at runtime.
+Built on [lloyal.node](https://github.com/lloyal-ai/lloyal.node), which provides forkable decode state and continuous tree batching over llama.cpp. `lloyal-agents` adds structured concurrency, tool dispatch, and a four-phase tick loop. Orchestration is not a layer above inference. It is inference.
 
-## Generation as the Primitive
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/lloyal-ai/sdk/main/assets/continuous-context-dark.svg">
+  <img src="https://raw.githubusercontent.com/lloyal-ai/sdk/main/assets/continuous-context.svg" alt="Traditional Agents vs Continuous Context Agents — shared KV prefix, tool prefill, sub-agent spawning" width="100%">
+</picture>
 
-The core architectural decision: generation is the primitive, not the API call. Agents are not processes that exchange messages. They are branches of a running inference process — forked from shared KV cache state, generating independently, their outputs comparable because they share a computational origin.
+```bash
+npm i @lloyal-labs/lloyal-agents @lloyal-labs/lloyal.node
+```
 
-This is built on [lloyal.node](https://github.com/lloyal-ai/lloyal.node), which provides forkable decode state and continuous tree batching over llama.cpp. `lloyal-agents` adds structured concurrency, tool dispatch, and a three-phase tick loop that drives N branches through a single GPU forward pass per step.
+`lloyal-agents` provides the agent runtime. [`lloyal.node`](https://github.com/lloyal-ai/lloyal.node) provides the native inference backend — prebuilt binaries for macOS (Metal, CPU), Linux (CPU, CUDA, Vulkan), and Windows (CPU, CUDA, Vulkan). Both are required. GPU selection at runtime.
 
 The public API surface:
 
@@ -91,7 +92,7 @@ yield *
 
 ## In-Loop Orchestration
 
-All active agents advance together in a three-phase tick loop:
+All active agents advance together in a four-phase tick loop:
 
 **PRODUCE.** Every generating agent calls `produceSync()` — synchronous sampling with no async gap between agents. This matters because it means the entire produce phase is a single uninterrupted pass over the active set.
 
@@ -99,6 +100,8 @@ All active agents advance together in a three-phase tick loop:
 
 **SETTLE.** Tool results that resolved during COMMIT are drained from a buffer. Each result is tokenized into a delta, budget-checked against a fresh `ContextPressure` snapshot, and batch-prefilled into the agent's branch. Grammar state resets. The agent transitions back to `generating`.
 
+**DISPATCH.** Tool calls collected during PRODUCE are executed sequentially via `scoped()` + `call()`. Each tool runs to completion before the next begins — no concurrent `llama_decode` during dispatch. Tools return `Operation<unknown>`, so they can `yield*` into framework primitives like `useAgentPool` or `runAgents`, spawning recursive sub-agents within the calling agent's scope.
+
 ```typescript
 // From the tick loop — Phase 1
 const entries: [Branch, number][] = [];
@@ -122,7 +125,7 @@ if (entries.length > 0) {
 }
 ```
 
-When no agent is generating and tools are still pending, the loop parks itself via `action()` — an Effection primitive that suspends the generator until a tool resolves and calls `wakeIdle()`. No polling. No sleep loops.
+When no agent is generating and tools are still pending, the loop yields control until the next tool resolves. No polling. No sleep loops.
 
 ## Structured Concurrency DAG
 
@@ -140,40 +143,15 @@ function* setupAgent(parent, task, ctx) {
 }
 ```
 
-If the scope exits — error, cancellation, normal completion — the branch is pruned. Orphaned branches are structurally impossible. Tool dispatch uses `scope.run()` for eager start inside the agent pool scope; if the scope tears down, pending tools are cancelled. The DAG is not imposed on the orchestration. It is intrinsic to the Effection task tree.
+If the scope exits — error, cancellation, normal completion — the branch is pruned. Orphaned branches are structurally impossible. Tool dispatch uses `scoped()` + `call()` — each tool executes inside a scoped error boundary within the agent pool scope. If the scope tears down, pending tools are cancelled. The DAG is not imposed on the orchestration. It is intrinsic to the Effection task tree.
 
 `useAgentPool` is an Effection `resource()` — it suspends via `provide()` after all agents complete, but keeps their branches alive. The caller can fork sub-agents from any completed agent's branch. Those sub-agents inherit the parent agent's full KV state — everything it generated, every tool result it consumed, every reasoning step it took. No summarization. No context window management. The sub-agent continues from the parent's frontier.
 
-The deep-research harness ships a concrete example: `reportPass`. Research agents run through the tick loop with tools — search, grep, read_file, report. Some agents get hard-cut by context pressure before they can submit findings. Rather than losing their work, the harness forks a sub-agent from each hard-cut agent's branch with a constrained tool set (report only):
+Recursive agents work at two levels. At the **harness level**, a completed pool's branches can be forked into follow-up pools — sub-agents inherit the parent's full KV state and continue from the fork point. At the **model level**, a tool's `execute()` method returns `Operation<unknown>`, so it can `yield*` directly into `useAgentPool` or `runAgents`. An agent that calls such a tool spawns sub-agents mid-generation — inside its own scope, inheriting its KV state, with cleanup guaranteed by structured concurrency.
 
-```typescript
-function* reportPass(pool: AgentPoolResult, opts: WorkflowOpts) {
-  const hardCut = pool.agents.filter((a) => !a.findings && !a.branch.disposed);
-  if (hardCut.length === 0) return;
-
-  const reporters = yield* runAgents({
-    tasks: hardCut.map((a) => ({
-      systemPrompt: REPORT_PROMPT,
-      content: "Report your findings.",
-      tools: reportOnlyTools,
-      parent: a.branch, // fork from the parent agent's branch
-    })),
-    tools: new Map([["report", reportTool]]),
-    terminalTool: "report",
-  });
+In both cases, the sub-agent sees everything the parent saw — system prompt, tool calls, partial reasoning — because that state is already in the KV cache at the fork point. No summarization. No context reconstruction. The sub-agent just continues from the parent's frontier.
 
-  hardCut.forEach((a, i) => {
-    if (reporters.agents[i]?.findings)
-      a.findings = reporters.agents[i].findings;
-  });
-}
-```
-
-The sub-agent sees everything the parent saw — its system prompt, its tool calls, its partial reasoning — because that state is already in the KV cache at the fork point. The sub-agent just continues from where the parent was cut off, with a tighter mandate.
-
-This is the DAG in practice: parent agents form the first level, reporter sub-agents form the second. `runAgents` wraps `useAgentPool` in `scoped()`, so the reporter branches are pruned when it returns. The parent branches are still alive in the outer scope. When that outer scope exits, every `ensure()` callback fires and prunes the parents. Teardown propagates top-down. Cleanup is guaranteed bottom-up.
-
-There is nothing in the framework that limits this to two levels. Agents can spawn sub-agents that spawn sub-agents. An agent pool can run inside another agent pool's scope. The structured concurrency guarantees compose at every depth.
+There is nothing in the framework that limits depth. Agents can spawn sub-agents that spawn sub-agents. An agent pool can run inside another agent pool's scope. The structured concurrency guarantees compose at every level.
 
 ## Hallucination Detection
 
@@ -198,19 +176,15 @@ const result =
 // Losers already pruned. Winner's branch is caller's responsibility.
 ```
 
-The harness decides how to compare. The deep-research example measures semantic equivalence across diverge outputs using bigram Jaccard similarity — where branches agree, the model is confident; where they diverge, hallucination risk is high. No model call required for the comparison itself. Other harnesses can use different equivalence measures over the same `diverge()` primitive.
+The harness decides how to compare. `diverge()` returns all outputs with their perplexity scores — the harness can apply any equivalence measure: bigram overlap, embedding similarity, or model-based evaluation. Where branches agree, the model is confident; where they diverge, hallucination risk is high.
 
 This directly operationalizes the semantic entropy work from Farquhar et al. ([Nature, 2024](https://www.nature.com/articles/s41586-024-07421-0)) — but as a runtime primitive, not a post-hoc metric. The key constraint: divergence from a common computational ancestor is signal. Divergence from independently-constructed contexts is sampling variance. This measurement is only meaningful because agents share a frontier.
 
 ## Session Accumulation
 
-When agents converge — when the entropy gate passes — the winning branch is not returned as output. It is promoted. It becomes the new trunk of the session. The next query starts from ground that was computationally earned by the previous convergence check.
-
-This is the cold/warm session distinction. A cold query runs the full pipeline: plan the decomposition, dispatch research agents, synthesize via `diverge`, evaluate convergence, promote. A warm query — one where a trusted trunk already exists — skips verification entirely. The frontier is already established. Agents fork from it, research, and the session responds directly from findings.
-
-Each promote is an epistemic commitment: this branch survived N-way comparison and convergence evaluation, so it becomes the basis for future reasoning. The session doesn't just carry forward text — it carries forward the KV state of a branch that survived verification. Future agents fork from this state. Their shared frontier is not an empty system prompt. It is the accumulated, verified reasoning of every previous cycle.
+`Session.promote(branch)` retains only that branch and makes it the session trunk. Future queries fork from this trunk — its KV cache already contains everything the promoted branch generated, every tool result it consumed, every verification it passed.
 
-Over multiple queries, the session compounds. Early queries establish the foundation. Later queries branch from it, research further, verify further, promote further. The trunk grows. The frontier advances. The model's effective context is not what you put in the prompt — it is what was earned by convergence.
+A cold query starts from position 0. A warm query starts from an existing trunk. Over multiple queries, the session compounds — each promote advances the frontier, and future agents inherit the accumulated state.
 
 ## Context Pressure
 
@@ -237,6 +211,8 @@ Tools are class-based with OpenAI-compatible function schemas:
 
 ```typescript
 import { Tool } from "@lloyal-labs/lloyal-agents";
+import { call } from "effection";
+import type { Operation } from "effection";
 import type { ToolContext } from "@lloyal-labs/lloyal-agents";
 
 class SearchTool extends Tool<{ query: string }> {
@@ -248,8 +224,10 @@ class SearchTool extends Tool<{ query: string }> {
     required: ["query"],
   };
 
-  async execute(args: { query: string }, context?: ToolContext) {
-    const results = await this.reranker.rank(args.query, this.chunks);
+  *execute(args: { query: string }, context?: ToolContext): Operation<unknown> {
+    const results = yield* call(() =>
+      this.reranker.rank(args.query, this.chunks),
+    );
     context?.onProgress?.({
       filled: results.length,
       total: this.chunks.length,

package/dist/Tool.d.ts

@@ -1,3 +1,4 @@
+import type { Operation } from 'effection';
 import type { JsonSchema, ToolSchema, ToolContext } from './types';
 /**
  * Abstract base class for tools usable by agents in the runtime
@@ -11,6 +12,11 @@ import type { JsonSchema, ToolSchema, ToolContext } from './types';
  * and `toolsJson` pair consumed by {@link useAgentPool} and
  * {@link runAgents}.
  *
+ * `execute()` returns an Effection `Operation`, enabling tools to
+ * spawn sub-agents via {@link runAgents} or {@link withSharedRoot}.
+ * For async work, wrap in `call()`. For synchronous tools, return
+ * directly from the generator body.
+ *
  * @example Search tool
  * ```typescript
  * class SearchTool extends Tool<{ query: string; topK?: number }> {
@@ -25,8 +31,8 @@ import type { JsonSchema, ToolSchema, ToolContext } from './types';
  *     required: ['query'],
  *   };
  *
- *   async execute(args: { query: string; topK?: number }, ctx?: ToolContext) {
- *     const results = await this.reranker.rank(args.query, args.topK ?? 5);
+ *   *execute(args: { query: string; topK?: number }, ctx?: ToolContext): Operation<unknown> {
+ *     const results = yield* call(() => this.reranker.rank(args.query, args.topK ?? 5));
  *     return { results };
  *   }
  * }
@@ -48,11 +54,15 @@ export declare abstract class Tool<TArgs = Record<string, unknown>> {
      * this tool's name. The return value is JSON-serialized and prefilled
      * back into the agent's context as a tool result.
      *
+     * Returns an Effection Operation — implement as a generator method.
+     * The operation runs inside the agent pool's scope, so it has access
+     * to Ctx, Store, and Events contexts for nested agent spawning.
+     *
      * @param args - Parsed arguments from the model's tool call
      * @param context - Execution context with progress reporting callback
      * @returns Tool result (will be JSON-serialized)
      */
-    abstract execute(args: TArgs, context?: ToolContext): Promise<unknown>;
+    abstract execute(args: TArgs, context?: ToolContext): Operation<unknown>;
     /**
      * OpenAI-compatible function tool schema
      *

package/dist/Tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Tool.d.ts","sourceRoot":"","sources":["../src/Tool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,8BAAsB,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACxD,gEAAgE;IAChE,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAC/B,oDAAoD;IACpD,QAAQ,CAAC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IACtC,2DAA2D;IAC3D,QAAQ,CAAC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAEzC;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;IAEtE;;;;;;OAMG;IACH,IAAI,MAAM,IAAI,UAAU,CASvB;CACF"}
+{"version":3,"file":"Tool.d.ts","sourceRoot":"","sources":["../src/Tool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,8BAAsB,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACxD,gEAAgE;IAChE,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAC/B,oDAAoD;IACpD,QAAQ,CAAC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IACtC,2DAA2D;IAC3D,QAAQ,CAAC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAEzC;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC,OAAO,CAAC;IAExE;;;;;;OAMG;IACH,IAAI,MAAM,IAAI,UAAU,CASvB;CACF"}

package/dist/Tool.js

@@ -13,6 +13,11 @@ exports.Tool = void 0;
  * and `toolsJson` pair consumed by {@link useAgentPool} and
  * {@link runAgents}.
  *
+ * `execute()` returns an Effection `Operation`, enabling tools to
+ * spawn sub-agents via {@link runAgents} or {@link withSharedRoot}.
+ * For async work, wrap in `call()`. For synchronous tools, return
+ * directly from the generator body.
+ *
  * @example Search tool
  * ```typescript
  * class SearchTool extends Tool<{ query: string; topK?: number }> {
@@ -27,8 +32,8 @@ exports.Tool = void 0;
  *     required: ['query'],
  *   };
  *
- *   async execute(args: { query: string; topK?: number }, ctx?: ToolContext) {
- *     const results = await this.reranker.rank(args.query, args.topK ?? 5);
+ *   *execute(args: { query: string; topK?: number }, ctx?: ToolContext): Operation<unknown> {
+ *     const results = yield* call(() => this.reranker.rank(args.query, args.topK ?? 5));
  *     return { results };
  *   }
  * }

package/dist/Tool.js.map

@@ -1 +1 @@
-{"version":3,"file":"Tool.js","sourceRoot":"","sources":["../src/Tool.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAsB,IAAI;IAqBxB;;;;;;OAMG;IACH,IAAI,MAAM;QACR,OAAO;YACL,IAAI,EAAE,UAAU;YAChB,QAAQ,EAAE;gBACR,IAAI,EAAE,IAAI,CAAC,IAAI;gBACf,WAAW,EAAE,IAAI,CAAC,WAAW;gBAC7B,UAAU,EAAE,IAAI,CAAC,UAAU;aAC5B;SACF,CAAC;IACJ,CAAC;CACF;AAtCD,oBAsCC"}
+{"version":3,"file":"Tool.js","sourceRoot":"","sources":["../src/Tool.ts"],"names":[],"mappings":";;;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,MAAsB,IAAI;IAyBxB;;;;;;OAMG;IACH,IAAI,MAAM;QACR,OAAO;YACL,IAAI,EAAE,UAAU;YAChB,QAAQ,EAAE;gBACR,IAAI,EAAE,IAAI,CAAC,IAAI;gBACf,WAAW,EAAE,IAAI,CAAC,WAAW;gBAC7B,UAAU,EAAE,IAAI,CAAC,UAAU;aAC5B;SACF,CAAC;IACJ,CAAC;CACF;AA1CD,oBA0CC"}

package/dist/agent-pool.d.ts

@@ -6,11 +6,10 @@ import type { PressureThresholds, AgentPoolOptions, AgentPoolResult } from './ty
  *
  * Created from `SessionContext._storeKvPressure()` which returns
  * `{ nCtx, cellsUsed, remaining }` where `remaining = nCtx - cellsUsed`.
- * `cellsUsed` is a monotonic counter in `BranchStore` — it increments on
- * every `decode_each` / `decode_scatter` but does **not** decrement on
- * individual branch prune (only resets on bulk ops like `retainOnly` and
- * `drain`). This means `remaining` is a conservative lower bound that
- * becomes increasingly pessimistic as branches are pruned mid-run.
+ * `cellsUsed` tracks unique KV cells per branch — incremented on
+ * `decode_each` / `decode_scatter`, decremented on release by
+ * `position - fork_head` (unique cells above the fork point), reset on
+ * bulk ops like `retainOnly` and `drain`.
  *
  * Two thresholds partition `remaining` into three zones:
  *
@@ -44,8 +43,6 @@ export declare class ContextPressure {
     /**
      * KV slots remaining (`nCtx - cellsUsed`).
      * Infinity when nCtx ≤ 0 (no context limit).
-     * Conservative: may undercount actual free space when branches have been
-     * pruned, since `cellsUsed` is monotonic.
      */
     readonly remaining: number;
     /** Remaining KV floor — tokens reserved for downstream work */
@@ -67,17 +64,18 @@ export declare class ContextPressure {
 /**
  * Concurrent agent generation loop as an Effection resource
  *
- * Runs N agents in parallel using a three-phase tick loop over shared
+ * Runs N agents in parallel using a four-phase tick loop over shared
  * {@link BranchStore} infrastructure. Each agent forks from a parent
  * branch, generates tokens, invokes tools, and reports findings.
  *
- * **Three-phase tick loop:**
+ * **Four-phase tick loop:**
  * 1. **PRODUCE** — sample all active agents via `produceSync()` (no async gap)
  * 2. **COMMIT** — single GPU call via `store.commit()` for all produced tokens
  * 3. **SETTLE** — drain settled tool results, batch prefill, reset grammars
+ * 4. **DISPATCH** — execute collected tool calls sequentially via `scoped()` + `call()`
  *
- * Tool dispatch uses `scope.run()` for eager start — tool executions run as
- * children of the agent pool scope and are cancelled if the scope exits.
+ * Tool dispatch uses `scoped()` + `call()` — each tool executes to completion
+ * before the next tick, ensuring exclusive `llama_context` access (no concurrent decode).
  *
  * **Resource semantics:** `provide()` suspends after all agents complete,
  * keeping branches alive so the caller can fork from them (e.g. for

package/dist/agent-pool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-pool.d.ts","sourceRoot":"","sources":["../src/agent-pool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAkB,MAAM,WAAW,CAAC;AAE3D,OAAO,EAA+G,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAIpK,OAAO,KAAK,EAEV,kBAAkB,EAElB,gBAAgB,EAChB,eAAe,EAEhB,MAAM,SAAS,CAAC;AAqCjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,qBAAa,eAAe;IAC1B,kEAAkE;IAClE,MAAM,CAAC,QAAQ,CAAC,kBAAkB,QAAQ;IAC1C,2DAA2D;IAC3D,MAAM,CAAC,QAAQ,CAAC,kBAAkB,OAAO;IAEzC;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,+DAA+D;IAC/D,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,wEAAwE;IACxE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;gBAEf,GAAG,EAAE,cAAc,EAAE,IAAI,CAAC,EAAE,kBAAkB;IAO1D;;;;OAIG;IACH,IAAI,QAAQ,IAAI,MAAM,CAA4C;IAElE,qEAAqE;IACrE,IAAI,QAAQ,IAAI,OAAO,CAA4C;IAEnE,iEAAiE;IACjE,MAAM,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;CACpC;AAwDD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,gBAAgB,GAAG,SAAS,CAAC,eAAe,CAAC,CAwW/E"}
+{"version":3,"file":"agent-pool.d.ts","sourceRoot":"","sources":["../src/agent-pool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAW,MAAM,WAAW,CAAC;AAEpD,OAAO,EAA+G,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAKpK,OAAO,KAAK,EAEV,kBAAkB,EAElB,gBAAgB,EAChB,eAAe,EAEhB,MAAM,SAAS,CAAC;AAqCjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,qBAAa,eAAe;IAC1B,kEAAkE;IAClE,MAAM,CAAC,QAAQ,CAAC,kBAAkB,QAAQ;IAC1C,2DAA2D;IAC3D,MAAM,CAAC,QAAQ,CAAC,kBAAkB,OAAO;IAEzC;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,+DAA+D;IAC/D,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,wEAAwE;IACxE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;gBAEf,GAAG,EAAE,cAAc,EAAE,IAAI,CAAC,EAAE,kBAAkB;IAO1D;;;;OAIG;IACH,IAAI,QAAQ,IAAI,MAAM,CAA4C;IAElE,qEAAqE;IACrE,IAAI,QAAQ,IAAI,OAAO,CAA4C;IAEnE,iEAAiE;IACjE,MAAM,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;CACpC;AA0DD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,gBAAgB,GAAG,SAAS,CAAC,eAAe,CAAC,CAsa/E"}