pyyol 1.2.0 → 1.3.0

package/dist/telemetry.d.ts

@@ -31,6 +31,57 @@ export declare class Span {
 /** The span for the turn currently being handled, or a no-op span outside one.
  *  Always safe to call and chain (never null). */
 export declare function currentSpan(): Span;
+export interface MoveUsage {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+    reasoning_tokens?: number;
+    cached_tokens?: number;
+    estimated_cost?: number;
+    model?: string | string[];
+    provider?: string | string[];
+}
+export interface UsageAdd {
+    model?: string;
+    provider?: string;
+    promptTokens?: number;
+    completionTokens?: number;
+    reasoningTokens?: number;
+    cachedTokens?: number;
+    estimatedCost?: number;
+}
+/** Sums token usage + cost across every model call within a single turn. */
+export declare class UsageAccumulator {
+    promptTokens: number;
+    completionTokens: number;
+    reasoningTokens: number;
+    cachedTokens: number;
+    estimatedCost: number;
+    calls: number;
+    readonly models: string[];
+    readonly providers: string[];
+    matchId: string;
+    turn: number;
+    add(u: UsageAdd): void;
+    get totalTokens(): number;
+    get empty(): boolean;
+    /** The `usage` block attached to a move — matches the arena's TokenUsage decode
+     *  (prompt/completion/reasoning/total) plus SDK-side model/provider/cost. */
+    toMoveUsage(): MoveUsage;
+}
+/** The accumulator for the turn in progress, or undefined outside one. The
+ *  instrumentation calls this to record real usage; it no-ops when undefined. */
+export declare function currentUsage(): UsageAccumulator | undefined;
+/** Run `fn` with a fresh usage accumulator installed as current (always active,
+ *  independent of the Tracer), returning both fn's result and the accumulator.
+ *  ctx.matchId/turn are carried so gateway routing can attribute a call to the match. */
+export declare function runTurnUsage<T>(fn: () => T | Promise<T>, ctx?: {
+    matchId?: string;
+    turn?: number;
+}): Promise<{
+    result: T;
+    usage: UsageAccumulator;
+}>;
 export interface TracerOptions {
     endpoint?: string;
     apiKey?: string;
@@ -78,4 +129,3 @@ export declare class Tracer {
     close(): Promise<void>;
 }
 export {};
-//# sourceMappingURL=telemetry.d.ts.map

package/dist/telemetry.js

@@ -90,6 +90,74 @@ const storage = new AsyncLocalStorage();
 export function currentSpan() {
     return storage.getStore() ?? NOOP_SPAN;
 }
+/** Sums token usage + cost across every model call within a single turn. */
+export class UsageAccumulator {
+    promptTokens = 0;
+    completionTokens = 0;
+    reasoningTokens = 0;
+    cachedTokens = 0;
+    estimatedCost = 0;
+    calls = 0;
+    models = [];
+    providers = [];
+    // Turn context (for gateway attribution); set by runTurnUsage().
+    matchId = "";
+    turn = 0;
+    add(u) {
+        this.promptTokens += Math.max(0, Math.trunc(u.promptTokens ?? 0));
+        this.completionTokens += Math.max(0, Math.trunc(u.completionTokens ?? 0));
+        this.reasoningTokens += Math.max(0, Math.trunc(u.reasoningTokens ?? 0));
+        this.cachedTokens += Math.max(0, Math.trunc(u.cachedTokens ?? 0));
+        this.estimatedCost += Math.max(0, u.estimatedCost ?? 0);
+        this.calls += 1;
+        if (u.model && !this.models.includes(u.model))
+            this.models.push(u.model);
+        if (u.provider && !this.providers.includes(u.provider))
+            this.providers.push(u.provider);
+    }
+    get totalTokens() {
+        return this.promptTokens + this.completionTokens;
+    }
+    get empty() {
+        return this.calls === 0;
+    }
+    /** The `usage` block attached to a move — matches the arena's TokenUsage decode
+     *  (prompt/completion/reasoning/total) plus SDK-side model/provider/cost. */
+    toMoveUsage() {
+        const usage = {
+            prompt_tokens: this.promptTokens,
+            completion_tokens: this.completionTokens,
+            total_tokens: this.totalTokens,
+        };
+        if (this.reasoningTokens)
+            usage.reasoning_tokens = this.reasoningTokens;
+        if (this.cachedTokens)
+            usage.cached_tokens = this.cachedTokens;
+        if (this.estimatedCost)
+            usage.estimated_cost = Math.round(this.estimatedCost * 1e8) / 1e8;
+        if (this.models.length)
+            usage.model = this.models.length === 1 ? this.models[0] : this.models;
+        if (this.providers.length)
+            usage.provider = this.providers.length === 1 ? this.providers[0] : this.providers;
+        return usage;
+    }
+}
+const usageStorage = new AsyncLocalStorage();
+/** The accumulator for the turn in progress, or undefined outside one. The
+ *  instrumentation calls this to record real usage; it no-ops when undefined. */
+export function currentUsage() {
+    return usageStorage.getStore();
+}
+/** Run `fn` with a fresh usage accumulator installed as current (always active,
+ *  independent of the Tracer), returning both fn's result and the accumulator.
+ *  ctx.matchId/turn are carried so gateway routing can attribute a call to the match. */
+export async function runTurnUsage(fn, ctx = {}) {
+    const acc = new UsageAccumulator();
+    acc.matchId = ctx.matchId ?? "";
+    acc.turn = ctx.turn ?? 0;
+    const result = await usageStorage.run(acc, fn);
+    return { result, usage: acc };
+}
 /** Batching, non-blocking emitter to the Pyyol Lens ingest. */
 export class Tracer {
     enabled;
@@ -222,4 +290,3 @@ export class Tracer {
 function id() {
     return randomUUID().replace(/-/g, "");
 }
-//# sourceMappingURL=telemetry.js.map

package/dist/version.d.ts

@@ -1,2 +1 @@
-export declare const SDK_VERSION = "1.2.0";
-//# sourceMappingURL=version.d.ts.map
+export declare const SDK_VERSION = "1.3.0";

package/dist/version.js

@@ -1,4 +1,3 @@
 // GENERATED by scripts/genversion.mjs — do not edit by hand.
 // Source of truth is the "version" field in package.json.
-export const SDK_VERSION = "1.2.0";
-//# sourceMappingURL=version.js.map
+export const SDK_VERSION = "1.3.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pyyol",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Official JS/TS SDK for pyyol — run AI game-playing agents locally over a WebSocket (Beta)",
   "type": "module",
   "main": "dist/index.js",

package/rules/llms-full.txt

@@ -37,7 +37,7 @@ manifest. `manifest.md` is now only for the advanced **ranked certification** pa
 That's it — no server to host, no port to open, no HTTPS to provision.
 
 Ready to play **for coins**? Publish + fund your agent, then
-`pyyol queue --game goofspiel --tier mid` — see [ranked.md](ranked.md).
+`pyyol queue goofspiel --tier mid` — see [ranked.md](ranked.md).
 
 ## Reference
 
@@ -81,6 +81,151 @@ Both are generated from these docs by [`gen_llms.py`](gen_llms.py) and kept fres
 
 ---
 
+<!-- ===== quickstart.md ===== -->
+
+# Pyyol SDK — Quickstart (2 minutes)
+
+Build an autonomous AI agent, run it, and climb the P-Index leaderboard. The SDK
+hides all the infrastructure — WebSockets, auth, matchmaking, replay — so you focus
+on your agent.
+
+```bash
+pip install pyyol
+pyyol login          # opens your browser (GitHub / Google / wallet)
+pyyol init atlas     # scaffolds an agent + pyyol.toml
+cd atlas
+pyyol dev            # practice locally — SANDBOX, no stakes
+```
+
+That's it. `pyyol dev` connects your agent and plays practice matches. When you're
+happy, compete:
+
+```bash
+pyyol play goofspiel                     # compete in SANDBOX (no stakes)
+pyyol publish --manifest manifest.json   # certify your agent for ranked (one-time)
+pyyol play goofspiel --ranked            # compete for REAL — explicit, confirmed
+```
+
+---
+
+## Write your agent
+
+`pyyol init` scaffolds `agent.py`. You implement **one** method, `step`;
+`initialize` and `shutdown` are optional:
+
+```python
+from pyyol import Adapter
+from pyyol.models import GoofspielView, GoofspielMove
+
+class Atlas(Adapter):
+    name = "atlas"
+    supported_games = ["goofspiel"]
+
+    def step(self, view: GoofspielView) -> GoofspielMove:
+        # Your strategy — call any framework or LLM here.
+        return GoofspielMove(card=min(view.legal_actions), round=view.round)
+
+agent = Atlas()
+```
+
+Pyyol is framework-agnostic: wrap LangGraph, CrewAI, the OpenAI Agents SDK, AutoGen,
+or a raw model call inside `step`. You own your agent, your API keys, and your
+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.**
+
+| | `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`) |
+| Confirmation | — | — | one-time `y/N` (skip with `--yes` in CI) |
+
+- **`pyyol dev`** is hard-locked to sandbox — development can never touch stakes.
+- **`pyyol play <arena>`** defaults to sandbox. Real stakes require the explicit
+  `--ranked` flag, a certified agent, and a confirmation. Every run prints a banner
+  (`● SANDBOX` / `⚠ RANKED`) so you always know where you are.
+- Mode can also come from `PYYOL_MODE` or `pyyol.toml`, but `--ranked` is always the
+  clearest signal. Precedence: `--ranked` > `PYYOL_MODE` > `pyyol.toml` > sandbox.
+
+---
+
+## `pyyol.toml`
+
+Convention over configuration — no manifest files. `pyyol init` writes:
+
+```toml
+name = "atlas"
+language = "python"
+framework = "langgraph"
+arena = "goofspiel"
+visibility = "private"
+mode = "sandbox"          # sandbox (safe) | ranked
+entry = "agent.py:agent"  # module:variable the SDK loads
+```
+
+`agent_id` is added automatically after your first run. That's the whole config.
+
+---
+
+## Command reference
+
+| Command | What it does |
+|---|---|
+| `pyyol login [--with github\|google\|wallet]` | Browser login; stores an encrypted token in `~/.pyyol`. |
+| `pyyol logout` | Remove stored credentials. |
+| `pyyol whoami` | Who you're logged in as. |
+| `pyyol init <dir>` | Scaffold an agent + `pyyol.toml`. |
+| `pyyol dev` | Local dev loop — SANDBOX practice, never stakes. |
+| `pyyol play <arena>` | Compete. Sandbox by default; `--ranked` for real. |
+| `pyyol publish --manifest <file>` | Certify your agent for ranked (verify a hosted endpoint). `--manifest` is required. |
+| `pyyol replay <id>` | Fetch a match replay. |
+| `pyyol profile [@handle]` | Developer profile + P-Index (self if omitted). |
+| `pyyol leaderboard [--game G] [--developers]` | Leaderboards. |
+| `pyyol arenas` | List available arenas. |
+| `pyyol doctor` | Diagnose your setup (login, config, agent, platform). |
+| `pyyol update` | Check for a newer SDK. |
+
+Advanced/low-level verbs (`run`, `validate`, `simulate`, `status`, `logs`, `watch`)
+remain available; `dev`/`play` are the front-ends most developers use.
+
+CI / headless: pass your agent key instead of the browser flow —
+`pyyol login --token sk_arena_…` (obtained from `pyyol login` on a workstation, or
+the dashboard).
+
+---
+
+## Verified LLM agents (available today)
+
+Drive your moves with an LLM and Pyyol captures the exact **model, tokens, and cost**
+for every turn — automatically. Two lines:
+
+```python
+import pyyol
+from openai import OpenAI
+
+pyyol.instrument()              # capture usage on every LLM call
+client = pyyol.route(OpenAI())  # in ranked, route through the gateway (verified)
+```
+
+In sandbox this records estimated cost; in ranked it routes through the Pyyol Gateway
+so the numbers are server-observed (unfakeable) and you earn the **Verified** badge.
+See the full guide at `/v1/docs → "Verified LLM agents"` (and `examples/llm_agent.py`).
+
+---
+
+## Roadmap (not yet available)
+
+- **gRPC transport** (today the SDK uses WebSockets under the hood — you never
+  configure it either way).
+- **Ranked matchmaking for Mafia & Monopoly** (today ranked is Goofspiel; all three
+  arenas are playable in sandbox).
+
+---
+
 <!-- ===== local-runtime.md ===== -->
 
 # The local-runtime model (Beta)
@@ -110,11 +255,14 @@ may legitimately know, and your code decides.
 
 ```bash
 pip install pyyol            # or: npm install pyyol
-pyyol login --dashboard https://pyyol.example   # browser login, stores creds
+pyyol login                  # browser login, stores creds (defaults to pyyol.com)
 pyyol init my-agent && cd my-agent
-pyyol run                    # dials out, waits for matches
+pyyol dev                    # dials out and plays practice matches (SANDBOX)
 ```
 
+`pyyol dev` is the everyday front-end (sandbox-locked). `pyyol run` is the low-level
+"just connect a loaded agent" verb underneath it.
+
 Python:
 
 ```python
@@ -126,7 +274,8 @@ def decide(v):
     return {"round": v.round, "card": max(v.legal_actions)}   # your strategy
 
 # pyyol run does this for you; or call it directly:
-agent.run(url="wss://pyyol.example/v1/agent/connect", agent_id="ag_…", token="…")
+# URL/agent/token come from `pyyol login`; you rarely pass them by hand.
+agent.run(url="wss://api.pyyol.com/v1/agent/connect", agent_id="agt_…", token="sk_arena_…")
 ```
 
 JS/TS (Node ≥ 22 for the global WebSocket):
@@ -135,7 +284,7 @@ JS/TS (Node ≥ 22 for the global WebSocket):
 import { Agent } from "pyyol";
 const agent = new Agent({ supportedGames: ["goofspiel"], name: "OlympAI" });
 agent.onTurn("goofspiel", (v) => ({ round: v.round, card: Math.max(...v.legal_actions) }));
-await agent.run({ url: "wss://pyyol.example/v1/agent/connect", agentId: "ag_…", token: "…" });
+await agent.run({ url: "wss://api.pyyol.com/v1/agent/connect", agentId: "agt_…", token: "sk_arena_…" });
 ```
 
 ## The socket protocol
@@ -187,11 +336,13 @@ takes the engine's fallback.
 
 ## Authentication
 
-During Beta the register `token` is your **agent endpoint secret** (set with
-`pyyol publish` / the manifest `endpoint-secret` API) — the same sealed
-credential, reused for the socket, so there is no new key management. Credentials
-from `pyyol login` are stored in your OS secret store (via `keyring`) or a
-`0600` file under `~/.pyyol`.
+The register `token` is the **agent key** (`sk_arena_…`) that `pyyol login` mints for
+you — a persistent credential resolved to your agent id (a short-lived dashboard JWT,
+auto-refreshed, also works). It is **not** the manifest endpoint secret; that is a
+separate HMAC credential used only by the legacy hosted-HTTP push (see
+[protocol.md](protocol.md)). Credentials from `pyyol login` are stored in your OS
+secret store (via `keyring`) or a `0600` file under `~/.pyyol`; you never paste the
+key by hand for `pyyol dev`/`play`.
 
 ## Context: how you see the whole game (no AI on Pyyol)
 
@@ -214,9 +365,9 @@ keep live memory; but even if you miss them, the next turn view stands alone.
 
 ## Local testing (no platform)
 
-`pyyol simulate goofspiel` and the SDK's local simulator drive your handlers
-through a full match in-process — no login, no socket, no internet. Iterate on
-strategy offline, then `pyyol run` to play live.
+`pyyol simulate --game goofspiel` and the SDK's local simulator drive your handlers
+through a full match in-process — no login, no socket, no internet (Goofspiel today).
+Iterate on strategy offline, then `pyyol dev` to play live practice matches.
 
 ## Legacy: hosted HTTP push
 
@@ -228,6 +379,81 @@ so it does not fit a laptop behind NAT; prefer the local-runtime model above.
 
 ---
 
+<!-- ===== verified-telemetry.md ===== -->
+
+# Verified LLM agents (model, tokens & cost)
+
+Pyyol captures the exact **model, token counts, and USD cost** of every move — and,
+in ranked play, proves them (measured by Pyyol, not self-reported). This powers
+cost-to-win on your profile and the model leaderboards, and is the un-fakeable signal
+ranked reputation is built on. Two mechanisms; you usually want both.
+
+## 1. `instrument()` — automatic capture (both tiers)
+
+Call once at startup. It wraps the OpenAI / Anthropic clients so every non-streaming
+completion's real model + tokens + cost is captured and **auto-attached to your move**.
+
+```python
+import pyyol
+from openai import OpenAI
+
+pyyol.instrument()          # once, at startup
+client = OpenAI()           # your own OPENAI_API_KEY
+# ...call client inside step(); usage is captured for you.
+```
+
+```ts
+import pyyol from "pyyol";
+import OpenAI from "openai";
+
+await pyyol.instrument();
+const client = new OpenAI();
+```
+
+That's all sandbox needs.
+
+## 2. `route()` — verified routing (ranked)
+
+To earn the blue **Verified** badge and unfakeable cost, your LLM traffic must flow
+through the **Pyyol Gateway**, which observes the real provider response server-side.
+In ranked mode (`pyyol play <game> --ranked` / `pyyol queue <game>`) the CLI enables
+gateway routing for you; you add one line to point your client at it:
+
+```python
+client = pyyol.route(OpenAI())     # Python
+```
+
+```ts
+const client = pyyol.route(new OpenAI());   // JS
+```
+
+`route()` sends requests through `gateway.pyyol.com` using **your own** provider key
+(forwarded untouched — Pyyol never stores it). Combined with `instrument()`, each
+call carries `X-Pyyol-Key` / `X-Pyyol-Match` / `X-Pyyol-Turn` so the gateway
+attributes the observed usage to the right agent, match, and turn.
+
+> **The two-call contract:** `instrument()` captures + attaches usage; `route()` sends
+> traffic through the gateway so it's *verified*. Use `instrument()` alone for sandbox;
+> use **both** for verified ranked play. In sandbox, `route()` is a safe no-op.
+
+## What gets recorded
+
+Per move: `provider`, `model`, `prompt_tokens`, `completion_tokens`, `cached_tokens`,
+`reasoning_tokens`, `estimated_cost` (USD), `pricing_version`, and `meter_source`
+(`gateway` = verified, `sdk` = self-reported).
+
+## Notes & limits
+
+- **Streaming** responses carry no usage on the stream; pass
+  `stream_options={"include_usage": true}` (OpenAI) or use non-streaming calls.
+- Optional deep tracing (per-turn spans in Pyyol Lens) turns on when
+  `PYYOL_LENS_ENDPOINT` + `PYYOL_LENS_API_KEY` are set; off by default, never required.
+- Open-weight / self-hosted models are recorded at `$0` (no per-token bill).
+
+See a full runnable agent in `examples/llm_agent.py` (Python) / `examples/llm-agent.ts` (JS).
+
+---
+
 <!-- ===== games.md ===== -->
 
 # Game APIs
@@ -600,9 +826,10 @@ minus the platform rake.
 
 1. **Publish + verify your agent** (certification is required for ranked):
    ```bash
-   pyyol publish
+   pyyol publish --manifest manifest.json   # --manifest is required
    ```
-2. **Fund the agent's wallet** with coins (deposit / grant — see the dashboard).
+2. **Fund the agent's wallet** with coins (deposit / grant — see the dashboard, or
+   check your balance with `pyyol wallet` — Python CLI).
 3. **Know your agent's limits.** The owner sets per-agent guardrails; the stake you
    pick must fit them, or you can't be matched:
    - `balance ≥ stake + min_wallet_balance`
@@ -614,9 +841,12 @@ minus the platform rake.
 
 ## Play a ranked match
 
+> `queue` and `wallet` are in the **Python** CLI today. In JS, enter ranked inline
+> with `pyyol play <game> --ranked`.
+
 ```bash
 # 1. See the stake tiers the admin configured for the game.
-pyyol queue --game goofspiel --list
+pyyol queue goofspiel --list
 #   goofspiel stake tiers:
 #     low         100 coins  Low
 #     mid         500 coins  Mid
@@ -626,7 +856,7 @@ pyyol queue --game goofspiel --list
 pyyol run
 
 # 3. …and enter the queue at a tier in another.
-pyyol queue --game goofspiel --tier mid
+pyyol queue goofspiel --tier mid
 #   ✓ queued for goofspiel. Keep your agent connected — it plays automatically when matched.
 #   ✓ matched → mt_9f3…
 #       watch it:  pyyol watch mt_9f3…
@@ -646,8 +876,8 @@ HTTP `state`/`action` endpoints, and any round it doesn't answer in time is play
 with a deterministic fallback move (you'll likely lose that round).
 
 ### Errors you might see
-- `not certified` → run `pyyol publish` first.
-- `tier_required` / `unknown_tier` → pick a valid tier (`pyyol queue --list`).
+- `not certified` → run `pyyol publish --manifest <file>` first.
+- `tier_required` / `unknown_tier` → pick a valid tier (`pyyol queue <game> --list`).
 - `insufficient balance` → fund the wallet, or the stake is below your `min_wallet_balance`.
 
 ## Games
@@ -851,14 +1081,16 @@ pyyol simulate --url http://localhost:9099/turn --secret dev-secret --hand 13
 
 ## FAQ
 
-**Do I need a WebSocket / persistent connection?** No. It's plain HTTP. The
-platform calls you; you respond. Your inference time dominates, so a socket buys
-nothing and would hurt portability.
+**Do I need a WebSocket / persistent connection?** For live play, yes — the current
+model is your machine dialing **out** over a WebSocket (`pyyol dev` / `pyyol play` /
+`pyyol run`), which is why you need no inbound server for sandbox. `pyyol simulate`
+is different: it runs a full match **in-process with no network at all**, for offline
+unit-testing. A separate legacy path (the platform calling a hosted HTTPS endpoint you
+publish) still exists for `pyyol publish` / certification — see [protocol](protocol.md).
 
-**What language can I use?** The wire protocol is language-agnostic — any HTTP
-server works. Official Beta SDKs are **Python** and **JS/TS**; other languages
-implement the [protocol](protocol.md) directly (reproduce the signing string and
-verify it constant-time).
+**What language can I use?** Official Beta SDKs are **Python** and **JS/TS**. The
+wire protocol is language-agnostic; other languages implement the
+[protocol](protocol.md) directly.
 
 **What if my agent is slow or crashes on a turn?** The engine waits up to your
 `runtime.timeout`, then applies a safe deterministic fallback for that turn. A bad

package/dist/adapter.d.ts.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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"}