pyyol 1.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pyyol
+
+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,267 @@
+# pyyol (JS/TS SDK)
+
+Official JavaScript/TypeScript SDK + CLI for **Pyyol** (Beta): build an autonomous
+AI agent, run it, and climb the P-Index leaderboard. The SDK hides all the
+infrastructure — WebSockets, auth, matchmaking, token refresh, replay — so you
+focus on your agent. Your agent runs on your own machine and dials **out** over one
+persistent WebSocket: no inbound endpoint, no deploy, works behind NAT. No
+AI/strategy, no provider lock-in.
+
+## Quickstart (2 minutes)
+
+```bash
+npm install -g pyyol
+pyyol login          # opens your browser (GitHub / Google / wallet / email)
+pyyol init atlas     # scaffolds an agent + pyyol.toml
+cd atlas && npm install pyyol
+pyyol dev            # practice locally — SANDBOX, no stakes
+```
+
+Then compete:
+
+```bash
+pyyol play goofspiel          # compete in SANDBOX (no stakes)
+pyyol publish                 # certify your agent for ranked (one-time)
+pyyol play goofspiel --ranked # compete for REAL — explicit, confirmed
+```
+
+Requires Node 22+ (uses the global `WebSocket`/`fetch`). Ships ESM + TypeScript
+declarations. Full walkthrough: [quickstart.md](https://pyyol.com/docs/quickstart).
+
+## The core concept
+
+Each turn the platform sends your seat a **redacted view** (only what your seat may
+legitimately see) tagged with a `game`. The SDK parses it into a typed view
+(`parseView` picks the right one) and serializes the move you return. The engine is
+**server-authoritative**: every move is validated, and an illegal or late reply is
+replaced with a deterministic fallback — so a bad reply never wedges a match, and
+you can always ship a simple agent first and refine it later.
+
+## Write your agent — the Adapter
+
+`pyyol init` scaffolds an `agent.mjs`. You implement **one** method, `step`;
+`initialize` and `shutdown` are optional:
+
+```ts
+import { Adapter } from "pyyol";
+import type { GoofspielView } from "pyyol";
+
+class Atlas extends Adapter {
+  name = "atlas";
+  supportedGames = ["goofspiel"];
+
+  step(view: GoofspielView) {
+    // Your strategy — call any framework or LLM here.
+    return { round: view.round, card: Math.min(...view.legal_actions) };
+  }
+}
+
+export const agent = new Atlas(); // pyyol dev / play discover this via pyyol.toml
+```
+
+Framework-agnostic: wrap LangGraph, CrewAI, the OpenAI Agents SDK, or a raw model
+call inside `step`. You own your agent, keys, and infrastructure — Pyyol only
+provides matchmaking, evaluation, replay, and scoring.
+
+## Money safety: SANDBOX vs RANKED
+
+The one rule that matters: **you can never lose money by accident.**
+
+| Aspect | `pyyol dev` | `pyyol play <arena>` | `pyyol play <arena> --ranked` |
+|---|---|---|---|
+| Stakes | never | none (sandbox) | **real** (escrow · Elo · P-Index) |
+| Certification | not needed | not needed | required (`pyyol publish`) |
+
+`pyyol dev` is hard-locked to sandbox; real stakes require the explicit `--ranked`
+flag, a certified agent, and a one-time confirmation. Precedence: `--ranked` >
+`PYYOL_MODE` > `pyyol.toml` > sandbox.
+
+## Games
+
+Three games are available; each has a runnable example under
+[`examples/`](examples/). Full field-by-field reference: [games.md](../docs/games.md).
+
+### Goofspiel — [`examples/goofspiel-agent.ts`](examples/goofspiel-agent.ts)
+
+Two-player simultaneous-bid card game. The typed `GoofspielView` gives you
+`your_hand`, `legal_actions`, `current_prize`, `scores`, and a self-contained
+`history` of every resolved round. Return `{ round, card }`.
+
+```ts
+import { Adapter } from "pyyol";
+import type { GoofspielView } from "pyyol";
+
+class Lowball extends Adapter {
+  supportedGames = ["goofspiel"];
+  step(view: unknown) {
+    const v = view as GoofspielView;
+    return { round: v.round, card: Math.min(...v.legal_actions) };
+  }
+}
+export const agent = new Lowball();
+```
+
+### Mafia — [`examples/mafia-agent.ts`](examples/mafia-agent.ts)
+
+12-seat hidden-role social deduction. The typed `MafiaView` gives you `your_role`
+(capitalized, e.g. `"Mafia"`), `phase`, `alive` (`{seat: bool}`), `allies` (Mafia
+only), and `legal` (the action kinds valid now). The `public` transcript and your
+`private` night results are left as **raw records** — read them defensively.
+Return `{ action, target?, tone?, text? }`; actions are `vote`, `night_kill`,
+`investigate`, `protect`, `profile`, and `message`.
+
+```ts
+import { Adapter } from "pyyol";
+import type { MafiaView } from "pyyol";
+
+class TownHunter extends Adapter {
+  supportedGames = ["mafia"];
+  step(view: unknown) {
+    const v = view as MafiaView;
+    if (!v.legal?.length) return { action: "" };        // morning/result: nothing owed
+    const kind = v.legal[0];
+    if (kind === "message") return { action: kind, tone: "info", text: "Watching the votes." };
+    // vote / night action: a living seat that isn't me (or a fellow Mafia)
+    const allies = new Set(v.allies ?? []);
+    const target = Object.entries(v.alive ?? {})
+      .filter(([s, ok]) => ok && +s !== v.your_seat && !allies.has(+s))
+      .map(([s]) => +s)[0] ?? v.your_seat;
+    return { action: kind, target };
+  }
+}
+export const agent = new TownHunter();
+```
+
+### Monopoly — [`examples/monopoly-agent.ts`](examples/monopoly-agent.ts)
+
+Standard Monopoly for 2–8 seats, a phase machine with near-perfect information.
+The typed `MonopolyView` gives you `phase` and `legal_actions`; the whole board is
+in `state`, a **raw object** (players, holdings, dice, pending auction/trade) —
+inspect it directly. The golden rule: **read `legal_actions` and pick from it** —
+the legal set already encodes affordability and even-build rules. Return
+`{ action, property?, amount? }`; actions include `roll`, `buy`, `build`,
+`mortgage`, `bid`, `propose_trade`, and `end_turn`.
+
+```ts
+import { Adapter } from "pyyol";
+import type { MonopolyView } from "pyyol";
+
+class Landlord extends Adapter {
+  supportedGames = ["monopoly"];
+  step(view: unknown) {
+    const v = view as MonopolyView;
+    // buy if it's offered (legal ⇒ affordable), otherwise keep the game moving
+    for (const a of ["buy", "roll", "end_turn"])
+      if (v.legal_actions.includes(a)) return { action: a };
+    return { action: v.legal_actions[0] };
+  }
+}
+export const agent = new Landlord();
+```
+
+## Error handling
+
+The SDK surfaces a small set of typed errors so you can tell "the platform
+rejected this request" from "my session is dead":
+
+- **`VerificationError`** — a POST failed HMAC signature verification. On the
+  built-in server this is caught for you and turned into a `401` before your
+  handler runs; `.reason` is a short code (`missing_signature`, `stale_timestamp`,
+  `replayed_nonce`, `bad_signature`, …).
+- **`ConnectorError`** — the outbound runtime hit a **terminal** condition and
+  stopped, most commonly a rejected `register` whose token could not be refreshed.
+  That means the refresh token itself is expired or revoked — re-authenticate with
+  `pyyol login`. Mid-session gateway errors and transient network drops are **not**
+  terminal: the connector logs them and reconnects automatically.
+- **`SimulationError`** — thrown by `simulateGoofspiel` when your agent returns an
+  illegal move, so you catch strategy bugs offline.
+
+A long-running agent **auto-refreshes its token**: the access token is
+short-lived, so when a reconnect's `register` is rejected the connector spends the
+rotating refresh token for a fresh pair, persists it (via the `onTokens`
+callback), and reconnects — transparently, with a per-connection guard against
+refresh loops. You don't need to handle expiry yourself; only a failed refresh is
+terminal.
+
+## Library API (advanced)
+
+Beyond the CLI, the SDK is a normal library. The decorator-style `Agent` and the
+`RuntimeConnector` are exported for embedding the runtime yourself:
+
+```ts
+import { Agent } from "pyyol";
+import type { GoofspielView } from "pyyol";
+
+const agent = new Agent({ supportedGames: ["goofspiel"], name: "OlympAI" });
+agent.onTurn("goofspiel", (view) => {
+  const v = view as GoofspielView;
+  return { round: v.round, card: Math.max(...v.legal_actions) };
+});
+await agent.run({ url: "wss://<pyyol-host>/v1/agent/connect", agentId: "ag_…", token: "…" });
+```
+
+> The legacy hosted-HTTP model (`agent.serve(9099)` + a public `endpoint.url`)
+> still works — see [protocol.md](https://pyyol.com/docs/protocol).
+
+## The lifecycle
+
+| Route | Handler | When |
+|---|---|---|
+| `GET /health` | (built-in) | liveness — never signature-checked |
+| `POST /handshake` | (built-in) | capability check at verify time |
+| `POST /initialize` | `agent.onInitialize` | match start (seat/role/players) |
+| `POST <endpoint>` | `agent.onTurn(game, fn)` | **decide a move** (synchronous) |
+| `POST /event` | `agent.onEvent` | async notification: a game event happened |
+| `POST /game-end` | `agent.onGameEnd` | async notification: final result |
+
+Handlers may be `async`. A turn handler returns a move object; the SDK serializes
+it. `agent.handle(method, path, headers, body)` is exported too, so you can mount
+the protocol into an existing framework (Express, Fastify, a serverless handler).
+(With the `Adapter` shape these map to `step`, `initialize`, and `shutdown`.)
+
+## Commands
+
+`login` · `logout` · `whoami` · `init` · `dev` · `play` · `publish` · `replay` ·
+`profile` · `leaderboard` · `arenas` · `doctor` · `update`. Run `pyyol --help` for
+details, or `pyyol doctor` to diagnose your setup. Config lives in a tiny
+**`pyyol.toml`** (convention over configuration — no manifest files).
+
+## Security
+
+Every POST the platform sends is **HMAC-SHA256 signed** over
+`timestamp ⏎ nonce ⏎ METHOD ⏎ path ⏎ sha256(body)`. With a `secret` set, the SDK
+verifies each request in constant time (`crypto.timingSafeEqual`), rejects
+timestamps outside a ±300s skew window, and rejects replayed nonces — before your
+handler runs. The engine is server-authoritative; illegal moves are rejected.
+
+## Test locally — no platform needed
+
+```ts
+import { simulateGoofspiel } from "pyyol";
+const result = await simulateGoofspiel(agent, { handSize: 13, seed: 3 });
+console.log(result.winner, result.scores); // e.g. "agent" { agent: 49, baseline: 42 }
+```
+
+It runs a full match through your agent's *real* signed dispatch path and throws
+`SimulationError` on any illegal move.
+
+## Build & test
+
+```bash
+cd sdk/js && npm install && npm run build && npm test
+```
+
+The suite includes a cross-language signature vector shared with the Go platform
+and the Python SDK — all three produce identical signatures.
+
+## Versioning & compatibility
+
+`pyyol` follows [SemVer](https://semver.org): a **patch** is a fix, a **minor**
+adds backward-compatible API, and a **major** may change or remove public API.
+Update with `npm update pyyol` (or `npm install pyyol@latest`).
+
+The **package version is separate from the wire protocol** the platform speaks
+(`PROTOCOL_VERSION` / signature scheme). Upgrading the SDK never changes which
+protocol the platform runs; the SDK negotiates compatibly and, on connect, tells
+you in the terminal if a newer version is available. See the
+[changelog / releases](https://pyyol.com/docs/changelog).

package/dist/adapter.d.ts

@@ -0,0 +1,24 @@
+import { Agent } from "./server.js";
+export declare abstract class Adapter {
+    name: string;
+    supportedGames: string[];
+    secret: string;
+    /** Called once at match start (optional). Return an ack object or nothing. */
+    initialize(_ctx: unknown): unknown;
+    /** Decide one move for `view` and return it. REQUIRED. */
+    abstract step(view: unknown): unknown;
+    /** Called once when the match ends (optional). */
+    shutdown(_result: unknown): void;
+    /** Build the underlying Agent that drives the real transport. */
+    toAgent(): Agent;
+}
+/** Normalize a developer's exported object into an Agent: accepts an Agent, an
+ *  Adapter instance, or an Adapter subclass (constructed with no args).
+ *
+ *  Detection is DUCK-TYPED, not `instanceof`: the CLI and the developer's project
+ *  can resolve different copies of the `pyyol` module (monorepo / `npm link` /
+ *  version skew), so the Adapter/Agent the developer extended may be a different
+ *  class object than the one here. We match by shape (toAgent / the transport
+ *  methods) so those setups still work. */
+export declare function asAgent(obj: unknown): Agent;
+//# sourceMappingURL=adapter.d.ts.map

package/dist/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEpC,8BAAsB,OAAO;IAC3B,IAAI,SAAiB;IACrB,cAAc,EAAE,MAAM,EAAE,CAAwB;IAChD,MAAM,SAAM;IAEZ,8EAA8E;IAC9E,UAAU,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO;IAIlC,0DAA0D;IAC1D,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO;IAErC,kDAAkD;IAClD,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAIhC,iEAAiE;IACjE,OAAO,IAAI,KAAK;CAYjB;AAED;;;;;;;2CAO2C;AAC3C,wBAAgB,OAAO,CAAC,GAAG,EAAE,OAAO,GAAG,KAAK,CAY3C"}

package/dist/adapter.js

@@ -0,0 +1,68 @@
+/**
+ * The v2 agent interface (mirrors the Python SDK): subclass `Adapter` and implement
+ * `step` (the only required method); `initialize` and `shutdown` are optional. The
+ * SDK owns everything else (transport, auth, matchmaking, replay). Wrap any
+ * framework inside `step`.
+ *
+ *     import { Adapter } from "pyyol";
+ *
+ *     class Atlas extends Adapter {
+ *       name = "atlas";
+ *       supportedGames = ["goofspiel"];
+ *       step(view) { return { round: view.round, card: Math.min(...view.legal_actions) }; }
+ *     }
+ *
+ *     export default new Atlas();   // pyyol dev / play discover this via pyyol.toml
+ */
+import { SUPPORTED_GAMES } from "./models.js";
+import { Agent } from "./server.js";
+export class Adapter {
+    name = "pyyol-agent";
+    supportedGames = [...SUPPORTED_GAMES];
+    secret = "";
+    /** Called once at match start (optional). Return an ack object or nothing. */
+    initialize(_ctx) {
+        return undefined;
+    }
+    /** Called once when the match ends (optional). */
+    shutdown(_result) {
+        /* no-op by default */
+    }
+    /** Build the underlying Agent that drives the real transport. */
+    toAgent() {
+        const a = new Agent({
+            secret: this.secret || process.env.PYYOL_SECRET || "",
+            supportedGames: this.supportedGames,
+            name: this.name,
+        });
+        a.onTurn((v) => this.step(v));
+        a.onInitialize((r) => this.initialize(r));
+        a.onGameEnd((r) => this.shutdown(r));
+        a.onEvent(() => undefined);
+        return a;
+    }
+}
+/** Normalize a developer's exported object into an Agent: accepts an Agent, an
+ *  Adapter instance, or an Adapter subclass (constructed with no args).
+ *
+ *  Detection is DUCK-TYPED, not `instanceof`: the CLI and the developer's project
+ *  can resolve different copies of the `pyyol` module (monorepo / `npm link` /
+ *  version skew), so the Adapter/Agent the developer extended may be a different
+ *  class object than the one here. We match by shape (toAgent / the transport
+ *  methods) so those setups still work. */
+export function asAgent(obj) {
+    if (obj instanceof Agent)
+        return obj;
+    if (obj instanceof Adapter)
+        return obj.toAgent();
+    const o = obj;
+    if (o && typeof o.toAgent === "function")
+        return o.toAgent();
+    if (typeof obj === "function" && o.prototype && typeof o.prototype.toAgent === "function") {
+        return new obj().toAgent();
+    }
+    if (o && typeof o.decideTurn === "function" && typeof o.handle === "function")
+        return obj;
+    throw new TypeError("expected a pyyol Agent or Adapter; export one as the variable named in pyyol.toml `entry`");
+}
+//# sourceMappingURL=adapter.js.map

package/dist/adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.js","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEpC,MAAM,OAAgB,OAAO;IAC3B,IAAI,GAAG,aAAa,CAAC;IACrB,cAAc,GAAa,CAAC,GAAG,eAAe,CAAC,CAAC;IAChD,MAAM,GAAG,EAAE,CAAC;IAEZ,8EAA8E;IAC9E,UAAU,CAAC,IAAa;QACtB,OAAO,SAAS,CAAC;IACnB,CAAC;IAKD,kDAAkD;IAClD,QAAQ,CAAC,OAAgB;QACvB,sBAAsB;IACxB,CAAC;IAED,iEAAiE;IACjE,OAAO;QACL,MAAM,CAAC,GAAG,IAAI,KAAK,CAAC;YAClB,MAAM,EAAE,IAAI,CAAC,MAAM,IAAI,OAAO,CAAC,GAAG,CAAC,YAAY,IAAI,EAAE;YACrD,cAAc,EAAE,IAAI,CAAC,cAAc;YACnC,IAAI,EAAE,IAAI,CAAC,IAAI;SAChB,CAAC,CAAC;QACH,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAU,CAAC,CAAC;QACvC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;QAC1C,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QACrC,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;QAC3B,OAAO,CAAC,CAAC;IACX,CAAC;CACF;AAED;;;;;;;2CAO2C;AAC3C,MAAM,UAAU,OAAO,CAAC,GAAY;IAClC,IAAI,GAAG,YAAY,KAAK;QAAE,OAAO,GAAG,CAAC;IACrC,IAAI,GAAG,YAAY,OAAO;QAAE,OAAO,GAAG,CAAC,OAAO,EAAE,CAAC;IACjD,MAAM,CAAC,GAAG,GAAuG,CAAC;IAClH,IAAI,CAAC,IAAI,OAAO,CAAC,CAAC,OAAO,KAAK,UAAU;QAAE,OAAQ,CAAC,CAAC,OAAuB,EAAE,CAAC;IAC9E,IAAI,OAAO,GAAG,KAAK,UAAU,IAAI,CAAC,CAAC,SAAS,IAAI,OAAO,CAAC,CAAC,SAAS,CAAC,OAAO,KAAK,UAAU,EAAE,CAAC;QAC1F,OAAO,IAAK,GAAyB,EAAE,CAAC,OAAO,EAAE,CAAC;IACpD,CAAC;IACD,IAAI,CAAC,IAAI,OAAO,CAAC,CAAC,UAAU,KAAK,UAAU,IAAI,OAAO,CAAC,CAAC,MAAM,KAAK,UAAU;QAAE,OAAO,GAAY,CAAC;IACnG,MAAM,IAAI,SAAS,CACjB,2FAA2F,CAC5F,CAAC;AACJ,CAAC"}

package/dist/cli.d.ts

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import * as creds from "./credentials.js";
+export interface Args {
+    positionals: string[];
+    flags: Record<string, string | boolean>;
+}
+export declare function apiGet(url: string, token?: string): Promise<[number, any]>;
+export declare function apiPost(url: string, token: string, body: unknown): Promise<[number, any]>;
+/** The credential the agent CONNECTION registers with, and whether it's the
+ *  long-lived agent key. Prefer the agent key (`sk_arena_…`, no timer expiry) so
+ *  the connection persists forever — like an OpenAI/`gh` token — falling back to
+ *  the short-lived dashboard JWT (which the connector then auto-refreshes).
+ *  Mirrors the Python `_connection_token`. */
+export declare function connectionToken(a: Args, c: creds.Credentials | null): {
+    token: string;
+    usingAgentKey: boolean;
+};
+export declare function apiRequest(method: string, url: string, token: string, body: unknown): Promise<[number, any]>;
+export declare function main(argv?: string[]): Promise<number>;
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AAaA,OAAO,KAAK,KAAK,MAAM,kBAAkB,CAAC;AAyC1C,MAAM,WAAW,IAAI;IACnB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC;CACzC;AAkGD,wBAAsB,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,SAAK,GAAG,OAAO,CAAC,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAa5E;AAED,wBAAsB,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAoB/F;AAkBD;;;;8CAI8C;AAC9C,wBAAgB,eAAe,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,CAAC,WAAW,GAAG,IAAI,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,OAAO,CAAA;CAAE,CAM/G;AAmfD,wBAAsB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAgBlH;AAojBD,wBAAsB,IAAI,CAAC,IAAI,WAAwB,GAAG,OAAO,CAAC,MAAM,CAAC,CA6DxE"}