@borgee/agents-host 0.2.84 → 0.2.94

package/dist/vendor/claude-agent-acp/dist/borgee-foreground-handoff-bridge.js

@@ -0,0 +1,322 @@
+export const CLAUDE_FOREGROUND_HANDOFF_METHOD = '_borgee/session/foreground_handoff';
+export const CLAUDE_FOREGROUND_LIFECYCLE_EVENT = 'settled_with_background';
+
+const AUTONOMOUS_ORIGIN_KINDS = new Set([
+  'task-notification',
+  'peer',
+  'coordinator',
+  'observer',
+  'observer-activity',
+]);
+
+function isPositiveSafeInteger(value) {
+  return Number.isSafeInteger(value) && value > 0;
+}
+
+function activeForegroundTurn(session) {
+  const owner = session?.activeTurn?.borgeeForegroundTurn;
+  return isPositiveSafeInteger(owner) ? owner : undefined;
+}
+
+function ensureOwnershipMaps(session) {
+  session.borgeeForegroundTurns ??= new Map();
+  session.borgeeTaskOwners ??= new Map();
+  session.borgeeToolOwners ??= new Map();
+}
+
+function ownerForPromptUuid(session, uuid) {
+  if (typeof uuid !== 'string') {
+    return undefined;
+  }
+  return session.borgeeForegroundTurns?.get(uuid);
+}
+
+function ownerForTool(session, toolUseId) {
+  if (typeof toolUseId !== 'string') {
+    return undefined;
+  }
+  return session.borgeeToolOwners?.get(toolUseId);
+}
+
+function ownerForTask(session, taskId) {
+  if (typeof taskId !== 'string') {
+    return undefined;
+  }
+  return session.borgeeTaskOwners?.get(taskId);
+}
+
+export function registerClaudeForegroundTurn(session, turn) {
+  ensureOwnershipMaps(session);
+  const next = isPositiveSafeInteger(session.borgeeNextForegroundTurn)
+    ? session.borgeeNextForegroundTurn + 1
+    : 1;
+  session.borgeeNextForegroundTurn = next;
+  turn.borgeeForegroundTurn = next;
+  session.borgeeForegroundTurns.set(turn.promptUuid, next);
+  return next;
+}
+
+export function parseClaudeForegroundHandoffRequest(value) {
+  if (
+    typeof value !== 'object'
+    || value === null
+    || Array.isArray(value)
+    || typeof value.sessionId !== 'string'
+    || value.sessionId.length === 0
+  ) {
+    throw new Error('foreground handoff requires a non-empty sessionId');
+  }
+  return { sessionId: value.sessionId };
+}
+
+export function admitClaudeForegroundHandoff(session) {
+  if (!session || session.queryClosed) {
+    return { outcome: 'not_found' };
+  }
+  const turn = session.activeTurn
+    ?? session.turnQueue?.find((candidate) => !candidate.settled);
+  if (!turn || turn.settled) {
+    return { outcome: 'not_found' };
+  }
+  const foregroundTurn = isPositiveSafeInteger(turn.borgeeForegroundTurn)
+    ? turn.borgeeForegroundTurn
+    : registerClaudeForegroundTurn(session, turn);
+  turn.borgeeForegroundHandoffRequested = true;
+  const released = turn.borgeeReleaseDeferredForeground?.() === true;
+  return {
+    outcome: released ? 'released' : 'admitted',
+    foregroundTurn,
+  };
+}
+
+export function shouldDeferClaudeForegroundTurn(turn) {
+  return turn?.borgeeForegroundHandoffRequested !== true;
+}
+
+export function bindClaudeDeferredForegroundRelease(turn, release) {
+  turn.borgeeReleaseDeferredForeground = release;
+}
+
+export function emitClaudeForegroundLifecycle(client, sessionId, turn, event = CLAUDE_FOREGROUND_LIFECYCLE_EVENT) {
+  const foregroundTurn = isPositiveSafeInteger(turn?.borgeeForegroundTurn)
+    ? turn.borgeeForegroundTurn
+    : undefined;
+  return client.sessionUpdate({
+    sessionId,
+    update: {
+      sessionUpdate: 'session_info_update',
+      _meta: {
+        claudeCode: {
+          foregroundLifecycle: {
+            event,
+            ...(foregroundTurn ? { foregroundTurn } : {}),
+          },
+        },
+      },
+    },
+  });
+}
+
+export function noteClaudeUpdateOwnership(session, message) {
+  ensureOwnershipMaps(session);
+  const messageUuids = [
+    ...(message?.type === 'user' && typeof message.uuid === 'string'
+      ? [message.uuid]
+      : []),
+    ...(typeof message?.user_message_uuid === 'string'
+      ? [message.user_message_uuid]
+      : []),
+    ...(Array.isArray(message?.user_message_uuids)
+      ? message.user_message_uuids.filter((value) => typeof value === 'string')
+      : []),
+  ];
+  let owner = messageUuids
+    .map((uuid) => ownerForPromptUuid(session, uuid))
+    .find(isPositiveSafeInteger);
+  owner ??= ownerForTool(session, message?.parent_tool_use_id);
+
+  const subtype = message?.type === 'system' ? message.subtype : undefined;
+  if (subtype === 'task_started') {
+    owner ??= ownerForTool(session, message.tool_use_id);
+    owner ??= activeForegroundTurn(session);
+    owner ??= session.borgeeUpdateOwner;
+    if (isPositiveSafeInteger(owner)) {
+      session.borgeeTaskOwners.set(message.task_id, owner);
+      if (typeof message.tool_use_id === 'string') {
+        session.borgeeToolOwners.set(message.tool_use_id, owner);
+      }
+    }
+  } else if (subtype === 'task_notification' || subtype === 'task_updated') {
+    owner ??= ownerForTask(session, message.task_id);
+    if (subtype === 'task_notification' && isPositiveSafeInteger(owner)) {
+      session.borgeeAutonomousOwner = owner;
+    }
+  }
+
+  const originKind = message?.origin?.kind;
+  owner ??= ownerForTask(session, message?.origin?.senderTaskId);
+  if (originKind === 'task-notification') {
+    owner ??= session.borgeeAutonomousOwner;
+  }
+  if (messageUuids.length > 0 || AUTONOMOUS_ORIGIN_KINDS.has(originKind)) {
+    owner ??= session.borgeeAutonomousOwner;
+    owner ??= session.borgeeUpdateOwner;
+    owner ??= activeForegroundTurn(session);
+  } else {
+    owner ??= session.borgeeUpdateOwner;
+    owner ??= activeForegroundTurn(session);
+  }
+  if (isPositiveSafeInteger(owner)) {
+    session.borgeeUpdateOwner = owner;
+  }
+
+  const activeOwner = activeForegroundTurn(session);
+  if (messageUuids.length > 0) {
+    session.borgeeForegroundLane = owner === activeOwner ? 'foreground' : 'background';
+    if (owner === activeOwner) {
+      session.borgeeAutonomousOwner = undefined;
+    }
+    return;
+  }
+  if (typeof originKind === 'string' && AUTONOMOUS_ORIGIN_KINDS.has(originKind)) {
+    session.borgeeForegroundLane = 'background';
+    return;
+  }
+  if (
+    typeof message?.parent_tool_use_id === 'string'
+    || (isPositiveSafeInteger(owner) && isPositiveSafeInteger(activeOwner) && owner !== activeOwner)
+  ) {
+    session.borgeeForegroundLane = 'background';
+    return;
+  }
+  if (message?.type === 'user') {
+    session.borgeeForegroundLane =
+      originKind === undefined || originKind === 'human' || originKind === 'channel'
+        ? 'foreground'
+        : 'background';
+  }
+}
+
+function ownerForNotification(session, notification, ownerHint) {
+  if (isPositiveSafeInteger(ownerHint)) {
+    return ownerHint;
+  }
+  const update = notification?.update;
+  const provider = update?._meta?.claudeCode;
+  const explicitOwner = provider?.foregroundTurn;
+  if (isPositiveSafeInteger(explicitOwner)) {
+    return explicitOwner;
+  }
+  const taskId = provider?.taskLifecycle?.taskId;
+  return ownerForTool(session, update?.toolCallId)
+    ?? ownerForTool(session, provider?.parentToolUseId)
+    ?? ownerForTask(session, taskId)
+    ?? session?.borgeeUpdateOwner
+    ?? activeForegroundTurn(session);
+}
+
+export function stampClaudeUpdateOwnership(session, notification, ownerHint) {
+  if (!session) {
+    return notification;
+  }
+  ensureOwnershipMaps(session);
+  const owner = ownerForNotification(session, notification, ownerHint);
+  const lane = session.borgeeForegroundLane;
+  if (isPositiveSafeInteger(owner) && typeof notification?.update?.toolCallId === 'string') {
+    session.borgeeToolOwners.set(notification.update.toolCallId, owner);
+  }
+  if (
+    !isPositiveSafeInteger(owner)
+    && lane !== 'foreground'
+    && lane !== 'background'
+  ) {
+    return notification;
+  }
+  const activeOwner = activeForegroundTurn(session);
+  const resolvedLane =
+    isPositiveSafeInteger(owner)
+    && isPositiveSafeInteger(activeOwner)
+    && owner !== activeOwner
+      ? 'background'
+      : lane;
+  return {
+    ...notification,
+    update: {
+      ...notification.update,
+      _meta: {
+        ...notification.update._meta,
+        claudeCode: {
+          ...notification.update._meta?.claudeCode,
+          ...(resolvedLane === 'foreground' || resolvedLane === 'background'
+            ? { foregroundLane: resolvedLane }
+            : {}),
+          ...(isPositiveSafeInteger(owner) ? { foregroundTurn: owner } : {}),
+        },
+      },
+    },
+  };
+}
+
+export function noteClaudePermissionOwnership(session, toolUseId, agentId) {
+  if (!session || typeof toolUseId !== 'string') {
+    return;
+  }
+  ensureOwnershipMaps(session);
+  const owner = ownerForTool(session, toolUseId)
+    ?? ownerForTask(session, agentId)
+    ?? activeForegroundTurn(session)
+    ?? session.borgeeUpdateOwner;
+  if (isPositiveSafeInteger(owner)) {
+    session.borgeeToolOwners.set(toolUseId, owner);
+  }
+}
+
+export function stampClaudePermissionOwnership(session, params) {
+  if (!session || typeof params?.toolCall?.toolCallId !== 'string') {
+    return params;
+  }
+  ensureOwnershipMaps(session);
+  const provider = params.toolCall._meta?.claudeCode;
+  const owner = ownerForTool(session, params.toolCall.toolCallId)
+    ?? ownerForTool(session, provider?.parentToolUseId)
+    ?? activeForegroundTurn(session)
+    ?? session.borgeeUpdateOwner;
+  if (!isPositiveSafeInteger(owner)) {
+    return params;
+  }
+  return {
+    ...params,
+    toolCall: {
+      ...params.toolCall,
+      _meta: {
+        ...params.toolCall._meta,
+        claudeCode: {
+          ...provider,
+          foregroundTurn: owner,
+        },
+      },
+    },
+  };
+}
+
+export function sendClaudeHookUpdate(client, session, hookInput, notification) {
+  const owner = ownerForTask(session, hookInput?.agent_id)
+    ?? ownerForPromptUuid(session, hookInput?.prompt_id)
+    ?? session?.borgeeUpdateOwner
+    ?? activeForegroundTurn(session);
+  return client.sessionUpdate(stampClaudeUpdateOwnership(session, notification, owner));
+}
+
+const wrappedClients = new WeakSet();
+
+export function bindClaudeSessionUpdateOwnership(client, resolveSession) {
+  if (wrappedClients.has(client)) {
+    return client;
+  }
+  const sessionUpdate = client.sessionUpdate.bind(client);
+  client.sessionUpdate = (notification) => sessionUpdate(
+    stampClaudeUpdateOwnership(resolveSession(notification?.sessionId), notification),
+  );
+  wrappedClients.add(client);
+  return client;
+}

package/dist/vendor/claude-agent-acp/dist/borgee-task-cancellation-bridge.js

@@ -0,0 +1,101 @@
+export const CLAUDE_TASK_CANCELLATION_METHOD = '_borgee/claude/task/cancel/v1';
+export const CLAUDE_TASK_CANCELLATION_VERSION = 1;
+export const CLAUDE_TASK_CANCELLATION_CAPABILITY = Object.freeze({
+  method: CLAUDE_TASK_CANCELLATION_METHOD,
+  version: CLAUDE_TASK_CANCELLATION_VERSION,
+});
+
+const taskStates = new WeakMap();
+
+function stateFor(session) {
+  let state = taskStates.get(session);
+  if (!state) {
+    state = {
+      backgroundTaskIds: new Set(),
+      stopRequests: new Map(),
+    };
+    taskStates.set(session, state);
+  }
+  return state;
+}
+
+function removeTask(state, taskId) {
+  state.backgroundTaskIds.delete(taskId);
+  state.stopRequests.delete(taskId);
+}
+
+export function trackClaudeTaskLifecycle(session, message) {
+  const state = stateFor(session);
+  switch (message.subtype) {
+    case 'background_tasks_changed': {
+      const taskIds = new Set(message.tasks.map((task) => task.task_id));
+      state.backgroundTaskIds = taskIds;
+      for (const taskId of state.stopRequests.keys()) {
+        if (!taskIds.has(taskId)) {
+          state.stopRequests.delete(taskId);
+        }
+      }
+      break;
+    }
+    case 'task_updated':
+      if (
+        message.patch.status === 'completed'
+        || message.patch.status === 'failed'
+        || message.patch.status === 'killed'
+        || message.patch.is_backgrounded === false
+      ) {
+        removeTask(state, message.task_id);
+      } else if (message.patch.is_backgrounded === true) {
+        state.backgroundTaskIds.add(message.task_id);
+      }
+      break;
+    case 'task_notification':
+      removeTask(state, message.task_id);
+      break;
+  }
+}
+
+export function parseClaudeTaskCancellationRequest(params) {
+  if (!params || typeof params !== 'object') {
+    throw new TypeError('Claude task cancellation params must be an object');
+  }
+  const { sessionId, taskId } = params;
+  if (typeof sessionId !== 'string' || sessionId.length === 0) {
+    throw new TypeError('Claude task cancellation requires a non-empty sessionId');
+  }
+  if (typeof taskId !== 'string' || taskId.length === 0) {
+    throw new TypeError('Claude task cancellation requires a non-empty taskId');
+  }
+  return { sessionId, taskId };
+}
+
+export async function stopClaudeBackgroundTask(session, taskId) {
+  if (!session || session.queryClosed) {
+    return { outcome: 'not_found' };
+  }
+  const state = stateFor(session);
+  if (!state.backgroundTaskIds.has(taskId)) {
+    return { outcome: 'not_found' };
+  }
+  if (typeof session.query?.stopTask !== 'function') {
+    return { outcome: 'unsupported' };
+  }
+
+  const existing = state.stopRequests.get(taskId);
+  if (existing) {
+    return existing;
+  }
+  const request = (async () => {
+    await session.query.stopTask(taskId);
+    return { outcome: 'accepted' };
+  })();
+  state.stopRequests.set(taskId, request);
+  try {
+    return await request;
+  } catch (error) {
+    if (state.stopRequests.get(taskId) === request) {
+      state.stopRequests.delete(taskId);
+    }
+    throw error;
+  }
+}

package/dist/vendor/claude-agent-acp/dist/borgee-task-lifecycle-bridge.js

@@ -0,0 +1,58 @@
+function lifecycleForMessage(message) {
+  switch (message.subtype) {
+    case 'task_started':
+      return {
+        event: 'started',
+        taskId: message.task_id,
+        ...(message.tool_use_id ? { toolUseId: message.tool_use_id } : {}),
+        description: message.description,
+        ...(message.subagent_type ? { subagentType: message.subagent_type } : {}),
+        ...(message.task_type ? { taskType: message.task_type } : {}),
+      };
+    case 'task_notification':
+      return {
+        event: 'notification',
+        taskId: message.task_id,
+        ...(message.tool_use_id ? { toolUseId: message.tool_use_id } : {}),
+        status: message.status,
+        summary: message.summary,
+        ...(message.usage ? { usage: message.usage } : {}),
+      };
+    case 'task_updated':
+      return {
+        event: 'updated',
+        taskId: message.task_id,
+        patch: message.patch,
+      };
+    case 'background_tasks_changed':
+      return {
+        event: 'background_tasks_changed',
+        tasks: message.tasks.map((task) => ({
+          taskId: task.task_id,
+          taskType: task.task_type,
+          description: task.description,
+        })),
+      };
+    default:
+      return undefined;
+  }
+}
+
+export async function emitClaudeTaskLifecycle(sendUpdate, sessionId, message) {
+  const taskLifecycle = lifecycleForMessage(message);
+  if (!taskLifecycle) {
+    return false;
+  }
+  await sendUpdate({
+    sessionId,
+    update: {
+      sessionUpdate: 'session_info_update',
+      _meta: {
+        claudeCode: {
+          taskLifecycle,
+        },
+      },
+    },
+  });
+  return true;
+}

package/dist/vendor/claude-agent-acp/dist/elicitation.d.ts

@@ -0,0 +1,130 @@
+import { CreateElicitationResponse } from "@agentclientprotocol/sdk";
+import type { CreateElicitationRequest } from "@agentclientprotocol/sdk";
+import type { ElicitationRequest, ElicitationResult } from "@anthropic-ai/claude-agent-sdk";
+import type { AskUserQuestionInput } from "@anthropic-ai/claude-agent-sdk/sdk-tools.js";
+/**
+ * Bridges between the Claude Agent SDK's elicitation/dialog callbacks and ACP's
+ * (unstable) elicitation protocol.
+ *
+ * Two distinct SDK surfaces flow through here:
+ *
+ *   1. `onElicitation` — fired when an MCP server requests user input. These map
+ *      directly onto ACP `session/create_elicitation` (form or url mode).
+ *   2. The built-in AskUserQuestion tool — when a `canUseTool` callback is
+ *      registered the SDK routes its permission check through `canUseTool`
+ *      (not the interactive `permission_ask_user_question` dialog). We render
+ *      its questions as an ACP form elicitation and feed the user's selections
+ *      back as the tool's `updatedInput`, which the tool's own `call()` reads.
+ */
+/** Modes the connected client advertised support for. */
+export type ElicitationSupport = {
+    form: boolean;
+    url: boolean;
+};
+/**
+ * Convert an MCP elicitation request (from the SDK's `onElicitation` callback)
+ * into an ACP `CreateElicitationRequest`. Returns `null` when the request can't
+ * be represented (e.g. a url-mode request with no url).
+ */
+export declare function mcpElicitationToCreateRequest(request: ElicitationRequest, sessionId: string): CreateElicitationRequest | null;
+/**
+ * Map an ACP elicitation response back to the MCP `ElicitResult` the SDK expects
+ * to hand back to the requesting server.
+ */
+export declare function createElicitationResponseToElicitResult(response: CreateElicitationResponse): ElicitationResult;
+/**
+ * A single question as supplied by the AskUserQuestion tool. Derived from the
+ * SDK's input type so the shape stays in sync; the SDK validates the model's
+ * tool call against this schema before it reaches us.
+ */
+export type AskUserQuestion = AskUserQuestionInput["questions"][number];
+/**
+ * Pull the well-formed questions out of an AskUserQuestion tool input. Returns
+ * `null` when there are no usable questions — including the case where every
+ * entry is malformed and filtering leaves an empty list — so callers can treat
+ * "nothing to ask" uniformly.
+ */
+export declare function extractAskUserQuestions(input: Record<string, unknown>): AskUserQuestion[] | null;
+/**
+ * Render the AskUserQuestion tool's questions as an ACP form elicitation.
+ *
+ * Fields are keyed by a short stable id (`question_<n>`) rather than the full
+ * question text, so the question text appears in exactly one place per field.
+ * Single-select questions use a titled `oneOf` enum; multi-select questions use
+ * an array with a titled `anyOf` item enum. The enum `const` is always the
+ * option label, since that is what the tool records as the answer; an option's
+ * secondary text travels in the enum option's own `description` field.
+ *
+ * Each question is followed by its own optional free-text "custom answer" field
+ * (`question_<n>_custom`), mirroring the CLI's per-question "Other" box: the
+ * user can type their own answer instead of picking an option, scoped to that
+ * specific question. Nothing is marked required, so the user can also just skip
+ * — matching the built-in tool, which always offers Skip + a free-text box.
+ */
+export declare function askUserQuestionsToCreateRequest(questions: AskUserQuestion[], sessionId: string, toolCallId: string | undefined): CreateElicitationRequest;
+/** Outcome of an AskUserQuestion elicitation, decoupled from any transport. */
+export type AskUserQuestionOutcome = {
+    action: "answered";
+    updatedInput: Record<string, unknown>;
+} | {
+    action: "cancel";
+};
+/**
+ * Fold an ACP elicitation response into the AskUserQuestion tool's input.
+ *
+ * Selected labels are read back from the indexed form fields and written into
+ * `answers` as a `{ [questionText]: label }` map (comma-joining multi-selects)
+ * — the key shape the tool's own `call()` reads. A non-empty per-question
+ * custom-answer field (`question_<n>_custom`) takes precedence over that
+ * question's selection, since the user typed their own answer instead of
+ * picking one. Decline yields empty answers (the model is told the user skipped
+ * rather than the turn aborting); cancel — and any custom/future action we
+ * don't understand — aborts the tool call.
+ */
+export declare function applyAskElicitationResponse(response: CreateElicitationResponse, toolInput: Record<string, unknown>, questions: AskUserQuestion[]): AskUserQuestionOutcome;
+/**
+ * The `request_user_dialog` kind the CLI emits when a model refusal has a
+ * fallback available but needs user consent before retrying (e.g. Claude Fable
+ * declining a request with Opus available as the fallback). Declaring this
+ * kind in `supportedDialogKinds` is the opt-in: the CLI fails closed and never
+ * emits an undeclared kind — the flow degrades to the classic refusal error
+ * ending the turn.
+ */
+export declare const REFUSAL_FALLBACK_DIALOG_KIND = "refusal_fallback_prompt";
+/**
+ * Payload of the `refusal_fallback_prompt` dialog. The dialog protocol
+ * transports payloads opaquely, so this shape is recovered from the CLI's own
+ * schema (v2.1.177): `originalModel`/`fallbackModel` are required strings;
+ * `apiRefusalCategory` (nullable), `guidanceText`, and
+ * `retractedMessageUuids` are optional. We ignore `retractedMessageUuids` —
+ * ACP has no way to retract already-streamed chunks.
+ */
+export type RefusalFallbackPrompt = {
+    originalModel: string;
+    fallbackModel: string;
+    apiRefusalCategory: string | null;
+    guidanceText?: string;
+};
+/**
+ * Validate the opaque dialog payload into a {@link RefusalFallbackPrompt}.
+ * Returns `null` when the required fields are missing or mistyped (a newer CLI
+ * may reshape the payload), so the caller can cancel the dialog and let the
+ * CLI apply its default behavior instead of rendering something misleading.
+ */
+export declare function extractRefusalFallbackPrompt(payload: Record<string, unknown>): RefusalFallbackPrompt | null;
+/**
+ * Render the refusal-fallback consent prompt as an ACP form elicitation: a
+ * single-select between retrying on the fallback model and keeping the
+ * refusal. The enum `const`s are the dialog's wire result values, so the
+ * response maps back without a translation table.
+ */
+export declare function refusalFallbackToCreateRequest(prompt: RefusalFallbackPrompt, sessionId: string): CreateElicitationRequest;
+/**
+ * Map the elicitation response back to the dialog's result enum. Only an
+ * explicit accept-with-retry resolves to `retry_fallback`; decline, cancel, a
+ * skipped field, or an unrecognized value all keep the refusal — the dialog's
+ * own default — so a dismissed or half-filled form can never trigger a model
+ * switch the user didn't ask for.
+ */
+export declare function refusalFallbackResultFromResponse(response: CreateElicitationResponse): string;
+//# sourceMappingURL=elicitation.d.ts.map

package/dist/vendor/claude-agent-acp/dist/elicitation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elicitation.d.ts","sourceRoot":"","sources":["../src/elicitation.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,yBAAyB,EAAE,MAAM,0BAA0B,CAAC;AACrE,OAAO,KAAK,EACV,wBAAwB,EAKzB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AAC5F,OAAO,KAAK,EACV,oBAAoB,EAErB,MAAM,6CAA6C,CAAC;AAErD;;;;;;;;;;;;;GAaG;AAEH,yDAAyD;AACzD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,OAAO,CAAC;IACd,GAAG,EAAE,OAAO,CAAC;CACd,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,kBAAkB,EAC3B,SAAS,EAAE,MAAM,GAChB,wBAAwB,GAAG,IAAI,CAyBjC;AAgBD;;;GAGG;AACH,wBAAgB,uCAAuC,CACrD,QAAQ,EAAE,yBAAyB,GAClC,iBAAiB,CAUnB;AAED;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG,oBAAoB,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAExE;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,eAAe,EAAE,GAAG,IAAI,CAUhG;AAgCD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,+BAA+B,CAC7C,SAAS,EAAE,eAAe,EAAE,EAC5B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,GAAG,SAAS,GAC7B,wBAAwB,CA2D1B;AAED,+EAA+E;AAC/E,MAAM,MAAM,sBAAsB,GAChC;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,QAAQ,CAAA;CAAE,CAAC;AAEvF;;;;;;;;;;;GAWG;AACH,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,yBAAyB,EACnC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClC,SAAS,EAAE,eAAe,EAAE,GAC3B,sBAAsB,CAkCxB;AAgBD;;;;;;;GAOG;AACH,eAAO,MAAM,4BAA4B,4BAA4B,CAAC;AAEtE;;;;;;;GAOG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC/B,qBAAqB,GAAG,IAAI,CAW9B;AAYD;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAC5C,MAAM,EAAE,qBAAqB,EAC7B,SAAS,EAAE,MAAM,GAChB,wBAAwB,CA+B1B;AAED;;;;;;GAMG;AACH,wBAAgB,iCAAiC,CAAC,QAAQ,EAAE,yBAAyB,GAAG,MAAM,CAG7F"}