pantheon-opencode 1.3.5-beta.60.efa533f → 1.3.6

package/src/pantheon/zeus-delegate-with-retry.ts

@@ -0,0 +1,401 @@
+/**
+ * Zeus Delegate With Retry (Wave 4, empty-mode fix) — helper for Zeus waves.
+ *
+ * Opencode 1.18.x cannot intercept `task()` completion via hooks, so the
+ * `dispatch-guard` lib is NOT wired in the plugin. Zeus waves MUST use this
+ * helper manually: it encapsulates
+ *
+ *   delegate → waitForTerminal → classify via createDispatchGuard
+ *            → maybeRetry 1x on empty-mode1/mode2 → escalate
+ *
+ * Retry cap is HARD at 1 (never 2x). The guard is stateful per helper
+ * instance — one retry budget total. Fail-open on missing APIs is NOT
+ * applicable here: a failed delegate throws/log+escalate so the wave can
+ * decide (a) retry with different agent, (b) simplify, (c) manual.
+ *
+ * Two usage shapes:
+ *   1. High-level: `zeusDelegateWithRetry({ board, client, sessionID, agent, prompt })`
+ *      — creates child session, registers board, promptAsync, waitForTerminal,
+ *        reads report, classifies, retries once if empty, escalates if still empty.
+ *   2. Low-level: `createZeusRetryHelper()` — wraps a generic
+ *      `() => Promise<DispatchResultLike>` pair via `executeWithRetry`.
+ *
+ * The high-level helper is the one Zeus waves should import:
+ *
+ * ```ts
+ * import { zeusDelegateWithRetry } from './pantheon/zeus-delegate-with-retry.ts'
+ * const { report, alias, taskID, retried, classification } =
+ *   await zeusDelegateWithRetry({ board, client, sessionID, agent: 'apollo', prompt })
+ * ```
+ *
+ * If the result is empty after one retry, the helper THROWS with an
+ * `EscalationError` — the wave must catch and escalate to the user (see
+ * `src/agents/zeus.md` "Waves with Retry").
+ *
+ * Pure TypeScript — no direct SDK import. Board/client are structural.
+ *
+ * @module zeus-delegate-with-retry
+ */
+
+import type { BackgroundJobBoard } from './background-job-board.ts'
+import type { DelegationClient } from './delegation-finalize.ts'
+import { DELEGATION_DEFAULTS, readDelegationReport } from './delegation-finalize.ts'
+import {
+  createDispatchGuard,
+  type DispatchClassification,
+  type DispatchGuard,
+  type DispatchGuardOptions,
+  type DispatchResultLike,
+} from './dispatch-guard.ts'
+import { createPantheonLogger } from './logger.ts'
+import {
+  type ProviderCooldownTracker,
+  type RetryPolicy,
+  RetryPolicyEngine,
+} from './retry-policy.ts'
+import { safeSessionPath } from './session-guard.ts'
+
+const log = createPantheonLogger({ module: 'pantheon-zeus-retry' })
+
+// ─── Types ───────────────────────────────────────────────────────────────
+
+export interface ZeusDelegateWithRetryOptions {
+  /** Board singleton (same instance the plugin uses). */
+  board: BackgroundJobBoard
+  /** Delegation client (adapted SDK client, e.g. adaptDelegationClient). */
+  client: DelegationClient
+  /** Parent session that delegates (must be a valid ses_ id). */
+  sessionID: string
+  /** Target agent (e.g. "apollo", "hermes"). */
+  agent: string
+  /** Task prompt delivered to the background agent. */
+  prompt: string
+  /** Human-readable description shown on the job board. */
+  description?: string
+  /** Explicit model for the child session (provider/model). */
+  model?: { id: string; providerID: string }
+  /** Timeout for board.waitForTerminal (ms). Default: DELEGATION_DEFAULTS.readTimeoutMs */
+  readTimeoutMs?: number
+  /** Retry on empty results. Default: true */
+  retryOnEmpty?: boolean
+  /** R1: per-error-type retry policy (routing.yml `retry_policy`). */
+  retryPolicy?: RetryPolicy
+  /** R1: provider cooldown tracker (routing.yml `cooldown`). */
+  cooldown?: ProviderCooldownTracker
+  /** R1: provider name for cooldown tracking (default "default"). */
+  provider?: string
+  /** Injectable logger. Default: file log (PANTHEON_HOOKS_LOG gate). */
+  logger?: { warn: (message: string) => void; info?: (message: string) => void }
+  /** Output dir for delegation reports. Default: DELEGATION_DEFAULTS.outputDir */
+  outputDir?: string
+}
+
+export interface ZeusDelegateResult {
+  /** Job alias (e.g. "apo-1"). */
+  alias: string
+  /** Child session id (= board task id). */
+  taskID: string
+  /** Report markdown (with Agent Activity section when sampled). */
+  report: string
+  /** Classification of the final result. */
+  classification: DispatchClassification
+  /** True when a retry was fired (cap 1). */
+  retried: boolean
+}
+
+/**
+ * Thrown when a delegate returns empty even after one retry — the wave must
+ * escalate (try different agent, simplify scope, or manual intervention).
+ */
+export class ZeusEscalationError extends Error {
+  constructor(
+    public readonly agent: string,
+    public readonly prompt: string,
+    public readonly classification: DispatchClassification,
+  ) {
+    super(
+      `Zeus delegate escalate: agent "${agent}" returned ${classification} even after retry (prompt: "${prompt.slice(0, 80)}") — escalate to user: (a) try different agent, (b) simplify scope, (c) manual`,
+    )
+    this.name = 'ZeusEscalationError'
+  }
+}
+
+// ─── Low-level helper — wraps any async delegate+read pair ───────────────
+
+/**
+ * Low-level retry helper. Zeus waves that already have a `delegate+read`
+ * pair can use this directly without the board/client machinery:
+ *
+ * ```ts
+ * const guard = createZeusRetryHelper({ logger })
+ * const out = await guard.executeWithRetry(
+ *   () => firstRead(),
+ *   () => secondRead(),
+ * )
+ * if (out.escalate) throw new ZeusEscalationError(...)
+ * ```
+ */
+export interface ZeusRetryHelper {
+  guard: DispatchGuard
+  /**
+   * Classify `first` and, if empty and budget allows, run `redispatch` once.
+   * Returns the final result plus escalation flag (true when still empty after
+   * the one allowed retry).
+   */
+  executeWithRetry(
+    first: DispatchResultLike,
+    redispatch: () => Promise<DispatchResultLike>,
+  ): Promise<{
+    result: DispatchResultLike
+    classification: DispatchClassification
+    retried: boolean
+    escalate: boolean
+  }>
+}
+
+export interface ZeusRetryHelperOptions extends DispatchGuardOptions {
+  /**
+   * R1: per-error-type retry policy. When provided, error-type retries with
+   * exponential backoff apply (auth → 0, rate_limit → N, ...); when absent
+   * the legacy hard-cap-1 empty-result retry applies.
+   */
+  retryPolicy?: RetryPolicy
+  /** R1: provider cooldown tracker (shared across helpers for global cooldown). */
+  cooldown?: ProviderCooldownTracker
+  /** R1: provider name for cooldown tracking (default "default"). */
+  provider?: string
+  /** R1: injectable sleep for tests (default: setTimeout promise). */
+  sleep?: (ms: number) => Promise<void>
+}
+
+export function createZeusRetryHelper(options?: ZeusRetryHelperOptions): ZeusRetryHelper {
+  const guard = createDispatchGuard(options)
+  const engine =
+    options?.retryPolicy !== undefined
+      ? new RetryPolicyEngine(options.retryPolicy, options.cooldown)
+      : undefined
+  const provider = options?.provider ?? 'default'
+  const sleep =
+    options?.sleep ?? ((ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms)))
+  return {
+    guard,
+    async executeWithRetry(first, redispatch) {
+      if (engine === undefined) {
+        // Legacy path (unchanged): hard cap 1 on empty results.
+        const out = await guard.maybeRetry(first, redispatch)
+        const escalate = out.classification !== 'content'
+        return {
+          result: out.result,
+          classification: out.classification,
+          retried: out.retried,
+          escalate,
+        }
+      }
+      // R1 path: classify the failure, apply the per-error-type policy with
+      // exponential backoff, and track provider cooldown. A content result
+      // records success (resets the provider's failure counter); an
+      // exhausted budget records failure (feeds the cooldown tracker).
+      let result = first
+      let attemptsUsed = 0
+      let retried = false
+      let classification = guard.classifyResult(result)
+      let lastError: unknown =
+        result.error ??
+        (classification === 'content' ? undefined : new Error('empty dispatch result'))
+      for (;;) {
+        if (classification === 'content') {
+          engine.recordSuccess(provider)
+          return { result, classification, retried, escalate: false }
+        }
+        lastError = result.error ?? lastError
+        const decision = engine.decide(provider, lastError, attemptsUsed)
+        if (!decision.shouldRetry) {
+          engine.recordFailure(provider, lastError)
+          return { result, classification, retried, escalate: true }
+        }
+        retried = true
+        attemptsUsed += 1
+        await sleep(decision.delayMs)
+        try {
+          result = await redispatch()
+          lastError = undefined
+        } catch (err: unknown) {
+          lastError = err
+        }
+        classification = guard.classifyResult(result)
+      }
+    },
+  }
+}
+
+// ─── High-level helper — full delegate → wait → read → retry → escalate ───
+
+/**
+ * High-level helper Zeus waves MUST use (see `src/agents/zeus.md`).
+ * Delegates a background agent as a child session, waits for terminal,
+ * classifies via `createDispatchGuard`, retries ONCE on empty-mode1/mode2,
+ * and escalates (throws `ZeusEscalationError`) if still empty.
+ *
+ * Not wired automatically in the plugin — opencode 1.18.x cannot intercept
+ * task completion via hooks, so wiring is manual-orchestration only.
+ */
+export async function zeusDelegateWithRetry(
+  opts: ZeusDelegateWithRetryOptions,
+): Promise<ZeusDelegateResult> {
+  const logger = opts.logger ?? log
+  const warn = logger.warn.bind(logger)
+  const board = opts.board
+  const client = opts.client
+  const sessionID = opts.sessionID
+
+  const sessionPath = safeSessionPath(sessionID)
+  if (!sessionPath) {
+    warn(`zeusDelegateWithRetry: invalid sessionID "${sessionID}" — aborting`)
+    throw new Error(`invalid sessionID: ${sessionID}`)
+  }
+
+  const readTimeoutMs = opts.readTimeoutMs ?? DELEGATION_DEFAULTS.readTimeoutMs
+  const outputDir = opts.outputDir ?? DELEGATION_DEFAULTS.outputDir
+  const retryHelper = createZeusRetryHelper({
+    retryOnEmpty: opts.retryOnEmpty ?? true,
+    logger,
+    ...(opts.retryPolicy !== undefined ? { retryPolicy: opts.retryPolicy } : {}),
+    ...(opts.cooldown !== undefined ? { cooldown: opts.cooldown } : {}),
+    ...(opts.provider !== undefined ? { provider: opts.provider } : {}),
+  })
+
+  // One delegate+read attempt. Factored so maybeRetry can invoke a second
+  // attempt with a fresh child session + board job.
+  async function runOnce(): Promise<{
+    alias: string
+    taskID: string
+    report: string
+    dispatchResult: DispatchResultLike
+  }> {
+    // 1. Create child session (parentID = caller). No model forwarding here —
+    // delegation.ts resolves models via routing.yml; this helper uses the
+    // bare SDK default unless opts.model is supplied (explicit caller intent).
+    let childID: string
+    try {
+      const created = await client.session.create({
+        body: {
+          parentID: sessionID,
+          title: opts.description ?? opts.prompt.slice(0, 80),
+          ...(opts.model !== undefined ? { model: opts.model } : {}),
+        },
+      })
+      childID = created.id
+    } catch (err: unknown) {
+      const reason = err instanceof Error ? err.message : String(err)
+      warn(`zeusDelegateWithRetry: session.create failed: ${reason}`)
+      throw new Error(`delegate session.create failed: ${reason}`)
+    }
+
+    const childPath = safeSessionPath(childID)
+    if (!childPath) {
+      warn(`zeusDelegateWithRetry: child sessionID invalid "${childID}"`)
+      throw new Error(`invalid child sessionID: ${childID}`)
+    }
+
+    // 2. Register on board (taskID == child session id)
+    const job = await board.registerLaunch({
+      taskID: childID,
+      parentSessionID: sessionID,
+      agent: opts.agent,
+      description: opts.description ?? opts.prompt,
+      objective: opts.prompt,
+    })
+
+    // 3. Fire-and-forget promptAsync on the child. Completion is observed via
+    // board.waitForTerminal, not via noReply — the spike refuted noReply.
+    // A promptAsync failure is logged but does not abort the wait — the board
+    // timeout will finalize the job.
+    void client.session
+      .promptAsync({
+        path: childPath.path,
+        body: { agent: opts.agent, parts: [{ type: 'text', text: opts.prompt }] },
+      })
+      .catch((err: unknown) => {
+        const reason = err instanceof Error ? err.message : String(err)
+        warn(`zeusDelegateWithRetry: promptAsync failed for ${childID}: ${reason}`)
+      })
+
+    // 4. Wait for terminal state
+    let terminal: Awaited<ReturnType<BackgroundJobBoard['waitForTerminal']>>
+    try {
+      terminal = await board.waitForTerminal(childID, readTimeoutMs)
+    } catch {
+      // Timed out waiting — treat as empty so the guard retries once
+      return {
+        alias: job.alias,
+        taskID: childID,
+        report: '',
+        dispatchResult: { content: '' },
+      }
+    }
+
+    // 5. Read report markdown
+    const report = (await readDelegationReport(outputDir, terminal)) ?? ''
+
+    // DispatchResultLike for classification: content = report markdown.
+    // Tokens are unavailable from the board/report path → mode1 when empty.
+    const dispatchResult: DispatchResultLike = { content: report }
+
+    return { alias: job.alias, taskID: childID, report, dispatchResult }
+  }
+
+  // First attempt
+  const first = await runOnce()
+
+  // Classify + maybe retry once — capture second run's metadata via closure
+  let secondRun: typeof first | undefined
+  const out = await retryHelper.executeWithRetry(first.dispatchResult, async () => {
+    const second = await runOnce()
+    secondRun = second
+    return second.dispatchResult
+  })
+
+  // When retried, return second run's report or escalate
+  if (out.retried && secondRun !== undefined) {
+    if (out.classification === 'content') {
+      return {
+        alias: secondRun.alias,
+        taskID: secondRun.taskID,
+        report: secondRun.report,
+        classification: out.classification,
+        retried: true,
+      }
+    }
+    // Still empty after retry → escalate
+    throw new ZeusEscalationError(opts.agent, opts.prompt, out.classification)
+  }
+
+  // No retry, or first was content
+  if (out.classification !== 'content') {
+    // Empty and retry budget exhausted (or retryOnEmpty:false) → escalate
+    // But if we already retried and failed we threw above; this path is for
+    // the case where maybeRetry did NOT retry (budget exhausted or disabled)
+    // and the first result was empty. Per spec, one retry is allowed — if
+    // maybeRetry didn't retry, we should NOT auto-escalate here unless the
+    // guard's budget was used. Instead, treat as final empty that still
+    // requires escalation when retried==false but classification empty and
+    // retryOnEmpty was true but guard had no budget left? The guard already
+    // enforces cap 1, so after one retry escalate is required. For the
+    // first-attempt-empty with no retry (retryOnEmpty false), we still escalate
+    // so the wave knows to handle it.
+    if (out.retried) {
+      throw new ZeusEscalationError(opts.agent, opts.prompt, out.classification)
+    }
+    // No retry happened — still empty. Escalate so the wave doesn't silently
+    // use an empty report.
+    throw new ZeusEscalationError(opts.agent, opts.prompt, out.classification)
+  }
+
+  return {
+    alias: first.alias,
+    taskID: first.taskID,
+    report: first.report,
+    classification: out.classification,
+    retried: out.retried,
+  }
+}

package/src/plugin.ts

@@ -15,6 +15,7 @@ import {
   createEnforcementGuard,
   readOnlyRegistry,
   SessionHierarchyRegistry,
+  zeusReadGuard,
 } from './pantheon/delegation-enforce.ts'
 import { handleDelegationEvent } from './pantheon/delegation-notify.ts'
 import { FilePersistenceAdapter } from './pantheon/file-persistence.ts'
@@ -24,7 +25,14 @@ import { createHashlineEditTool } from './pantheon/hashline/tool.ts'
 import { createIdleDispatcher } from './pantheon/idle-continuation.ts'
 import { createPantheonLogger } from './pantheon/logger.ts'
 import { pantheonPluginOnce } from './pantheon/plugin-once.ts'
-import { applyActivePresetToConfig, loadRoutingAgentModels } from './pantheon/presets.mjs'
+import {
+  applyActivePresetToConfig,
+  loadRoutingAgentModels,
+  loadRoutingMaxSteps,
+  loadRoutingPermissionTask,
+} from './pantheon/presets.mjs'
+import { safeSessionPath } from './pantheon/session-guard.ts'
+import { StepCapTracker } from './pantheon/step-cap.ts'
 import {
   TODO_ENFORCER_DEFAULTS,
   TodoEnforcer,
@@ -53,6 +61,17 @@ const log = createPantheonLogger({ module: 'pantheon-plugin' })
 // plugin never throws at startup.
 const routingAgentModels = loadRoutingAgentModels({ logger: log })
 
+// R4: per-agent step caps from routing.yml `agents.<name>.max_steps`
+// (fail-open → {} = no agent capped). R1 retry_policy/cooldown are NOT
+// wired here — the plugin has no retry path (opencode cannot intercept task
+// completion); zeus waves load them via presets.mjs loaders and pass them
+// to zeusDelegateWithRetry explicitly.
+const stepCapTracker = new StepCapTracker(loadRoutingMaxSteps({ logger: log }))
+
+// O5: permission.task glob rules from routing.yml `permission.task`
+// (fail-open → undefined = existing runtime matrix only).
+const routingPermissionTask = loadRoutingPermissionTask({ logger: log })
+
 const board = new BackgroundJobBoard({
   maxConcurrentPerAgent: 3,
   signalDir: '.pantheon/deepwork/board-signals',
@@ -193,15 +212,31 @@ function adaptDelegationClient(client: PluginInput['client']): DelegationClient
         return { id: result.data.id }
       },
       promptAsync: async (input) => {
+        const path = safeSessionPath(input.path.id)
+        if (!path) {
+          log.warn(`[Pantheon Plugin] promptAsync skipped: invalid sessionID "${input.path.id}"`)
+          throw new Error(`invalid sessionID: ${input.path.id}`)
+        }
         const result = await client.session.promptAsync({
-          path: input.path,
-          body: { agent: input.body.agent, parts: input.body.parts },
+          path: path.path,
+          body: {
+            agent: input.body.agent,
+            ...(input.body.model !== undefined
+              ? { model: { providerID: input.body.model.providerID, modelID: input.body.model.id } }
+              : {}),
+            parts: input.body.parts,
+          },
         })
         if (result.error) throw new Error(sdkErrorMessage(result.error))
         return result.data
       },
       messages: async (input) => {
-        const result = await client.session.messages({ path: input.path })
+        const path = safeSessionPath(input.path.id)
+        if (!path) {
+          log.warn(`[Pantheon Plugin] messages skipped: invalid sessionID "${input.path.id}"`)
+          return []
+        }
+        const result = await client.session.messages({ path: path.path })
         if (result.error) throw new Error(sdkErrorMessage(result.error))
         return result.data
       },
@@ -219,22 +254,42 @@ function adaptTodoEnforcerClient(client: PluginInput['client']): TodoEnforcerCli
   return {
     session: {
       todo: async (input) => {
-        const result = await client.session.todo({ path: input.path })
+        const path = safeSessionPath(input.path.id)
+        if (!path) {
+          log.warn(`[Pantheon Plugin] todo skipped: invalid sessionID "${input.path.id}"`)
+          return []
+        }
+        const result = await client.session.todo({ path: path.path })
         if (result.error) throw new Error(sdkErrorMessage(result.error))
         return result.data
       },
       messages: async (input) => {
-        const result = await client.session.messages({ path: input.path })
+        const path = safeSessionPath(input.path.id)
+        if (!path) {
+          log.warn(`[Pantheon Plugin] messages skipped: invalid sessionID "${input.path.id}"`)
+          return []
+        }
+        const result = await client.session.messages({ path: path.path })
         if (result.error) throw new Error(sdkErrorMessage(result.error))
         return result.data
       },
       children: async (input) => {
-        const result = await client.session.children({ path: input.path })
+        const path = safeSessionPath(input.path.id)
+        if (!path) {
+          log.warn(`[Pantheon Plugin] children skipped: invalid sessionID "${input.path.id}"`)
+          return []
+        }
+        const result = await client.session.children({ path: path.path })
         if (result.error) throw new Error(sdkErrorMessage(result.error))
         return result.data
       },
       promptAsync: async (input) => {
-        const result = await client.session.promptAsync({ path: input.path, body: input.body })
+        const path = safeSessionPath(input.path.id)
+        if (!path) {
+          log.warn(`[Pantheon Plugin] promptAsync skipped: invalid sessionID "${input.path.id}"`)
+          throw new Error(`invalid sessionID: ${input.path.id}`)
+        }
+        const result = await client.session.promptAsync({ path: path.path, body: input.body })
         if (result.error) throw new Error(sdkErrorMessage(result.error))
         return result.data
       },
@@ -302,6 +357,8 @@ const plugin: Plugin = async (input: PluginInput) => {
       readOnlyAgents: new Set(['apollo', 'gaia']),
       agentModels: routingAgentModels,
       delegationBudgets,
+      stepCapTracker,
+      ...(routingPermissionTask != null ? { permissionTask: routingPermissionTask } : {}),
       ...(wallClockTimeoutMs !== undefined ? { wallClockTimeoutMs } : {}),
     },
   })
@@ -484,11 +541,13 @@ const plugin: Plugin = async (input: PluginInput) => {
     // Phase 4: deny mutating tools in read-only delegated sessions. Additive
     // key — does not touch Phase 3's tools/event/onTerminal/chat.message.
     'tool.execute.before': async (input, output) => {
-      // Chain: the read-only enforcement guard runs first (denies mutating
-      // tools in read-only sessions), then release-134 Phase 3 rewrites the
-      // first post-compaction `todowrite` with the captured todo snapshot.
-      // Both are no-ops for non-matching sessions/tools; the preserver is
-      // fail-open (only its intentional restore denial throws).
+      // Chain: Zeus read guard runs first (denies read/glob/grep of source
+      // code when the active agent is Zeus — delegate to @apollo), then the
+      // read-only enforcement guard (denies mutating tools in read-only
+      // sessions), then release-134 Phase 3 rewrites the first
+      // post-compaction `todowrite` with the captured todo snapshot. All are
+      // no-ops for non-matching sessions/tools.
+      zeusReadGuard(input.tool, output?.args, sessionAgents.get(input.sessionID))
       await enforcementGuard(input, output)
       await todoPreserver.beforeTodoWrite(input, output)
     },

package/src/plugins/hook-runner.ts

@@ -22,7 +22,7 @@
  * is returned as a structured HookResult so the opencode session can never be
  * taken down by the security layer.
  */
-import { spawn, type ChildProcessWithoutNullStreams } from 'node:child_process'
+import { type ChildProcessWithoutNullStreams, spawn } from 'node:child_process'
 import path from 'node:path'
 import type { Readable } from 'node:stream'
 import { fileURLToPath } from 'node:url'

package/src/plugins/pantheon-hooks.ts

@@ -192,8 +192,8 @@ import {
   enqueueChatReminder,
   pendingChatReminders,
 } from '../pantheon/chat-reminders.ts'
-import { type HookPayload, type HookResult, runHook } from './hook-runner.ts'
 import { pantheonPluginOnce } from '../pantheon/plugin-once.ts'
+import { type HookPayload, type HookResult, runHook } from './hook-runner.ts'
 
 /** Tools that represent a subagent delegation (opencode `task` tool etc.). */
 const DELEGATION_TOOL_RE = /^(task|.*delegate.*|.*subagent.*)$/i

package/src/plugins/tui/dist/tui.d.ts

@@ -11,7 +11,7 @@ type DelegationEntry = {
   taskID?: string;
   /** Agent name, e.g. "apollo". */
   agent: string;
-  state: 'running' | 'completed' | 'error' | 'cancelled';
+  state: 'running' | 'completed' | 'error' | 'startup_failed' | 'startup_unknown' | 'cancelled';
   /** Epoch ms of the `Started` header. */
   startedAt: number;
   /** Epoch ms of the `Finalized` header — null while still running. */

package/src/plugins/tui/dist/tui.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tui.d.ts","names":[],"sources":["../src/index.tsx"],"mappings":";;KAm5BY;;EAEV;;EAEA;;;;EAIA;;EAEA;EACA;;EAEA;;EAEA;EACA;EACA;;EAEA;;;;EAIA;;;;;;;;;;;iBAsBc,wBACd,aACA,oBACA,qBACC;;;;;;iBA8GmB,sBAAsB,cAAc,QAAQ;;;;;;;;iBAwC5C,yBAAyB,eAAe,QAAQ;;;;;;;;iBAWtD,sBACd;EAAS;EAAoB;eAC7B;;;;;;iBAYc,YAAY;;;iBAMZ,WAAW;;;;iBAOX,yBAAyB,GAAG,iBAAiB,GAAG;;;;;iBAWhD,sBACd,cAAc,mBACd,uBACC;;;iBAQa,WAAW;;;iBAcX,kBAAkB,OAAO,iBAAiB;;;KAO9C;iBAQI,mBAAmB,OAAO,kBAAkB;iBAS5C,wBAAwB,OAAO;;iBAoB/B,uBAAuB;;;;;;;iBAWvB,4BACd,mBAAmB,mBACnB,eAAe,wBACd;;KA2DS;EACV;EACA;EACA;EACA;EACA;EACA;IACE;IACA,QAAQ;IACR;IACA;IACA;MAAS;MAAgB;;;;;KAKjB;;EAEV;;EAEA;;EAEA;EACA;;EAEA;EACA;;EAEA;;EAEA;EACA;EACA;EACA;;EAEA;;;KAIU;EACV;EACA;EACA;EACA;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;;;;;iBAac,wBACd,MAAM,oBACN,eACC;;;iBA+Ea,yBACd,KAAK,YAAY,sBACjB,MAAM,oBACN;;;iBA+Fc,sBACd,KAAK,YAAY,sBACjB;;;;;;iBAiBc,2BACd;EAAqB;EAAa;iBAClC,YAAY,uDACX;;;;;iBA2Ba,sBACd,KAAK,YAAY,sBACjB,gBAAgB,sBAChB;;;iBAWc,kBAAkB,MAAM,sBAAsB;;;;;;iBAqB9C,uBACd,eAAe,uBACf,aAAa,oBACZ;;;;;;;;;iBA8Da,iBAAiB,cAAc;;;;KAOnC;;EAEV;EACA;;IAEE;MAAU;;;IAEV;MAAU;QAAY;QAAe,SAAS;;;;;;;;;;iBASlC,wBAAwB,SAAS;;;;;;;;iBAmBjC,gBAAgB;EAAgB;IAAQ;;;;;;;iBASxC,kBAAkB;EAAkC;IAAQ;;;;KAKhE;;EAEV;;EAEA;;;EAGA;;;EAGA;EACA;IACE;IACA;;;;;;;iBAQY,mBAAmB;;;;;iBASnB,cAAc,OAAO;;;;;;;;;;;;;;iBAiBrB,4BACd,mBAAmB,mCACnB,aAAa,mBACb,eACC;;;;;;iBAwCa,4BACd;EAAS,YAAY,cAAc,SAAS;eAC5C;;;;;KA8KU;EACV,KAAK,YAAY;;EAEjB;;EAEA;;cAicI,QAAQ;EAAoB"}
+{"version":3,"file":"tui.d.ts","names":[],"sources":["../src/index.tsx"],"mappings":";;KAq6BY;;EAEV;;EAEA;;;;EAIA;;EAEA;EACA;;EAEA;;EAEA;EACA;EACA;;EAEA;;;;EAIA;;;;;;;;;;;iBAsBc,wBACd,aACA,oBACA,qBACC;;;;;;iBAgHmB,sBAAsB,cAAc,QAAQ;;;;;;;;iBAwC5C,yBAAyB,eAAe,QAAQ;;;;;;;;iBAWtD,sBACd;EAAS;EAAoB;eAC7B;;;;;;iBAYc,YAAY;;;iBAMZ,WAAW;;;;iBAOX,yBAAyB,GAAG,iBAAiB,GAAG;;;;;iBAWhD,sBACd,cAAc,mBACd,uBACC;;;iBAQa,WAAW;;;iBAcX,kBAAkB,OAAO,iBAAiB;;;KAO9C;iBAQI,mBAAmB,OAAO,kBAAkB;iBAc5C,wBAAwB,OAAO;;iBAoB/B,uBAAuB;;;;;;;iBAWvB,4BACd,mBAAmB,mBACnB,eAAe,wBACd;;KAmFS;EACV;EACA;EACA;EACA;EACA;EACA;IACE;IACA,QAAQ;IACR;IACA;IACA;MAAS;MAAgB;;;;;KAKjB;;EAEV;;EAEA;;EAEA;EACA;;EAEA;EACA;;EAEA;;EAEA;EACA;EACA;EACA;;EAEA;;;KAIU;EACV;EACA;EACA;EACA;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;;;;;iBAac,wBACd,MAAM,oBACN,eACC;;;iBA+Ea,yBACd,KAAK,YAAY,sBACjB,MAAM,oBACN;;;iBA+Fc,sBACd,KAAK,YAAY,sBACjB;;;;;;iBAiBc,2BACd;EAAqB;EAAa;iBAClC,YAAY,uDACX;;;;;iBA2Ba,sBACd,KAAK,YAAY,sBACjB,gBAAgB,sBAChB;;;iBAWc,kBAAkB,MAAM,sBAAsB;;;;;;iBAqB9C,uBACd,eAAe,uBACf,aAAa,oBACZ;;;;;;;;;iBA8Da,iBAAiB,cAAc;;;;KAOnC;;EAEV;EACA;;IAEE;MAAU;;;IAEV;MAAU;QAAY;QAAe,SAAS;;;;;;;;;;iBASlC,wBAAwB,SAAS;;;;;;;;iBAmBjC,gBAAgB;EAAgB;IAAQ;;;;;;;iBASxC,kBAAkB;EAAkC;IAAQ;;;;KAKhE;;EAEV;;EAEA;;;EAGA;;;EAGA;EACA;IACE;IACA;;;;;;;iBAQY,mBAAmB;;;;;iBASnB,cAAc,OAAO;;;;;;;;;;;;;;iBAiBrB,4BACd,mBAAmB,mCACnB,aAAa,mBACb,eACC;;;;;;iBAwCa,4BACd;EAAS,YAAY,cAAc,SAAS;eAC5C;;;;;KA8KU;EACV,KAAK,YAAY;;EAEjB;;EAEA;;cAucI,QAAQ;EAAoB"}