@parall/claude-agent 1.58.2 → 1.60.0

package/dist/input-lifecycle.js

@@ -1,4 +1,5 @@
 import { randomUUID } from 'node:crypto';
+import { newTurnEvidence, newTurnSink, } from './turn-sink.js';
 /**
  * Per-process registry that maps Parall WorkItem batches to Claude stdin
  * UUIDs. It owns lifecycle transition rules; process/stdout orchestration
@@ -28,17 +29,35 @@ export class ClaudeInputRegistry {
     hasPendingInjections() {
         return [...this.byKey.values()].some((delivery) => delivery.injected && !delivery.drained);
     }
-    register(deliveryKey, lifecycle, injected) {
+    /**
+     * Injected inputs whose lifecycle has NOT reached a terminal state. A
+     * terminal delivery still counts as pending (its buffered copy owes frame
+     * boundary bookkeeping) but owes the server nothing — the lane complete
+     * defers on this predicate, never on hasPendingInjections, so a bookkeeping
+     * copy that never drains cannot hold the lane open past its lease. Drained
+     * is deliberately NOT part of this predicate: a discarded bookkeeping copy
+     * (drained, non-terminal) is still a running input — completing its lane
+     * would release the member for redrive mid-processing.
+     */
+    hasUnsettledInjections() {
+        return [...this.byKey.values()].some((delivery) => delivery.injected && !delivery.terminal);
+    }
+    register(deliveryKey, lifecycle, injected, noteActivity, log) {
         if (this.byKey.has(deliveryKey)) {
             throw new Error(`duplicate Claude delivery key ${deliveryKey}`);
         }
+        const commandUuid = randomUUID();
         const delivery = {
             deliveryKey,
-            commandUuid: randomUUID(),
+            commandUuid,
             lifecycle,
             injected,
             drained: !injected,
             resultFailed: false,
+            sink: newTurnSink(`delivery ${deliveryKey}`, log),
+            evidence: newTurnEvidence(),
+            noteActivity,
+            sessionAnnounced: false,
         };
         this.byKey.set(deliveryKey, delivery);
         this.byCommand.set(delivery.commandUuid, delivery);
@@ -51,6 +70,26 @@ export class ClaudeInputRegistry {
         if (this.byCommand.get(delivery.commandUuid) === delivery) {
             this.byCommand.delete(delivery.commandUuid);
         }
+        // The sink stays open: apply() removes a drained delivery at its
+        // terminal BEFORE the pump pushes the terminal envelope its drain is
+        // waiting for. Only the pump closes sinks (process gone).
+    }
+    /**
+     * The buffered copy backing this delivery was discarded without a
+     * dispatch (already rendered into a frame the model saw), so the normal
+     * bookkeeping drain never comes. Its frame-boundary obligation is void:
+     * mark it drained so nothing waits on it, and drop it once terminal. A
+     * still-running input keeps its registration — byCommand must keep routing
+     * its lifecycle frames — and is dropped when its terminal state arrives
+     * (see apply/fail).
+     */
+    discardBookkeeping(deliveryKey) {
+        const delivery = this.byKey.get(deliveryKey);
+        if (!delivery)
+            return;
+        delivery.drained = true;
+        if (delivery.terminal)
+            this.remove(delivery);
     }
     async apply(delivery, state) {
         if (delivery.terminal || state === 'queued')
@@ -71,12 +110,19 @@ export class ClaudeInputRegistry {
             delivery.reportedState = 'completed';
         }
         delivery.terminal = 'completed';
+        // A discarded bookkeeping copy (drained without a dispatch) has no
+        // drain left to remove this entry — drop it at its terminal so it can
+        // never shadow a redelivered batch in findOverlapping.
+        if (delivery.drained)
+            this.remove(delivery);
     }
     async fail(delivery) {
         if (delivery.terminal)
             return;
         if (delivery.suppressFailReport) {
             delivery.terminal = 'settled';
+            if (delivery.drained)
+                this.remove(delivery);
             return;
         }
         try {
@@ -88,6 +134,8 @@ export class ClaudeInputRegistry {
         }
         finally {
             delivery.terminal ??= 'failed';
+            if (delivery.drained)
+                this.remove(delivery);
         }
     }
     async failBestEffort(delivery, log) {

package/dist/output-parser.d.ts

@@ -25,10 +25,38 @@ export type ClaudeResultMeta = {
     /** First model key of `modelUsage` — the model the CLI actually used. */
     model?: string;
 };
+/**
+ * The CLI's background-work frames (`system` subtypes). Every field is
+ * optional except the subtype.
+ * Observed on 2.1.227/2.1.258: `background_tasks_changed` (REPLACE
+ * semantics — every live task after the change), `task_started`,
+ * `task_progress`, `task_updated`, `task_notification` (a task finished or
+ * was stopped), `status`, `session_state_changed` (env-gated).
+ */
+export type ClaudeRuntimeTaskEvent = {
+    type: 'runtime_task';
+    subtype: 'background_tasks_changed' | 'task_started' | 'task_progress' | 'task_updated' | 'task_notification' | 'status' | 'session_state_changed';
+    taskId?: string;
+    toolUseId?: string;
+    description?: string;
+    taskType?: string;
+    status?: string;
+    summary?: string;
+    isBackgrounded?: boolean;
+    tasks?: Array<{
+        taskId: string;
+        taskType?: string;
+        description?: string;
+        ambient?: boolean;
+    }>;
+};
 export type ClaudeParsedEvent = RuntimeEvent | {
     type: 'runtime_init';
     sessionId?: string;
     capabilities: string[];
+} | ClaudeRuntimeTaskEvent | {
+    type: 'user_text';
+    text: string;
 } | {
     type: 'runtime_activity';
 } | {
@@ -38,6 +66,10 @@ export type ClaudeParsedEvent = RuntimeEvent | {
 } | {
     type: 'assistant_error';
     message: string;
+} | {
+    type: 'compact_boundary';
+    trigger?: string;
+    preTokens?: number;
 } | {
     type: 'turn_end';
     sessionId?: string;

package/dist/output-parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"output-parser.d.ts","sourceRoot":"","sources":["../src/output-parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,uEAAuE;IACvE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,yEAAyE;IACzE,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GACzB,YAAY,GACZ;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,EAAE,CAAA;CAAE,GAKpE;IAAE,IAAI,EAAE,kBAAkB,CAAA;CAAE,GAC5B;IACE,IAAI,EAAE,mBAAmB,CAAC;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,QAAQ,GAAG,SAAS,GAAG,WAAW,GAAG,WAAW,GAAG,WAAW,CAAC;CACvE,GAID;IAAE,IAAI,EAAE,iBAAiB,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAqB5C;IACE,IAAI,EAAE,UAAU,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,gBAAgB,CAAC;CAC/B,CAAC;AAgFN,wBAAuB,qBAAqB,CAC1C,QAAQ,EAAE,QAAQ,GACjB,cAAc,CAAC,iBAAiB,CAAC,CAkLnC"}
+{"version":3,"file":"output-parser.d.ts","sourceRoot":"","sources":["../src/output-parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,uEAAuE;IACvE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,yEAAyE;IACzE,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,IAAI,EAAE,cAAc,CAAC;IACrB,OAAO,EACH,0BAA0B,GAC1B,cAAc,GACd,eAAe,GACf,cAAc,GACd,mBAAmB,GACnB,QAAQ,GACR,uBAAuB,CAAC;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,KAAK,CAAC,EAAE,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;CAC/F,CAAC;AAYF,MAAM,MAAM,iBAAiB,GACzB,YAAY,GACZ;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,EAAE,CAAA;CAAE,GACpE,sBAAsB,GAItB;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAKnC;IAAE,IAAI,EAAE,kBAAkB,CAAA;CAAE,GAC5B;IACE,IAAI,EAAE,mBAAmB,CAAC;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,QAAQ,GAAG,SAAS,GAAG,WAAW,GAAG,WAAW,GAAG,WAAW,CAAC;CACvE,GAID;IAAE,IAAI,EAAE,iBAAiB,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAI5C;IAAE,IAAI,EAAE,kBAAkB,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GAqBlE;IACE,IAAI,EAAE,UAAU,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,gBAAgB,CAAC;CAC/B,CAAC;AAgFN,wBAAuB,qBAAqB,CAC1C,QAAQ,EAAE,QAAQ,GACjB,cAAc,CAAC,iBAAiB,CAAC,CA6NnC"}

package/dist/output-parser.js

@@ -1,3 +1,12 @@
+const RUNTIME_TASK_SUBTYPES = new Set([
+    'background_tasks_changed',
+    'task_started',
+    'task_progress',
+    'task_updated',
+    'task_notification',
+    'status',
+    'session_state_changed',
+]);
 function asTrimmedString(value) {
     if (typeof value !== 'string')
         return undefined;
@@ -91,20 +100,44 @@ export async function* parseClaudeStreamJson(readable) {
         const now = Date.now();
         const eventTimestampMs = parseEventTimestampMs(event) ?? now;
         const eventRecord = event;
-        if (eventRecord.type === 'system' && eventRecord.subtype === 'init') {
-            const sessionId = asTrimmedString(eventRecord.session_id);
-            const capabilities = Array.isArray(eventRecord.capabilities)
-                ? eventRecord.capabilities
-                    .map((capability) => asTrimmedString(capability))
-                    .filter((capability) => Boolean(capability))
-                : [];
+        if (eventRecord.type === 'system' && eventRecord.subtype === 'compact_boundary') {
+            const meta = eventRecord.compact_metadata && typeof eventRecord.compact_metadata === 'object'
+                ? eventRecord.compact_metadata
+                : undefined;
+            const trigger = asTrimmedString(meta?.trigger);
+            const preTokens = asFiniteNumber(meta?.pre_tokens);
             yield {
-                type: 'runtime_init',
-                ...(sessionId ? { sessionId } : {}),
-                capabilities,
+                type: 'compact_boundary',
+                ...(trigger ? { trigger } : {}),
+                ...(preTokens !== undefined ? { preTokens } : {}),
             };
             continue;
         }
+        if (eventRecord.type === 'system') {
+            if (eventRecord.subtype === 'init') {
+                const sessionId = asTrimmedString(eventRecord.session_id);
+                const capabilities = Array.isArray(eventRecord.capabilities)
+                    ? eventRecord.capabilities
+                        .map((capability) => asTrimmedString(capability))
+                        .filter((capability) => Boolean(capability))
+                    : [];
+                yield {
+                    type: 'runtime_init',
+                    ...(sessionId ? { sessionId } : {}),
+                    capabilities,
+                };
+                continue;
+            }
+            const subtype = asTrimmedString(eventRecord.subtype);
+            if (subtype && RUNTIME_TASK_SUBTYPES.has(subtype)) {
+                yield parseRuntimeTask(subtype, eventRecord);
+                continue;
+            }
+            // hook_started / hook_response / thinking_tokens /
+            // ...: valid CLI progress with no projection.
+            yield { type: 'runtime_activity' };
+            continue;
+        }
         if (eventRecord.type === 'command_lifecycle') {
             const commandUuid = asTrimmedString(eventRecord.command_uuid);
             const state = asTrimmedString(eventRecord.state);
@@ -190,8 +223,20 @@ export async function* parseClaudeStreamJson(readable) {
             const content = message && typeof message === 'object'
                 ? message.content
                 : undefined;
+            if (typeof content === 'string') {
+                const text = content.trim();
+                if (text)
+                    yield { type: 'user_text', text };
+                continue;
+            }
             if (!Array.isArray(content))
                 continue;
+            if (!content.some((block) => block?.type === 'tool_result')) {
+                const text = stringifyContent(content).trim();
+                if (text)
+                    yield { type: 'user_text', text };
+                continue;
+            }
             for (const block of content) {
                 if (!block || typeof block !== 'object')
                     continue;
@@ -239,8 +284,59 @@ export async function* parseClaudeStreamJson(readable) {
                 ...(numTurns !== undefined ? { numTurns } : {}),
                 resultMeta: extractResultMeta(eventRecord, isError, numTurns),
             };
+            continue;
+        }
+        // Any other well-formed frame (rate_limit_event, stream_event, ...) is
+        // CLI progress: refresh activity, never project.
+        yield { type: 'runtime_activity' };
+    }
+}
+function parseRuntimeTask(subtype, frame) {
+    const event = { type: 'runtime_task', subtype };
+    const taskId = asTrimmedString(frame.task_id);
+    if (taskId)
+        event.taskId = taskId;
+    const toolUseId = asTrimmedString(frame.tool_use_id);
+    if (toolUseId)
+        event.toolUseId = toolUseId;
+    const description = asTrimmedString(frame.description);
+    if (description)
+        event.description = description;
+    const taskType = asTrimmedString(frame.task_type);
+    if (taskType)
+        event.taskType = taskType;
+    const status = asTrimmedString(frame.status) ??
+        asTrimmedString(frame.patch?.status) ??
+        asTrimmedString(frame.state);
+    if (status)
+        event.status = status;
+    const summary = asTrimmedString(frame.summary);
+    if (summary)
+        event.summary = summary;
+    if (typeof frame.is_backgrounded === 'boolean')
+        event.isBackgrounded = frame.is_backgrounded;
+    if (Array.isArray(frame.tasks)) {
+        event.tasks = [];
+        for (const task of frame.tasks) {
+            if (!task || typeof task !== 'object')
+                continue;
+            const record = task;
+            const id = asTrimmedString(record.task_id);
+            if (!id)
+                continue;
+            const entry = { taskId: id };
+            const entryType = asTrimmedString(record.task_type);
+            if (entryType)
+                entry.taskType = entryType;
+            const entryDescription = asTrimmedString(record.description);
+            if (entryDescription)
+                entry.description = entryDescription;
+            if (record.ambient === true)
+                entry.ambient = true;
+            event.tasks.push(entry);
         }
     }
+    return event;
 }
 /** Snapshot the result frame's discriminator + usage fields (all optional). */
 function extractResultMeta(frame, isError, numTurns) {

package/dist/process-pump.d.ts

@@ -0,0 +1,105 @@
+import { type GatewayLogger, type RuntimeBusyState } from '@parall/agent-core';
+import { ClaudeBusyTracker } from './busy-state.js';
+import type { ClaudeInputDelivery, ClaudeInputRegistry } from './input-lifecycle.js';
+import type { ClaudeParsedEvent } from './output-parser.js';
+import { ClaudeRuntimeTurn } from './runtime-turn.js';
+import type { ClaudeProcessHandle } from './session-manager.js';
+import type { ClaudeTurnEndReason } from './turn-sink.js';
+export type ClaudeProcessPumpHooks = {
+    /** system.init: capabilities + session id. Return a message to fail the process. */
+    onRuntimeInit(init: {
+        sessionId?: string;
+        capabilities: string[];
+    }): string | undefined;
+    /** Unrecoverable protocol state: the adapter kills the process. */
+    onFatal(): void;
+    /** stdout reached EOF (process gone). */
+    onEof(): void;
+    onRuntimeTurnOpened(turn: ClaudeRuntimeTurn): void;
+    onRuntimeTurnClosed(): void;
+};
+export type ClaudeProcessPumpOptions = {
+    sessionKey: string;
+    parser: AsyncGenerator<ClaudeParsedEvent>;
+    handle: ClaudeProcessHandle;
+    inputs: ClaudeInputRegistry;
+    hooks: ClaudeProcessPumpHooks;
+    log?: GatewayLogger;
+    followUpHoldMs?: number;
+    now?: () => number;
+};
+/**
+ * Single owner of one Claude subprocess's stdout. Reads every frame the CLI
+ * emits — during dispatches AND between them — and routes it:
+ *
+ * - `command_lifecycle` frames go to the delivery they name (stdin uuid).
+ * - Content frames (thinking / text / tool_call / tool_result / error) go to
+ *   the delivery whose lifecycle is `started` and not yet terminal
+ *   (claude-soft-steer-design.md: the lifecycle terminal, not `result`,
+ *   bounds a delivery); with no started delivery they go to the open
+ *   runtime-initiated turn, opening one if needed. A `queued` delivery never
+ *   owns frames.
+ * - `result` frames attach turn-outcome evidence to the owner and close a
+ *   runtime-initiated turn; a poison `num_turns: 0` resume artifact never
+ *   opens or closes one.
+ * - task frames feed the busy ledger; `runtime_activity` only refreshes
+ *   inactivity deadlines.
+ *
+ * Reading continuously also removes the latent stall where an unread
+ * self-started turn filled the OS pipe and blocked the CLI.
+ */
+export declare class ClaudeProcessPump {
+    private readonly opts;
+    readonly busy: ClaudeBusyTracker;
+    capabilities: Set<string>;
+    sessionId: string | undefined;
+    runtimeTurn: ClaudeRuntimeTurn | null;
+    private closed;
+    private idleWaiters;
+    private idleTimer;
+    private activeDrain;
+    private readonly now;
+    constructor(opts: ClaudeProcessPumpOptions);
+    start(): void;
+    /** The dispatch generator currently draining `delivery` (owner preference). */
+    setActiveDrain(delivery: ClaudeInputDelivery, noteActivity?: () => void): void;
+    clearActiveDrain(delivery: ClaudeInputDelivery): void;
+    hasStartedDelivery(): boolean;
+    /**
+     * The CLI has (or is about to start) work no dispatch asked for: a
+     * runtime-initiated turn is open, or a finished background task's
+     * follow-up hold is pending. Lazy restarts, dispatch aborts and
+     * `whenIdle` all defer to it.
+     */
+    hasOwnWork(now?: number): boolean;
+    busyState(now?: number): RuntimeBusyState;
+    /** Dispatch abort: fail every live delivery and release its drain. */
+    abortDeliveries(message: string): void;
+    /**
+     * The adapter is terminating the process (kill / reset / shutdown): every
+     * drain and the open runtime turn end now, before stdout EOF is observed.
+     */
+    close(reason: ClaudeTurnEndReason, message: string): void;
+    /**
+     * Run `cb` once the CLI has nothing left to do on its own: no
+     * runtime-initiated turn open and no follow-up hold pending (a hold that
+     * turns into a follow-up turn is waited for as well). Immediate when
+     * already idle or closed.
+     */
+    whenIdle(cb: () => void): void;
+    private checkIdle;
+    closeRuntimeTurn(reason: ClaudeTurnEndReason, message?: string): void;
+    private run;
+    private route;
+    private touchAll;
+    private liveDeliveries;
+    private ownerFor;
+    private openRuntimeTurn;
+    private handleInit;
+    private handleLifecycle;
+    private handleTask;
+    private handleTurnEnd;
+    private pushErrorToDeliveries;
+    private handleEof;
+}
+//# sourceMappingURL=process-pump.d.ts.map

package/dist/process-pump.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-pump.d.ts","sourceRoot":"","sources":["../src/process-pump.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,aAAa,EAClB,KAAK,gBAAgB,EAEtB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,KAAK,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AACrF,OAAO,KAAK,EAAE,iBAAiB,EAA0B,MAAM,oBAAoB,CAAC;AACpF,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAEhE,OAAO,KAAK,EAAE,mBAAmB,EAAgC,MAAM,gBAAgB,CAAC;AAKxF,MAAM,MAAM,sBAAsB,GAAG;IACnC,oFAAoF;IACpF,aAAa,CAAC,IAAI,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,EAAE,CAAA;KAAE,GAAG,MAAM,GAAG,SAAS,CAAC;IACxF,mEAAmE;IACnE,OAAO,IAAI,IAAI,CAAC;IAChB,yCAAyC;IACzC,KAAK,IAAI,IAAI,CAAC;IACd,mBAAmB,CAAC,IAAI,EAAE,iBAAiB,GAAG,IAAI,CAAC;IACnD,mBAAmB,IAAI,IAAI,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,cAAc,CAAC,iBAAiB,CAAC,CAAC;IAC1C,MAAM,EAAE,mBAAmB,CAAC;IAC5B,MAAM,EAAE,mBAAmB,CAAC;IAC5B,KAAK,EAAE,sBAAsB,CAAC;IAC9B,GAAG,CAAC,EAAE,aAAa,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,iBAAiB;IAWhB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAVjC,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IACjC,YAAY,cAAyC;IACrD,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,WAAW,EAAE,iBAAiB,GAAG,IAAI,CAAQ;IAC7C,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,WAAW,CAAyB;IAC5C,OAAO,CAAC,SAAS,CAA+B;IAChD,OAAO,CAAC,WAAW,CAAoC;IACvD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAe;gBAEN,IAAI,EAAE,wBAAwB;IAK3D,KAAK,IAAI,IAAI;IAIb,+EAA+E;IAC/E,cAAc,CAAC,QAAQ,EAAE,mBAAmB,EAAE,YAAY,CAAC,EAAE,MAAM,IAAI,GAAG,IAAI;IAK9E,gBAAgB,CAAC,QAAQ,EAAE,mBAAmB,GAAG,IAAI;IAIrD,kBAAkB,IAAI,OAAO;IAK7B;;;;;OAKG;IACH,UAAU,CAAC,GAAG,SAAa,GAAG,OAAO;IAIrC,SAAS,CAAC,GAAG,SAAa,GAAG,gBAAgB;IAU7C,sEAAsE;IACtE,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAQtC;;;OAGG;IACH,KAAK,CAAC,MAAM,EAAE,mBAAmB,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAYzD;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,IAAI;IAK9B,OAAO,CAAC,SAAS;IA0BjB,gBAAgB,CAAC,MAAM,EAAE,mBAAmB,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI;YAevD,GAAG;YAeH,KAAK;IAkDnB,OAAO,CAAC,QAAQ;IAOhB,OAAO,CAAC,cAAc;IAMtB,OAAO,CAAC,QAAQ;IAOhB,OAAO,CAAC,eAAe;IAkCvB,OAAO,CAAC,UAAU;YAsBJ,eAAe;IA2C7B,OAAO,CAAC,UAAU;YA6BJ,aAAa;IA8C3B,OAAO,CAAC,qBAAqB;YAOf,SAAS;CAuBxB"}