pi-ptc-subagents 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,437 @@
+import { ExtensionAPI, Skill } from "@earendil-works/pi-coding-agent";
+import { MessagePort } from "node:worker_threads";
+//#region src/mode/ptc-mode.d.ts
+/** The two surfaces this package exposes. `/ptc on` needs at least one of them active. */
+export declare const PTC_MODE_TOOL_NAMES: readonly string[];
+/**
+ * Tools that must all be present for the **automatic** entry path to proceed.
+ *
+ * These four are pi's default session surface (`agent-session.js`: "["read", "bash", "edit",
+ * "write"]"), so "all four present" means "this session was not narrowed". Comparing against
+ * `BUILTIN_BINDING_NAMES` instead would be wrong: that list is the set of names that *can* be
+ * bound, not what a default session has (`grep` / `find` / `ls` are bindable but off by default),
+ * so requiring all seven would misread every ordinary session as restricted and never turn on.
+ */
+export declare const MODE_REQUIRED_TOOL_NAMES: readonly string[];
+/** `customType` for the persisted mode entry (`pi.appendEntry`). */
+export declare const PTC_MODE_ENTRY_TYPE = "ptc-mode";
+/** Footer status key (`ctx.ui.setStatus`). */
+export declare const PTC_MODE_STATUS_KEY = "ptc-mode";
+/** Config file name, resolved against pi's agent dir (`~/.pi/agent/`). */
+export declare const PTC_MODE_CONFIG_FILE = "ptc.json";
+/** How much of the loadout the mode hides. */
+type ModeHideStrategy = "builtins-only" | "all-but-ptc";
+/**
+ * Which tools the mode hides while it is on.
+ *
+ * - `"builtins-only"` (default) — hide the seven built-in tools; tools contributed by *other*
+ *   extensions (`web_search`, `todo`, `subagent`, …) stay visible and directly callable. The
+ *   model is forced to program for file and shell work, which is the bulk of a coding session,
+ *   without losing capabilities this package cannot re-expose: extension tools have no bindings
+ *   (`pi.getAllTools()` returns metadata only — no `execute`), so hiding one makes it
+ *   unreachable for the whole session.
+ * - `"all-but-ptc"` — hide everything except the two PTC surfaces. Closest to a strict reading of
+ *   DSH's preset, at the cost of making other extensions' tools unreachable until `/ptc off`.
+ */
+export declare const DEFAULT_HIDE_STRATEGY: ModeHideStrategy;
+/** Live mode state. `base` / `ourLoadout` are `undefined` while the mode is off. */
+interface PtcModeState {
+  enabled: boolean;
+  /** Loadout captured before the mode narrowed anything; bindings derive from this. */
+  base: readonly string[] | undefined;
+  /** Exactly the array handed to `setActiveTools`; a mismatch means someone else changed it. */
+  ourLoadout: readonly string[] | undefined;
+}
+/** Fresh, disabled state. */
+export declare function initialModeState(): PtcModeState;
+/**
+ * A persisted mode record lives in the session (`pi.appendEntry`), so `/ptc off` survives a
+ * resume and a `/reload` can put the loadout back the way it found it.
+ */
+interface PersistedModeState {
+  enabled: boolean;
+  base?: readonly string[];
+}
+/** Result of reading the opt-out config, with enough detail to warn about a broken file. */
+interface DefaultModeConfig {
+  defaultMode: boolean;
+  source: "file" | "default" | "invalid";
+  error?: string;
+}
+/**
+ * Read `defaultMode` from the agent-dir config file.
+ *
+ * Absent file → on (this package is default-on by design; see CONTEXT.md). A present file with a
+ * non-boolean `defaultMode`, or unparseable JSON, is reported as `invalid` **and still defaults to
+ * on** — the caller should surface the problem rather than silently changing behavior.
+ */
+export declare function readDefaultModeConfig(agentDir: string): DefaultModeConfig;
+/** Why the mode declined to turn on. Surfaced in the entry notification / debug logs. */
+type ModeBlockReason = "not-tui" | "config-off" | "tools-unavailable" | "restricted-session";
+/** Either the loadout to apply, or the reason the mode stayed off. */
+type ModeEntryDecision = {
+  enter: true;
+  base: readonly string[];
+  loadout: readonly string[];
+} | {
+  enter: false;
+  reason: ModeBlockReason;
+};
+/** Inputs to the entry decision. `active` is `pi.getActiveTools()` at decision time. */
+interface ModeEntryInput {
+  /** `ctx.mode` — only `"tui"` participates. */
+  mode: string;
+  /** Resolved `defaultMode` from the config file. */
+  defaultMode: boolean;
+  /** The session's current tool loadout. */
+  active: readonly string[];
+  /** True for `/ptc on`, which overrides the config and the restricted-session policy. */
+  manual: boolean;
+  /** Overrides `DEFAULT_HIDE_STRATEGY` (tests, or a future settings surface). */
+  hide?: ModeHideStrategy | undefined;
+}
+/** Order- and duplicate-insensitive set equality, for loadout comparison. */
+export declare function sameToolSet(a: readonly string[], b: readonly string[]): boolean;
+/**
+ * The loadout applied while the mode is on, given the session's current one.
+ *
+ * Always keeps the PTC surfaces; what else survives depends on the hide strategy (see
+ * `DEFAULT_HIDE_STRATEGY`). Order follows `active`, so the visible list reads the way the session
+ * was configured.
+ */
+export declare function modeLoadout(active: readonly string[], hide: ModeHideStrategy): string[];
+/**
+ * Decide whether the mode turns on for this session.
+ *
+ * The policy, in order:
+ * 1. **TUI only** — print / JSON / RPC sessions are never touched.
+ * 2. **Config** — `{"defaultMode": false}` opts out; `/ptc on` overrides it.
+ * 3. **PTC tools must exist** — if this session has them disabled, there is nothing to run.
+ * 4. **Explicit restriction wins** — a session launched with `--tools` / `--exclude-tools` /
+ *    `--no-builtin-tools` that is missing any of `MODE_REQUIRED_TOOL_NAMES` (pi's default four)
+ *    stays as launched. Narrowing *further* would be the extension overriding a deliberate user
+ *    instruction, and the PTC surface would be degraded anyway (bindings = `BUILTIN ∩ base`).
+ *    `/ptc on` overrides this: the manual path enters with the restricted loadout as `base`, so
+ *    bindings stay inside the user's allowlist.
+ */
+export declare function decideModeEntry(input: ModeEntryInput): ModeEntryDecision;
+/**
+ * Tool names the binding table should be built from.
+ *
+ * While the mode is on this is the base snapshot (so the built-ins the mode just hid remain
+ * callable from inside a program); otherwise it is simply the live loadout, i.e. T7's rule.
+ */
+export declare function bindingSource(state: PtcModeState, active: readonly string[]): readonly string[];
+/**
+ * Whether the live loadout is no longer the one this mode wrote — i.e. another extension (or the
+ * user) took ownership of the tool set. Always false while the mode is off.
+ */
+export declare function detectExternalLoadoutChange(state: PtcModeState, active: readonly string[]): boolean;
+/**
+ * Reconstruct the base loadout on `session_start`.
+ *
+ * Two shapes are possible:
+ * - The session is still narrowed from a previous run of this mode (a `/reload`, or a resumed
+ *   session): the live loadout is a subset of the PTC tools and the persisted record says the mode
+ *   was on. The persisted `base` is then authoritative — but only to *undo our own hiding*.
+ * - Otherwise the live loadout is whatever this pi process was launched with, and it wins. That is
+ *   what keeps a new `--tools …` choice from being overridden by an older session's snapshot.
+ */
+export declare function resolveBaseOnStart(persisted: PersistedModeState | undefined, active: readonly string[]): {
+  base: readonly string[];
+  restoreFirst: boolean;
+};
+/**
+ * Build the system-visible briefing for the mode.
+ *
+ * Generated from the *actual* binding list rather than hardcoded, because bindings vary by session
+ * (`base` is whatever the session was launched with) and a stale list would have the model calling
+ * names that are not bound.
+ */
+export declare function buildModeInstruction(bindings: readonly string[], hide: ModeHideStrategy): string;
+//#endregion
+//#region src/mode/skills-section.d.ts
+/** The two tools pi accepts as "this session can read a skill file". */
+export declare const SKILL_READING_TOOL_NAMES: readonly string[];
+/** What replaces it: the same instruction, in the only call form this session has. */
+export declare const PTC_SKILL_LOAD_INSTRUCTION = "Use tools.read({ path }) inside a ptc_run_code program to load a skill's file when the task matches its description.";
+/**
+ * Would pi withhold the skills section for this loadout?
+ *
+ * Mirrors the gate rather than guessing: it is true exactly when neither `read` nor `bash` is
+ * directly callable, which is the state the mode deliberately puts an ordinary session in.
+ */
+export declare function skillsSectionDropped(visibleTools: readonly string[]): boolean;
+/**
+ * Build the `skills` section body (pi wraps it in `<skills>…</skills>` itself).
+ *
+ * Returns `""` when nothing is advertisable — pi's formatter filters out skills marked
+ * `disable-model-invocation`, which is the correct behaviour to inherit: those are
+ * `/skill:name`-only by design.
+ *
+ * `format` is injectable so a test can drive the reworded-header branch without patching pi.
+ */
+export declare function buildPtcSkillsSection(skills: readonly Skill[], format?: (skills: Skill[], fileReadTool?: "read" | "bash") => string): string;
+//#endregion
+//#region src/runtime/limits.d.ts
+/**
+ * PTC run limits and spawn-time hardening, in one frozen `DEFAULT_CONFIG`.
+ *
+ * The numbers are DSH's (`dsh-v0.1.6-alpha.2`, `@deepseek-ai/dsh-ptc-runtime-node`)
+ * carried over verbatim — see ADR-0003 (output budget), ADR-0004 (pending calls) and
+ * ADR-0005 (execution boundary, F1–F4). Tests assert against these constants rather
+ * than repeating the literals, so a future re-sync only has to change this file.
+ *
+ * Deliberately absent:
+ * - `syncTimeoutMs` / `maxConcurrentAgents` / `maxTotalAgents` — workflow-engine caps
+ *   for a cooperative VM and for `agent()`. We run the program directly in the worker
+ *   realm (no VM) and ship no `agent()` (G1 #13 → B), so there is nothing to cap.
+ * - `sandbox-unavailable` is not an error kind either: ADR-0007 ships no OS sandbox.
+ */
+/** The two worker surfaces. Each run gets a fresh worker with exactly one of them. */
+type PtcSurface = "run_code" | "workflow";
+interface PtcConfig {
+  /** Default elapsed deadline for a run, including nested binding waits (R1 §1). */
+  timeoutMs: number;
+  /** Ceiling the requested deadline is clamped to. */
+  maxTimeoutMs: number;
+  /** Joint budget for serialized logs + completion value (ADR-0003). */
+  maxOutputBytes: number;
+  /** Cap on a single control frame, either direction (R1 §1). */
+  maxMessageBytes: number;
+  /** Admission control for simultaneously in-flight worker→host binding calls (ADR-0004). */
+  maxPendingCalls: number;
+  /** Concurrent binding dispatches; DSH's `maxParallelSubCalls` (ADR-0004 consequence).
+   *  Renamed in spirit by ADR-0016 section 2: the cap that really matters for
+   *  resource safety is the per-run `dispatchConcurrency` below. This field
+   *  is kept for backward compatibility (and for the in-process builtin
+   *  binding fan-out) but is no longer the authoritative limit on the
+   *  parallel binding `pi.dispatch`. */
+  maxParallelSubCalls: number;
+  /** Per-run hard cap on concurrently in-flight `pi.dispatch(...)` calls.
+   *  Default 8, matches pi's `subagent` extension `MAX_PARALLEL_TASKS`.
+   *  ADR-0016 section 2. */
+  dispatchConcurrency: number;
+  /** Maximum recursion depth for `pi.dispatch`. The child PTC run spawned by
+   *  the (depth+1)-th dispatch is allowed only when childDepth <= maxDispatchDepth.
+   *  Default 3. Aligns with dsh's `SubagentCapabilities.depthLimit` and codex's
+   *  `agent_max_depth`. ADR-0016 Recursive dispatch section. */
+  maxDispatchDepth: number;
+  /** Items accepted by a single `parallel()` / `pipeline()` call (R1 §1, workflow-side; pinned
+   *  here because it guards a helper call rather than an agent budget). */
+  maxItemsPerCall: number;
+  /** Cooperative-cancel grace before the worker is terminated outright. */
+  graceMs: number;
+  /** V8 old-generation cap handed to `new Worker({ resourceLimits })` (F2). */
+  maxOldGenerationSizeMb: number;
+  /** V8 young-generation cap handed to `new Worker({ resourceLimits })` (F2). */
+  maxYoungGenerationSizeMb: number;
+}
+export declare const DEFAULT_CONFIG: Readonly<PtcConfig>;
+/**
+ * F1 — the only environment variables a PTC worker may inherit.
+ *
+ * These are what a shell needs to resolve binaries on each platform; everything
+ * else the host has (tokens, API keys, proxies, home paths) stays out of the worker.
+ */
+export declare const WORKER_ENV_ALLOW_LIST: readonly string[];
+/**
+ * Build the per-run environment snapshot: the allow-list entries that actually exist.
+ *
+ * Unset or empty entries are dropped rather than passed through as empty strings, so
+ * `Object.keys(workerEnv)` is exactly what the worker sees in `process.env`.
+ */
+export declare function createWorkerEnv(source?: NodeJS.ProcessEnv): Record<string, string>;
+/**
+ * Merge per-run overrides onto `DEFAULT_CONFIG`.
+ *
+ * Overrides are validated rather than coerced: a negative or non-numeric limit is a
+ * caller bug, and silently substituting a default would hide it.
+ */
+export declare function resolveConfig(overrides?: Partial<PtcConfig>): PtcConfig;
+/**
+ * Resolve the effective deadline for one run.
+ *
+ * DSH semantics (R1 §3): `0` does not disable the deadline, it falls back to the
+ * default; anything larger is clamped to `maxTimeoutMs`.
+ */
+export declare function effectiveTimeoutMs(requested: number | undefined, config?: PtcConfig): number;
+//#endregion
+//#region src/runtime/protocol.d.ts
+/** host → worker */
+declare const HOST_FRAME_KIND_VALUES: {
+  readonly connect: "connect";
+  readonly init: "init";
+  readonly callResult: "call-result";
+  readonly cancel: "cancel";
+};
+export declare const HOST_FRAME_KIND: typeof HOST_FRAME_KIND_VALUES;
+/** worker → host */
+declare const WORKER_FRAME_KIND_VALUES: {
+  readonly ready: "ready";
+  readonly call: "call";
+  readonly log: "log";
+  readonly narration: "narration";
+  readonly phase: "phase";
+  readonly result: "result";
+  readonly error: "error";
+};
+export declare const WORKER_FRAME_KIND: typeof WORKER_FRAME_KIND_VALUES;
+declare const PTC_LOG_LEVEL_VALUES: {
+  readonly log: "log";
+  readonly info: "info";
+  readonly warn: "warn";
+  readonly error: "error";
+  readonly debug: "debug";
+};
+export declare const PTC_LOG_LEVEL: typeof PTC_LOG_LEVEL_VALUES;
+declare const PTC_ERROR_KIND_VALUES: {
+  /** Program parse error or thrown exception (includes `ReferenceError` from a helper that does not exist on this surface). */
+  readonly exception: "exception";
+  /** Elapsed deadline expiry. */
+  readonly timeout: "timeout";
+  /** Caller cancellation. */
+  readonly abort: "abort";
+  /** Malformed or excessive control traffic. */
+  readonly protocol: "protocol";
+  /** Early worker exit or a worker-level crash. */
+  readonly workerExit: "worker-exit";
+  /** Completion value could not be materialized as lossless JSON. */
+  readonly invalidOutput: "invalid-output";
+  /** Oversized outer result; collected logs are retained. */
+  readonly outputLimit: "output-limit";
+};
+export declare const PTC_ERROR_KIND: typeof PTC_ERROR_KIND_VALUES;
+type PtcErrorKind = (typeof PTC_ERROR_KIND)[keyof typeof PTC_ERROR_KIND];
+/** Lossless-JSON payloads, the only values that may cross the boundary as data. */
+interface PtcJsonObject {
+  [key: string]: PtcJsonValue;
+}
+type PtcJsonValue = string | number | boolean | null | PtcJsonValue[] | PtcJsonObject;
+interface PtcErrorShape {
+  kind: PtcErrorKind;
+  message: string;
+  stack?: string;
+}
+//#endregion
+//#region src/tools/text.d.ts
+/** Hard cap for one rendered line; longer lines are truncated with `…`. */
+export declare const MAX_LINE_CHARS = 200;
+/** Drop ANSI escape sequences (colours, cursor moves, OSC hyperlinks). */
+export declare function stripAnsi(value: string): string;
+/**
+ * Make arbitrary program output safe to hand the model.
+ *
+ * Same three steps as pi's built-ins: strip ANSI, remove `\r` (a progress bar's carriage
+ * return is not a line break), then drop control characters other than `\n`/`\t` and the
+ * Unicode format characters that break width math. Lone surrogates fall out of code-point
+ * iteration for free.
+ */
+export declare function sanitizeText(value: string): string;
+/**
+ * Render a completion value for the model: strings verbatim, everything else as a compact
+ * `{key: value}` summary or an indented block — never `JSON.stringify` on the whole value, whose
+ * escaping destroys exactly the content a reader needs (newlines, quotes, non-ASCII spacing).
+ */
+export declare function renderModelValue(value: PtcJsonValue): string;
+//#endregion
+//#region src/runtime/bindings.d.ts
+/** pi's built-in tools that can be exposed as bindings, in native order. */
+export declare const BUILTIN_BINDING_NAMES: readonly ["read", "bash", "edit", "write", "grep", "find", "ls"];
+type BuiltinBindingName = (typeof BUILTIN_BINDING_NAMES)[number];
+export declare const DEFAULT_BINDING_NAMES: readonly BuiltinBindingName[];
+interface BindingContext {
+  /** Aborted when the run is cancelled, times out, or settles. */
+  signal?: AbortSignal;
+  /** Wire call id; also used to build the tool call id the tools see. */
+  callId: number;
+  /** Depth of the current PTC run (0 for parent turn, 1+ for a child of `pi.dispatch`). */
+  depth: number;
+  /** Maximum allowed depth; passed through to `pi.dispatch` for the depth check. */
+  maxDispatchDepth: number;
+}
+interface Binding {
+  readonly name: string;
+  execute(args: unknown, context: BindingContext): Promise<unknown>;
+}
+type BindingTable = ReadonlyMap<string, Binding>;
+interface CreateBuiltinBindingsOptions {
+  /** Per-run working directory: the F4 `RunConfig.cwd`, used to build every tool. */
+  cwd: string;
+  /** Subset of {@link BUILTIN_BINDING_NAMES}; defaults to all of them (bash included). */
+  names?: readonly string[];
+}
+/**
+ * Build the binding table for one run.
+ *
+ * Tools are created once per table and reused across calls, matching pi's own extension
+ * examples (`createXxxTool(cwd)` caches nothing internally, so one instance per run is
+ * the intended granularity).
+ */
+export declare function createBuiltinBindings(options: CreateBuiltinBindingsOptions): BindingTable;
+//#endregion
+//#region src/runtime/dispatcher.d.ts
+interface RunPtcProgramOptions {
+  /** Program body: an async function body (`return`/`await` at the top level). */
+  code: string;
+  surface: PtcSurface;
+  /** Working directory for bindings and the run's recorded cwd (F4). */
+  cwd: string;
+  /** Bindings the program may call; the table keys become `tools.<name>`. */
+  bindings: BindingTable;
+  /** Workflow surface only: value bound to the program's `args` global. */
+  args?: unknown;
+  /** Requested deadline; `0`/absent fall back to `timeoutMs`, then clamped to `maxTimeoutMs`. */
+  timeoutMs?: number;
+  /** Per-run limit overrides on top of `DEFAULT_CONFIG`. */
+  config?: Partial<PtcConfig>;
+  /** Cancels the run; the worker gets a cooperative cancel window before termination. */
+  signal?: AbortSignal;
+  /** Identifier carried to the worker; generated when omitted. */
+  runId?: string;
+}
+/**
+ * One image hoisted out of a successful binding result (DSH parity — see ADR-0014).
+ *
+ * `data` is base64 exactly as pi's own `read` tool returns it, so the tool layer can forward it as
+ * an `ImageContent` block without re-encoding.
+ */
+interface PtcImage {
+  data: string;
+  mimeType: string;
+}
+interface PtcRunOutcome {
+  /** `console.*` output in arrival order. */
+  logs: string[];
+  /** Workflow `log(message)` narration (observers only, never console output). */
+  narrations: string[];
+  /** Workflow `phase(title)` titles in arrival order. */
+  phases: string[];
+  /** Completion value; absent when the program returned nothing or the run failed. */
+  value?: PtcJsonValue;
+  /**
+   * Images hoisted out of successful binding results, in call order.
+   *
+   * Every image a program's tool calls produced, with no cap and no dedupe: how many images a run
+   * attaches is the program's business, exactly as it is in DSH. Present only when at least one was
+   * hoisted — a failed or cancelled run attaches nothing, because the tool layer throws for it
+   * (`codeRunFailedError`) and its image would never reach the model.
+   */
+  images?: PtcImage[];
+  /** Failure details; absent on success. */
+  error?: PtcErrorShape;
+}
+/**
+ * Run one PTC program in a fresh worker and resolve with its outcome.
+ *
+ * Never rejects for program/ limit / cancellation failures — those are reported as
+ * `outcome.error` so callers have one place to render from. It only throws on caller bugs
+ * (invalid config overrides).
+ */
+export declare function runPtcProgram(options: RunPtcProgramOptions): Promise<PtcRunOutcome>;
+//#endregion
+//#region src/index.d.ts
+export default function ptcSubagents(pi: ExtensionAPI): void;
+//#endregion
+export type { Binding, BindingContext, BindingTable, CreateBuiltinBindingsOptions, DefaultModeConfig, ModeBlockReason, ModeEntryDecision, ModeEntryInput, ModeHideStrategy, PersistedModeState, PtcConfig, PtcErrorKind, PtcErrorShape, PtcJsonValue, PtcModeState, PtcRunOutcome, PtcSurface, RunPtcProgramOptions };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/mode/ptc-mode.ts","../src/mode/skills-section.ts","../src/runtime/limits.ts","../src/runtime/protocol.ts","../src/tools/text.ts","../src/runtime/bindings.ts","../src/runtime/dispatcher.ts","../src/index.ts"],"mappings":";;;;qBA2Ca;;;;;;;;;;qBAWA;;qBAGA;;qBAGA;;qBAGA;;KAGD;;;;;;;;;;;;;qBAcC,uBAAuB;;UAGnB;EACf;;EAEA;;EAEA;;;wBAIc,oBAAoB;;;;;UAQnB;EACf;EACA;;;UAQe;EACf;EACA;EACA;;;;;;;;;wBAUc,sBAAsB,mBAAmB;;KAwC7C;;KAGA;EACN;EAAa;EAAyB;;EACtC;EAAc,QAAQ;;;UAGX;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA,OAAO;;;wBASO,YAAY,sBAAsB;;;;;;;;wBAclC,YAAY,2BAA2B,MAAM;;;;;;;;;;;;;;;wBAqB7C,gBAAgB,OAAO,iBAAiB;;;;;;;wBA4BxC,cAAc,OAAO,cAAc;;;;;wBAQnC,4BACd,OAAO,cACP;;;;;;;;;;;wBAgBc,mBACd,WAAW,gCACX;EACG;EAAyB;;;;;;;;;wBAoBd,qBAAqB,6BAA6B,MAAM;;;;qBCvR3D;;qBAOA;;;;;;;wBASG,qBAAqB;;;;;;;;;;wBAarB,sBACd,iBAAiB,SACjB,UAAS,QAAQ,SAAS;;;;;;;;;;;;;;;;;;KCtChB;UAEK;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;EAOA;;;;EAIA;;;;;EAKA;;;EAGA;;EAEA;;EAEA;;EAEA;;qBAGW,gBAAgB,SAAS;;;;;;;qBAqBzB;;;;;;;wBAeG,gBAAgB,SAAQ,OAAO,aAA2B;;;;;;;wBAe1D,cAAc,YAAW,QAAQ,aAAkB;;;;;;;wBAmBnD,mBACd,+BACA,SAAQ;;;;cC9GJ;WACJ;WACA;WACA;WACA;;qBAEW,wBAAwB;;cAG/B;WACJ;WACA;WACA;WACA;WACA;WACA;WACA;;qBAEW,0BAA0B;cAGjC;WACJ;WACA;WACA;WACA;WACA;;qBAEW,sBAAsB;cAG7B;;WAEJ;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;qBAEW,uBAAuB;KACxB,uBAAuB,6BAA6B;;UAK/C;GACA,cAAA;;KAEL,kDAAkD,iBAAiB;UAE9D;EACf,MAAM;EACN;EACA;;;;;qBCvDW;;wBAwBG,UAAU;;;;;;;;;wBAgBV,aAAa;;;;;;wBA6Ib,iBAAiB,OAAO;;;;qBC7K3B;KASD,6BAA6B;qBAiB5B,gCAAgC;UAE5B;;EAEf,SAAS;;EAET;;EAEA;;EAEA;;UAGe;WACN;EACT,QAAQ,eAAe,SAAS,iBAAiB;;KAGvC,eAAe,oBAAoB;UAkC9B;;EAEf;;EAEA;;;;;;;;;wBAUc,sBAAsB,SAAS,+BAA+B;;;UCnF7D;;EAEf;EACA,SAAS;;EAET;;EAEA,UAAU;;EAEV;;EAEA;;EAEA,SAAS,QAAQ;;EAEjB,SAAS;;EAET;;;;;;;;UASe;EACf;EACA;;UAGe;;EAEf;;EAEA;;EAEA;;EAEA,QAAQ;;;;;;;;;EASR,SAAS;;EAET,QAAQ;;;;;;;;;wBAwBY,cAAc,SAAS,uBAAuB,QAAQ;;;wBCUpD,aAAa,IAAI"}