@esso0428/pi-subagents 0.17.16 → 0.17.18

package/dist/agent-manager.d.ts

@@ -1,503 +0,0 @@
-/**
- * agent-manager.ts — Tracks agents, background execution, resume support.
- *
- * There are two independent concurrency pools, never one:
- *
- * - Background (`maxConcurrent`, default 10) bounds detached agents.
- * - Foreground (`maxConcurrentForeground`, default 0 = unlimited) bounds
- *   agents a caller is blocking on inline — `spawnAndWait`.
- *
- * Independent by design: a foreground agent blocks the parent anyway, so
- * charging it to the background pool would let a saturated pool starve the main
- * session of work it could have done itself. Excess agents in either pool are
- * queued and auto-started as slots free up. Nested children take no slot in
- * either — see `occupiesPoolSlot` / `occupiesForegroundSlot`.
- */
-import type { Model } from "@earendil-works/pi-ai";
-import type { AgentSession, ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { type ToolActivity } from "./agent-runner.js";
-import type { AgentInvocation, AgentRecord, AgentTombstone, IsolationMode, MentionResolution, SubagentType, ThinkingLevel } from "./types.js";
-import { type LifetimeUsage } from "./usage.js";
-import type { CompiledSchema } from "./workflow/json-schema.js";
-export type OnAgentComplete = (record: AgentRecord) => void;
-export type OnAgentStart = (record: AgentRecord) => void;
-export type OnAgentCompact = (record: AgentRecord, info: CompactionInfo) => void;
-/**
- * Fired once per assistant `message_end`, for EVERY agent this manager owns —
- * top-level and nested alike, spawns and resumes. The one place where each
- * message is seen exactly once: `AgentRecord.lifetimeUsage` is deliberately
- * double-booked into ancestors (see `nested-tools.ts`) so a hidden child's spend
- * shows up on the record a human can see, which makes those records useless as
- * a basis for anything that must not count a message twice — parent-session
- * accounting above all.
- */
-export type OnAgentUsage = (record: AgentRecord, usage: LifetimeUsage) => void;
-export type CompactionInfo = {
-    reason: "manual" | "threshold" | "overflow";
-    tokensBefore: number;
-};
-/**
- * Whether a record is one of the session's own agents, rather than something
- * another agent or a workflow owns.
- *
- * The single definition behind every user-facing surface — the fleet list, the
- * widget, the `/agents` menus, `@handle` resolution, and the completion events
- * and session entries. An owned child reports through its owner, so surfacing
- * it separately would double-count the same work in the places a person reads.
- */
-export declare function isTopLevelAgent(record: Pick<AgentRecord, "parentAgentId" | "workflowId">): boolean;
-interface SpawnOptions {
-    description: string;
-    /**
-     * Optional memorable name for this instance, becoming a second handle
-     * (`@auth-audit`) alongside the type-derived one. Slugged, not validated —
-     * anything unusable degrades via `handleBase` rather than failing the spawn.
-     */
-    name?: string;
-    /**
-     * Reopen this pi session file instead of starting a fresh conversation, so a
-     * mention of an evicted agent continues where it left off. The agent's
-     * definition is still resolved from its type, so the continuation runs under
-     * the type's CURRENT config.
-     */
-    resumeSessionFile?: string;
-    /**
-     * Take an evicted agent's names back verbatim instead of allocating fresh
-     * ones, so a resumed conversation keeps the handle the user just typed —
-     * `handleBase(type)` cannot reproduce a numbered `explore-2`. Safe without an
-     * `assignHandle` pass because tombstoned names are excluded from allocation
-     * (`takenHandles`), so nothing live can be holding them.
-     *
-     * Internal capability, like `resumeSessionFile`: a forged handle would
-     * duplicate a live agent's name and make `resolveMention` ambiguous, so
-     * `spawnTopLevel` strips it from anything a caller sends.
-     */
-    reclaim?: {
-        handle: string;
-        alias?: string;
-    };
-    model?: Model<any>;
-    maxTurns?: number;
-    isolated?: boolean;
-    inheritContext?: boolean;
-    thinkingLevel?: ThinkingLevel;
-    isBackground?: boolean;
-    /**
-     * Skip whichever pool's queue check applies to this spawn — start immediately
-     * even if the configured concurrency limit would otherwise queue it. The slot
-     * is still COUNTED once the run starts, so a bypassing spawn transiently
-     * exceeds the limit rather than being invisible to it.
-     *
-     * Used by the scheduler, so a fired job can't be deferred past its trigger
-     * window, and by the `/agents` agent-file generator, which has no way to
-     * cancel a wait (see its call site).
-     */
-    bypassQueue?: boolean;
-    /**
-     * A caller is awaiting this record inline (`spawnAndWait`) — what
-     * `maxConcurrentForeground` bounds. Set only by `spawnAndWait`; stripped from
-     * caller-supplied options by `spawnTopLevel`, since a forged `blocking` would
-     * defer a detached start behind a queue its caller cannot see or release.
-     */
-    blocking?: boolean;
-    /**
-     * The workflow run this child belongs to, when a workflow spawned it.
-     *
-     * Ownership, not decoration. A workflow's children are the workflow's — they
-     * report through its card, its notification and its dialog, so they are
-     * filtered out of every top-level surface exactly as nested children are, and
-     * they take no `maxConcurrent` slot: the run has its own concurrency cap, and
-     * counting them twice would let one workflow starve the whole session.
-     */
-    workflowId?: string;
-    /**
-     * Make the child report through a `StructuredOutput` tool built from this
-     * compiled schema. Set only by the workflow host, for `agent({ schema })`.
-     */
-    structuredOutput?: CompiledSchema;
-    /** Isolation mode — "worktree" creates a temp git worktree for the agent. */
-    isolation?: IsolationMode;
-    /**
-     * Working directory for the agent (absolute path). Default: parent session
-     * cwd. The agent's tools operate here, but .pi config (extensions, skills,
-     * settings, memory) still loads from the parent session's project — the
-     * target directory's `.pi` extensions never execute. With isolation:
-     * "worktree", the worktree is created FROM this directory and the result
-     * branch lands in that repo.
-     */
-    cwd?: string;
-    /**
-     * Last chance to look at an isolated agent's worktree, awaited immediately
-     * before it is committed to a branch and removed.
-     *
-     * Exists because that removal happens inside the settle path, before
-     * `spawnAndWait` resolves: by the time a caller has the finished record, the
-     * directory the child actually wrote in is gone. Anything that must inspect
-     * or verify that tree — a workflow `gate` is the motivating case — has to run
-     * here or it silently inspects the main tree instead.
-     *
-     * Fires only on the normal settle path, and only when a worktree was created.
-     * Not on the error path and not on the stop-during-copy guard: those are
-     * already failing, and delaying cleanup there would leak a copy for no gain.
-     * A rejection is swallowed — the hook can never keep the worktree alive.
-     */
-    onBeforeWorktreeCleanup?: (worktreePath: string) => Promise<void>;
-    /** Resolved invocation snapshot captured for UI display. */
-    invocation?: AgentInvocation;
-    /** Whether the optional `.output` transcript is enabled for this run. */
-    outputTranscript?: boolean;
-    /** Parent abort signal — when aborted, the subagent is also stopped. */
-    signal?: AbortSignal;
-    /**
-     * Called synchronously once the record is in the map and its promise is set,
-     * before `onSessionCreated` fires — where callers attach the output file.
-     *
-     * Carried on the options rather than parked on the manager for the duration
-     * of a spawn: with a foreground queue, `startAgent` can run at drain time,
-     * long after any such field would have been restored, and the callback would
-     * silently never fire (or fire into an unrelated caller's closure).
-     */
-    onSpawned?: (id: string) => void;
-    /**
-     * Called synchronously when the spawn is queued instead of started, with how
-     * many entries in its own pool are ahead of it. The foreground UI uses it to
-     * say so while it waits; nothing else needs it.
-     */
-    onQueued?: (id: string, ahead: number) => void;
-    /** Called on tool start/end with activity info (for streaming progress to UI). */
-    onToolActivity?: (activity: ToolActivity) => void;
-    /** Called on streaming text deltas from the assistant response. */
-    onTextDelta?: (delta: string, fullText: string) => void;
-    /** Called when the agent session is created (for accessing session stats). */
-    onSessionCreated?: (session: AgentSession) => void;
-    /** Called at the end of each agentic turn with the cumulative count. */
-    onTurnEnd?: (turnCount: number) => void;
-    /** Called once per assistant message_end with that message's usage delta. */
-    onAssistantUsage?: (usage: {
-        input: number;
-        output: number;
-        cacheWrite: number;
-    }) => void;
-    /** Called when the session successfully compacts. */
-    onCompaction?: (info: CompactionInfo) => void;
-    /** Nesting depth: top-level subagent = 1. */
-    depth?: number;
-    /** Parent agent ID for ownership-scoped nested controls. */
-    parentAgentId?: string;
-    /** Effective inherited nesting cap for this branch. */
-    maxSubagentDepth?: number;
-    /** Config-discovery root inherited by nested launches when it differs from the working directory. */
-    configCwd?: string;
-    /** Root session id, inherited by nested launches so transcripts stay grouped. */
-    rootSessionId?: string;
-}
-interface ResumeOptions {
-    /**
-     * Run the resumed turn detached in the background: return immediately with
-     * the record still "running" (or "queued" at the concurrency limit) and
-     * notify on completion via onComplete, exactly like a background spawn.
-     * Default (false/undefined) runs the resume inline and returns the settled
-     * record — the historical behavior.
-     */
-    isBackground?: boolean;
-    /** Called on tool start/end with activity info (for streaming progress to UI). */
-    onToolActivity?: (activity: ToolActivity) => void;
-    /** Called once per assistant message_end with that message's usage delta. */
-    onAssistantUsage?: (usage: {
-        input: number;
-        output: number;
-        cacheWrite: number;
-    }) => void;
-    /** Called when the session successfully compacts. */
-    onCompaction?: (info: CompactionInfo) => void;
-    /**
-     * Background resume only: called synchronously when the run actually starts —
-     * immediately, or later from drainQueue. Callers wire per-run side effects
-     * (output-file streaming) here rather than at the call site, so a resume that
-     * is stopped while still queued never leaves a subscription behind: `abort()`
-     * drops a queued record without reaching `settle()`, which is what would have
-     * torn that subscription down.
-     */
-    onStarted?: () => void;
-}
-export declare class AgentManager {
-    private agents;
-    /** Lightweight terminal rows retained after runtime GC so durable history stays discoverable. */
-    private historyRecords;
-    private cleanupInterval;
-    private onComplete?;
-    private onStart?;
-    private onCompact?;
-    private onUsage?;
-    private maxConcurrent;
-    private maxConcurrentForeground;
-    /** Base repos worktrees were created from — so dispose() can prune them all,
-     *  not just the parent repo (caller-supplied cwd can target other repos). */
-    private worktreeRepos;
-    /** Project cwd for each record's durable checkpoint. */
-    private recoveryCwds;
-    /**
-     * Startup phases, keyed by agent id. `spawn()` still returns synchronously,
-     * but an agent using worktree isolation is not running yet when it does —
-     * copying the repo is an awaited git call. This is what `awaitStartup` hands
-     * callers that must fail their tool call on a startup failure, and what
-     * `waitForAll` waits on while a record is "running" with no `promise` yet.
-     * Entries are dropped once the run is underway, and kept (rejected) after a
-     * startup failure so a late `awaitStartup` still sees it.
-     */
-    private startups;
-    /**
-     * Evicted agents that can still be reached by name, keyed by handle. Outlives
-     * the 10-minute record cleanup — that timer exists to bound memory, not to
-     * expire a conversation the user might still want — and is cleared alongside
-     * completed records on session start/switch.
-     */
-    private tombstones;
-    /**
-     * Agents waiting to start, tagged with the pool they wait on. One queue for
-     * both pools: `drainQueue` picks the earliest entry whose own pool has room,
-     * so neither can head-of-line-block the other, and every removal path
-     * (`abort`, `abortAll`, `dispose`) stays a single filter.
-     *
-     * `release` wakes a caller blocked in `spawnAndWait`, and is fired once the
-     * entry's `start` has SETTLED rather than at drain time: startup is async
-     * now, so releasing earlier would wake the caller before `record.promise`
-     * exists and it would read a still-starting agent as one that never ran.
-     * Removing an entry from this array MUST release it — a queued record has no
-     * promise to await, and pi has no tool-execution timeout to bail the caller
-     * out.
-     */
-    private queue;
-    /** Number of currently running background agents. */
-    private runningBackground;
-    /** Number of currently running foreground (blocking) agents. */
-    private runningForeground;
-    constructor(onComplete?: OnAgentComplete, maxConcurrent?: number, onStart?: OnAgentStart, onCompact?: OnAgentCompact, onUsage?: OnAgentUsage);
-    /** Update the max concurrent background agents limit. */
-    setMaxConcurrent(n: number): void;
-    getMaxConcurrent(): number;
-    /** Update the max concurrent foreground (blocking) agents limit. 0 = unlimited. */
-    setMaxConcurrentForeground(n: number): void;
-    getMaxConcurrentForeground(): number;
-    /**
-     * Which pool a spawn is charged to, or undefined for one that is charged to
-     * neither (nested children, detached non-background spawns).
-     *
-     * Nothing here queues when the limit is unset — `poolHasRoom` reports an
-     * unlimited pool as always having room, so that alone is what keeps the
-     * default path identical. The `> 0` guard is belt and braces on top: it also
-     * keeps the counter from churning and the settle path from calling a drain
-     * that would find nothing to do. Both are unobservable, which is why no test
-     * pins them; the observable half — that the default start stays synchronous —
-     * is pinned in `test/foreground-concurrency.test.ts`.
-     */
-    private poolFor;
-    private poolHasRoom;
-    /**
-     * Spawn an agent and return its ID immediately (for background use).
-     * If the concurrency limit is reached, the agent is queued.
-     *
-     * The id comes back synchronously, but with `isolation: "worktree"` the agent
-     * is not running yet when it does — the repo copy is an awaited git call.
-     * Callers that must fail a tool call on a startup failure await
-     * `awaitStartup(id)`; everyone else sees it on the record (status "error").
-     */
-    spawn(pi: ExtensionAPI, ctx: ExtensionContext, type: SubagentType, prompt: string, options: SpawnOptions): string;
-    /**
-     * Attach the project-local transcript once for a newly-created record.
-     * Repeated calls are harmless: deterministic paths and an existing file keep
-     * the initial user entry intact, which is important for resume and retries.
-     */
-    private attachDurableTranscript;
-    private checkpointStatus;
-    private makeCheckpoint;
-    private checkpoint;
-    /** Checkpoint a record after external transcript wiring. */
-    checkpointRecord(id: string): void;
-    /** Register durable transcript metadata for compatibility with callers that
-     * attach a pre-existing history (for example a restored session). */
-    setTranscript(id: string, historyFile: string, transcriptPath: string, cwd?: string): void;
-    /** Restore active checkpoints as stopped partial history after a restart. */
-    restoreRecovered(cwd: string): void;
-    /**
-     * Restore terminal records from durable history without creating sessions.
-     * Invalid and live records are ignored so recovery cannot replace active work.
-     */
-    restoreCompleted(records: readonly Partial<AgentRecord>[]): void;
-    /**
-     * Wire a parent abort signal for a record that is about to be QUEUED.
-     * `startAgent` does this for running agents, and a queued record never gets
-     * there, so without this Esc could not release a queue position.
-     *
-     * Returns false when the signal is ALREADY aborted, in which case the record
-     * is stopped here and must not be enqueued: `addEventListener` never fires on
-     * an aborted signal, so a `spawnAndWait` on it would wait forever — pi has no
-     * tool-execution timeout to bail it out.
-     *
-     * The listener is left in place when the agent starts. `startAgent` adds its
-     * own, so both fire on a later abort, but `abort()` on an already-stopped
-     * record is a no-op — so detaching would only be tidiness, and tidiness the
-     * `abortAll`/`dispose` paths could not offer anyway.
-     */
-    private armQueuedAbort;
-    /**
-     * Kick off an agent's startup and register it under `startups`. The returned
-     * promise never rejects — the failure is delivered through `awaitStartup`,
-     * and to the record.
-     *
-     * @param queuedPool - The pool this start was QUEUED on, or undefined for an
-     *   immediate start. A queue drain can be minutes after `spawn()` returned,
-     *   and nobody is awaiting `awaitStartup` by then, so a failure has to live
-     *   on the record as status "error" — what drainQueue did when the throw was
-     *   still synchronous. An immediate start instead drops the record, exactly
-     *   as the throw out of `spawn()` did: no orphan in `listAgents()`, and the
-     *   handle goes back.
-     */
-    private launch;
-    /**
-     * Resolves once the agent is actually running, and rejects with the startup
-     * failure (strict worktree isolation) that `spawn()` used to throw before the
-     * repo copy became async. Resolves immediately for an agent that is already
-     * running, still queued, or unknown — so callers can await it unconditionally.
-     *
-     * Call it in the same tick as the `spawn()` it belongs to: a failed startup
-     * takes its record (and this entry) with it, exactly as the throw did.
-     */
-    awaitStartup(id: string): Promise<void>;
-    /** Actually start an agent (called immediately or from queue drain). */
-    private startAgent;
-    /**
-     * The shared tail of both settle paths: release whatever pool slot the run
-     * held, notify, and let the queue drain into the freed slot.
-     *
-     * The decrement lives HERE and nowhere else. `abort()` on a running record
-     * only fires its controller and leaves the run to settle normally, so
-     * decrementing there too would double-free — permanently lifting the limit.
-     *
-     * Foreground agents fire `onComplete` for lifecycle symmetry, with
-     * `resultConsumed` set so the callback skips notifications the inline result
-     * already delivered.
-     *
-     * @param guardCallback swallow a throwing `onComplete` (the success path does;
-     *   the error path historically did not, and keeps not doing so).
-     * @param pool the pool this run was CHARGED TO at start time — passed in, not
-     *   recomputed, so a mid-run change to `maxConcurrentForeground` can't make
-     *   the release disagree with the acquire.
-     */
-    private settleRun;
-    private flushOutput;
-    /**
-     * Stop the nested children a settled parent owns. Nested records are hidden
-     * from the UI and only their owner can consume them, so a child outliving its
-     * parent would burn tokens unseen with no way to reach it. Grandchildren are
-     * covered transitively — each abort lands in that child's own settle path.
-     */
-    private abortOwnedChildren;
-    /**
-     * Start queued agents up to each pool's concurrency limit.
-     *
-     * `findIndex` on the entry's OWN pool rather than `shift`: with one queue
-     * serving two independent limits, a saturated foreground pool at the head
-     * would otherwise stall every background agent behind it. Taking the earliest
-     * eligible entry keeps FIFO within each pool, which is what callers see.
-     */
-    private drainQueue;
-    /**
-     * Remove queued entries and wake anyone blocked on them. The single point
-     * that enforces "leaving the queue releases the waiter" — a missed release is
-     * an unbounded hang, not a failed call.
-     */
-    private dequeue;
-    /**
-     * Spawn an agent and wait for completion (foreground use).
-     * Charged to the foreground pool (`maxConcurrentForeground`), which is
-     * unlimited by default; never to the background one.
-     * Returns { id, record } so callers can access the agent ID.
-     *
-     * @param onSpawned - Called synchronously once the run is kicked off, before
-     *   onSessionCreated fires. Use this to set record.outputFile so
-     *   streamToOutputFile can pick it up.
-     */
-    spawnAndWait(pi: ExtensionAPI, ctx: ExtensionContext, type: SubagentType, prompt: string, options: Omit<SpawnOptions, "isBackground">, onSpawned?: (id: string) => void): Promise<{
-        id: string;
-        record: AgentRecord;
-    }>;
-    /**
-     * Resume an existing agent session with a new prompt.
-     */
-    resume(id: string, prompt: string, signal?: AbortSignal, options?: ResumeOptions): Promise<AgentRecord | undefined>;
-    /**
-     * Start a background resume run: detached, settling and notifying like
-     * startAgent's background path. Invoked immediately, or from drainQueue when
-     * a concurrency slot frees. The session already exists (resume reuses it), so
-     * there is no onSessionCreated to hang per-run wiring off — callers use
-     * `options.onStarted`, which fires on both the immediate and the drained path.
-     */
-    private startResume;
-    /**
-     * Send a steering message to an agent from the UI (mirrors the steer_subagent
-     * tool). A live session delivers it now — it interrupts the agent after its
-     * current tool execution and appears as a user message. If the session isn't
-     * ready yet, the message is queued on `pendingSteers` and flushed when the
-     * session is created. Returns false if the agent can't accept steering
-     * (unknown id, or no longer running/queued).
-     */
-    steer(id: string, message: string): boolean;
-    getRecord(id: string): AgentRecord | undefined;
-    /** Handles already in use, so a fresh spawn can pick an unclaimed one. */
-    private takenHandles;
-    /**
-     * Resolve an `@name` from the prompt. Matches a top-level agent's handle
-     * case-insensitively, preferring one that can still be steered and otherwise
-     * the most recently started (which is the one a resume should continue), then
-     * falls back to an exact agent id so `@<agentId>` works too.
-     */
-    resolveMention(name: string): MentionResolution | undefined;
-    /**
-     * Forget an evicted agent, by handle. For the case where its session file has
-     * gone: the entry can then only ever fail, while still holding the name
-     * against the type that would otherwise start a fresh agent under it.
-     *
-     * A *successful* resume does not drop its tombstone — the live record it
-     * creates already wins in `resolveMention`, and overwrites the entry in place
-     * when it is itself evicted.
-     */
-    dropTombstone(handle: string): void;
-    /** Evicted agents whose conversation can still be reopened, newest first. */
-    listTombstones(): AgentTombstone[];
-    listAgents(): AgentRecord[];
-    abort(id: string): boolean;
-    /** Dispose a record's session and remove it from the map. */
-    private removeRecord;
-    /**
-     * Preserve enough of a departing record for `@handle` to reopen its
-     * conversation later. Nothing to keep unless it has both a handle to be
-     * addressed by and a session file to reopen — an in-memory session leaves no
-     * transcript, so the mention would have nothing to continue from.
-     */
-    private tombstone;
-    private cleanup;
-    /**
-     * Remove completed/stopped/errored runtime records immediately.
-     * Called on session start/switch so live handles from a prior session do not
-     * remain addressable. Transcript-backed rows move to `historyRecords` and
-     * stay visible to the UI; their JSONL history is the durable source of truth.
-     * Pass skipUnconsumed=true to preserve records the LLM has not read yet
-     * (resultConsumed=false) so the result remains available to the caller.
-     */
-    clearCompleted(skipUnconsumed?: boolean): void;
-    /** Whether any agents are still running or queued. */
-    hasRunning(): boolean;
-    /** Abort all running and queued agents immediately. */
-    abortAll(): number;
-    /** Wait for all running and queued agents to complete (including queued ones). */
-    waitForAll(): Promise<void>;
-    /**
-     * @param pi - Needed to run `git worktree prune`, which is async now and so
-     *   cannot be reached through a stored spawn argument at shutdown. Omitting
-     *   it (tests, teardown of a manager that never spawned) skips the prune.
-     */
-    dispose(pi?: ExtensionAPI): Promise<void>;
-}
-export {};
-//# sourceMappingURL=agent-manager.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"agent-manager.d.ts","sourceRoot":"","sources":["../src/agent-manager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAKH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAcpG,OAAO,EAAyB,KAAK,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAI7E,OAAO,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,cAAc,EAAE,aAAa,EAAE,iBAAiB,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC9I,OAAO,EAAY,KAAK,aAAa,EAAE,MAAM,YAAY,CAAC;AAC1D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAGhE,MAAM,MAAM,eAAe,GAAG,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,CAAC;AAC5D,MAAM,MAAM,YAAY,GAAG,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,CAAC;AACzD,MAAM,MAAM,cAAc,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,IAAI,EAAE,cAAc,KAAK,IAAI,CAAC;AACjF;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;AAC/E,MAAM,MAAM,cAAc,GAAG;IAAE,MAAM,EAAE,QAAQ,GAAG,WAAW,GAAG,UAAU,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,CAAC;AAsEnG;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,IAAI,CAAC,WAAW,EAAE,eAAe,GAAG,YAAY,CAAC,GACxD,OAAO,CAET;AA2CD,UAAU,YAAY;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC7C,KAAK,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;;;;;;;OASG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;;;;;OAQG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,cAAc,CAAC;IAClC,6EAA6E;IAC7E,SAAS,CAAC,EAAE,aAAa,CAAC;IAC1B;;;;;;;OAOG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;;;;;;;;;;;;OAcG;IACH,uBAAuB,CAAC,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAClE,4DAA4D;IAC5D,UAAU,CAAC,EAAE,eAAe,CAAC;IAC7B,yEAAyE;IACzE,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,wEAAwE;IACxE,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB;;;;;;;;OAQG;IACH,SAAS,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC;;;;OAIG;IACH,QAAQ,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/C,kFAAkF;IAClF,cAAc,CAAC,EAAE,CAAC,QAAQ,EAAE,YAAY,KAAK,IAAI,CAAC;IAClD,mEAAmE;IACnE,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IACxD,8EAA8E;IAC9E,gBAAgB,CAAC,EAAE,CAAC,OAAO,EAAE,YAAY,KAAK,IAAI,CAAC;IACnD,wEAAwE;IACxE,SAAS,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,6EAA6E;IAC7E,gBAAgB,CAAC,EAAE,CAAC,KAAK,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;IAC1F,qDAAqD;IACrD,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,IAAI,CAAC;IAC9C,6CAA6C;IAC7C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,4DAA4D;IAC5D,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,uDAAuD;IACvD,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,qGAAqG;IACrG,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iFAAiF;IACjF,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,UAAU,aAAa;IACrB;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,kFAAkF;IAClF,cAAc,CAAC,EAAE,CAAC,QAAQ,EAAE,YAAY,KAAK,IAAI,CAAC;IAClD,6EAA6E;IAC7E,gBAAgB,CAAC,EAAE,CAAC,KAAK,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;IAC1F,qDAAqD;IACrD,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,IAAI,CAAC;IAC9C;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;CACxB;AAiCD,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAkC;IAChD,iGAAiG;IACjG,OAAO,CAAC,cAAc,CAAkC;IACxD,OAAO,CAAC,eAAe,CAAiC;IACxD,OAAO,CAAC,UAAU,CAAC,CAAkB;IACrC,OAAO,CAAC,OAAO,CAAC,CAAe;IAC/B,OAAO,CAAC,SAAS,CAAC,CAAiB;IACnC,OAAO,CAAC,OAAO,CAAC,CAAe;IAC/B,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,uBAAuB,CAAqC;IACpE;iFAC6E;IAC7E,OAAO,CAAC,aAAa,CAAqB;IAC1C,wDAAwD;IACxD,OAAO,CAAC,YAAY,CAA6B;IAEjD;;;;;;;;OAQG;IACH,OAAO,CAAC,QAAQ,CAAoC;IAEpD;;;;;OAKG;IACH,OAAO,CAAC,UAAU,CAAqC;IAEvD;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,KAAK,CAAqF;IAClG,qDAAqD;IACrD,OAAO,CAAC,iBAAiB,CAAK;IAC9B,gEAAgE;IAChE,OAAO,CAAC,iBAAiB,CAAK;gBAG5B,UAAU,CAAC,EAAE,eAAe,EAC5B,aAAa,SAAyB,EACtC,OAAO,CAAC,EAAE,YAAY,EACtB,SAAS,CAAC,EAAE,cAAc,EAC1B,OAAO,CAAC,EAAE,YAAY;IAYxB,yDAAyD;IACzD,gBAAgB,CAAC,CAAC,EAAE,MAAM;IAM1B,gBAAgB,IAAI,MAAM;IAI1B,mFAAmF;IACnF,0BAA0B,CAAC,CAAC,EAAE,MAAM;IAQpC,0BAA0B,IAAI,MAAM;IAIpC;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,OAAO;IAMf,OAAO,CAAC,WAAW;IAMnB;;;;;;;;OAQG;IACH,KAAK,CACH,EAAE,EAAE,YAAY,EAChB,GAAG,EAAE,gBAAgB,EACrB,IAAI,EAAE,YAAY,EAClB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,YAAY,GACpB,MAAM;IA0FT;;;;OAIG;IACH,OAAO,CAAC,uBAAuB;IAgB/B,OAAO,CAAC,gBAAgB;IAIxB,OAAO,CAAC,cAAc;IAmBtB,OAAO,CAAC,UAAU;IAKlB,4DAA4D;IAC5D,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAKlC;yEACqE;IACrE,aAAa,CAAC,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI;IAS1F,6EAA6E;IAC7E,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IA8BnC;;;OAGG;IACH,gBAAgB,CAAC,OAAO,EAAE,SAAS,OAAO,CAAC,WAAW,CAAC,EAAE,GAAG,IAAI;IAsChE;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,cAAc;IAgBtB;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,MAAM;IAgCd;;;;;;;;OAQG;IACH,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIvC,wEAAwE;YAC1D,UAAU;IA4RxB;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,SAAS;IAyBjB,OAAO,CAAC,WAAW;IAWnB;;;;;OAKG;IACH,OAAO,CAAC,kBAAkB;IAM1B;;;;;;;OAOG;IACH,OAAO,CAAC,UAAU;IAqBlB;;;;OAIG;IACH,OAAO,CAAC,OAAO;IASf;;;;;;;;;OASG;IACG,YAAY,CAChB,EAAE,EAAE,YAAY,EAChB,GAAG,EAAE,gBAAgB,EACrB,IAAI,EAAE,YAAY,EAClB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,IAAI,CAAC,YAAY,EAAE,cAAc,CAAC,EAC3C,SAAS,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,GAC/B,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,WAAW,CAAA;KAAE,CAAC;IA4C/C;;OAEG;IACG,MAAM,CACV,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,WAAW,EACpB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC;IAqGnC;;;;;;OAMG;IACH,OAAO,CAAC,WAAW;IAmGnB;;;;;;;OAOG;IACH,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO;IAa3C,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;IAI9C,0EAA0E;IAC1E,OAAO,CAAC,YAAY;IAgBpB;;;;;OAKG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS;IAwB3D;;;;;;;;OAQG;IACH,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAInC,6EAA6E;IAC7E,cAAc,IAAI,cAAc,EAAE;IAIlC,UAAU,IAAI,WAAW,EAAE;IAS3B,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAyB1B,6DAA6D;IAC7D,OAAO,CAAC,YAAY;IA6BpB;;;;;OAKG;IACH,OAAO,CAAC,SAAS;IAmBjB,OAAO,CAAC,OAAO;IASf;;;;;;;OAOG;IACH,cAAc,CAAC,cAAc,UAAQ,GAAG,IAAI;IAe5C,sDAAsD;IACtD,UAAU,IAAI,OAAO;IAMrB,uDAAuD;IACvD,QAAQ,IAAI,MAAM;IA4BlB,kFAAkF;IAC5E,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAmBjC;;;;OAIG;IACG,OAAO,CAAC,EAAE,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;CAiDhD"}