{"version":3,"file":"worker-H14yjTvH.cjs","names":["#baseUrl","#auth","#authFromEnv","#timeoutMs","#buildBody","#combineSignals","#buildAuthHeaders","MastraWorker","#config","#strategy","#processor","WorkflowEventProcessor","#running","#transport","PullTransport","#processEvent","MastraWorker","#config","#scheduler","Scheduler","#running","MastraWorker","#config","#manager","#ownsManager","BackgroundTaskManager","#wireStaticTools","#running","#mastra","getStepEntry","RequestContext","StepExecutor"],"sources":["../src/worker/strategies/http-remote-strategy.ts","../src/worker/workers/orchestration-worker.ts","../src/worker/workers/scheduler-worker.ts","../src/worker/workers/background-task-worker.ts","../src/worker/strategies/in-process-strategy.ts"],"sourcesContent":["import type { StepResult } from '../../workflows/types';\nimport type { StepExecutionParams, StepExecutionStrategy } from '../types';\n\n/**\n * Auth credential used by `HttpRemoteStrategy` when calling the server's\n * step-execution endpoint. The server's configured Mastra auth provider\n * (`authenticateToken`) decides whether to accept the credential — this\n * strategy just forwards it.\n *\n * - `bearer`: send `Authorization: Bearer ` (default when only a\n * token string is available)\n * - `api-key`: send `x-worker-api-key: ` for deployments that prefer\n * a custom header (the auth provider's `authenticateToken(_, request)`\n * callback can read it from `request.headers`)\n * - `header`: arbitrary header / value pair for fully custom schemes\n */\nexport type HttpRemoteAuthConfig =\n | { type: 'bearer'; token: string }\n | { type: 'api-key'; key: string }\n | { type: 'header'; name: string; value: string };\n\n/**\n * Executes workflow steps by calling a remote server endpoint over HTTP.\n * Used in standalone worker deployments where the worker runs orchestration\n * logic but delegates actual step execution to the server.\n *\n * Authentication piggy-backs on Mastra's existing auth pipeline: the route\n * is marked `requiresAuth: true` and the deployer's `authenticateToken`\n * provider validates the credential we send here. There is no separate\n * \"worker secret\" — whatever auth scheme the rest of the server uses is\n * what the worker uses too.\n */\nexport class HttpRemoteStrategy implements StepExecutionStrategy {\n #baseUrl: URL;\n #auth?: HttpRemoteAuthConfig;\n #timeoutMs: number;\n\n constructor({ serverUrl, auth, timeoutMs }: { serverUrl: string; auth?: HttpRemoteAuthConfig; timeoutMs?: number }) {\n // Normalize once: ensure trailing slash so URL joins compose correctly.\n const normalized = serverUrl.endsWith('/') ? serverUrl : `${serverUrl}/`;\n this.#baseUrl = new URL(normalized);\n this.#auth = auth ?? HttpRemoteStrategy.#authFromEnv();\n this.#timeoutMs = timeoutMs ?? 30_000;\n }\n\n /**\n * Default credential resolution: when `MASTRA_WORKER_AUTH_TOKEN` is set,\n * send it as a bearer token. The server's auth provider decides whether\n * to accept it.\n */\n static #authFromEnv(): HttpRemoteAuthConfig | undefined {\n const token = process.env.MASTRA_WORKER_AUTH_TOKEN;\n if (!token) return undefined;\n return { type: 'bearer', token };\n }\n\n async executeStep(params: StepExecutionParams): Promise> {\n const url = new URL(\n `workflows/${encodeURIComponent(params.workflowId)}/runs/${encodeURIComponent(params.runId)}/steps/execute`,\n this.#baseUrl,\n );\n\n const body = this.#buildBody(params);\n\n const signal = this.#combineSignals(params.abortSignal);\n\n const res = await fetch(url, {\n method: 'POST',\n headers: {\n 'content-type': 'application/json',\n ...this.#buildAuthHeaders(),\n },\n body,\n signal,\n });\n\n if (!res.ok) {\n const text = await res.text();\n throw new StepExecutionError(res.status, text);\n }\n\n return res.json() as Promise>;\n }\n\n /**\n * Build a JSON-serializable request body. The `params.requestContext` is\n * a plain object; if a caller stuffed a non-serializable value into it we\n * surface a clear error instead of silently dropping fields.\n *\n * `abortSignal` is consumed via fetch's `signal` argument — it must not\n * be in the body.\n */\n #buildBody(params: StepExecutionParams): string {\n const { abortSignal: _abortSignal, requestContext, ...rest } = params;\n let safeRequestContext: Record;\n try {\n safeRequestContext = JSON.parse(JSON.stringify(requestContext ?? {}));\n } catch (err) {\n throw new Error(\n `HttpRemoteStrategy: requestContext is not JSON-serializable. ${err instanceof Error ? err.message : String(err)}`,\n );\n }\n\n return JSON.stringify({\n ...rest,\n requestContext: safeRequestContext,\n });\n }\n\n #combineSignals(externalSignal?: AbortSignal): AbortSignal {\n const timeoutSignal = AbortSignal.timeout(this.#timeoutMs);\n if (!externalSignal) return timeoutSignal;\n // AbortSignal.any aborts when any input aborts.\n if (typeof AbortSignal.any === 'function') {\n return AbortSignal.any([timeoutSignal, externalSignal]);\n }\n // Fallback for runtimes without AbortSignal.any\n const controller = new AbortController();\n const onAbort = (reason: unknown) => controller.abort(reason);\n if (externalSignal.aborted) onAbort(externalSignal.reason);\n else externalSignal.addEventListener('abort', () => onAbort(externalSignal.reason), { once: true });\n if (timeoutSignal.aborted) onAbort(timeoutSignal.reason);\n else timeoutSignal.addEventListener('abort', () => onAbort(timeoutSignal.reason), { once: true });\n return controller.signal;\n }\n\n #buildAuthHeaders(): Record {\n if (!this.#auth) return {};\n if (this.#auth.type === 'api-key') {\n return { 'x-worker-api-key': this.#auth.key };\n }\n if (this.#auth.type === 'header') {\n return { [this.#auth.name]: this.#auth.value };\n }\n return { authorization: `Bearer ${this.#auth.token}` };\n }\n}\n\nexport class StepExecutionError extends Error {\n readonly status: number;\n readonly body: string;\n\n constructor(status: number, body: string) {\n super(`Step execution failed with status ${status}: ${body}`);\n this.name = 'StepExecutionError';\n this.status = status;\n this.body = body;\n }\n}\n","import type { Event } from '../../events/types';\nimport { WorkflowEventProcessor } from '../../workflows/evented/workflow-event-processor';\nimport { HttpRemoteStrategy } from '../strategies/http-remote-strategy';\nimport { PullTransport } from '../transport/pull-transport';\nimport type { WorkerTransport } from '../transport/transport';\nimport type { StepExecutionStrategy } from '../types';\nimport { MastraWorker } from '../worker';\nimport type { WorkerDeps } from '../worker';\n\nconst DEFAULT_GROUP = 'mastra-orchestration';\n\nexport interface OrchestrationWorkerConfig {\n group?: string;\n}\n\n/**\n * Processes workflow events (step.run, step.end, start, cancel, etc.)\n * by delegating to the WorkflowEventProcessor.\n *\n * Subscribes to the PubSub \"workflows\" topic and routes events to WEP.\n *\n * When MASTRA_STEP_EXECUTION_URL is set, injects HttpRemoteStrategy into\n * WEP so step execution happens over HTTP to the server. Otherwise WEP\n * executes steps directly in-process.\n */\nexport class OrchestrationWorker extends MastraWorker {\n readonly name = 'orchestration';\n\n #config: OrchestrationWorkerConfig;\n #transport?: WorkerTransport;\n #processor?: WorkflowEventProcessor;\n #strategy?: StepExecutionStrategy;\n #running = false;\n\n constructor(config: OrchestrationWorkerConfig = {}) {\n super();\n this.#config = config;\n }\n\n async init(deps: WorkerDeps): Promise {\n await super.init(deps);\n\n if (!deps.mastra) {\n throw new Error('OrchestrationWorker requires Mastra instance');\n }\n\n // OrchestrationWorker drives a pull subscription on the workflow topic.\n // Push-only pubsubs (EventEmitter, GCP push subscriptions) deliver events\n // through different paths and must not be paired with this worker.\n const modes = deps.pubsub.supportedModes ?? ['pull'];\n if (!modes.includes('pull')) {\n throw new Error(\n `OrchestrationWorker requires a pull-capable PubSub, but the configured pubsub only supports: ${modes.join(', ')}. ` +\n `Either remove OrchestrationWorker from the workers list or use a pull-capable PubSub (e.g. Redis Streams).`,\n );\n }\n\n // If MASTRA_STEP_EXECUTION_URL is set, use HttpRemoteStrategy\n // (standalone worker calling back to the server for step execution).\n // The strategy reads MASTRA_WORKER_AUTH_TOKEN itself and forwards it\n // through the server's normal Mastra auth provider — there is no\n // separate \"worker secret\" gate.\n const remoteUrl = process.env.MASTRA_STEP_EXECUTION_URL;\n if (remoteUrl) {\n this.#strategy = new HttpRemoteStrategy({\n serverUrl: remoteUrl,\n });\n }\n\n this.#processor = new WorkflowEventProcessor({\n mastra: deps.mastra,\n stepExecutionStrategy: this.#strategy,\n });\n }\n\n async start(): Promise {\n if (this.#running) return;\n if (!this.deps) throw new Error('OrchestrationWorker: call init() before start()');\n\n const group = this.#config.group ?? DEFAULT_GROUP;\n this.#transport = new PullTransport({ pubsub: this.deps.pubsub, group, logger: this.deps.logger });\n\n await this.#transport.start({\n route: (event, ack, nack) => this.#processEvent(event, ack, nack),\n });\n\n this.#running = true;\n }\n\n async stop(): Promise {\n if (!this.#running) return;\n\n try {\n if (this.#transport) {\n await this.#transport.stop();\n this.#transport = undefined;\n }\n } finally {\n this.#running = false;\n }\n }\n\n get isRunning(): boolean {\n return this.#running;\n }\n\n async #processEvent(event: Event, ack?: () => Promise, nack?: () => Promise): Promise {\n if (!this.#processor) {\n throw new Error('OrchestrationWorker not initialized');\n }\n\n // The local processor is used (rather than mastra.handleWorkflowEvent)\n // because it carries the standalone-worker step-execution strategy\n // (HttpRemoteStrategy when MASTRA_STEP_EXECUTION_URL is set), which the\n // shared in-process handler doesn't have.\n const result = await this.#processor.handle(event);\n if (result.ok) {\n try {\n await ack?.();\n } catch (e) {\n this.deps?.logger?.error('OrchestrationWorker: error acking event', { error: e });\n }\n return;\n }\n\n this.deps?.logger?.error('OrchestrationWorker: error processing event', {\n type: event.type,\n runId: event.runId,\n retry: result.retry,\n });\n // Only ask the transport to redeliver on retryable failures. On terminal\n // failures (e.g. WorkflowEventProcessor exhausted its delivery budget and\n // already published workflow.fail) we ack so the poisoned event drops out\n // of the queue instead of looping forever.\n if (result.retry) {\n if (nack) {\n try {\n await nack();\n } catch (e) {\n this.deps?.logger?.error('OrchestrationWorker: error nacking event', { error: e });\n }\n }\n return;\n }\n if (ack) {\n try {\n await ack();\n } catch (e) {\n this.deps?.logger?.error('OrchestrationWorker: error acking terminal event', { error: e });\n }\n }\n }\n}\n","import type { IMastraLogger } from '../../logger';\nimport type { ScheduleTarget } from '../../storage/domains/schedules/base';\nimport { Scheduler } from '../../workflows/scheduler/scheduler';\nimport type { SchedulerConfig } from '../../workflows/scheduler/types';\nimport { MastraWorker } from '../worker';\nimport type { WorkerDeps } from '../worker';\n\n/**\n * Drives cron-based workflow schedules. On each tick it polls storage\n * for due schedules, computes next fire times, and publishes\n * workflow.start events. Does not consume events — only produces them.\n *\n * This is the **single** scheduler code path. The Mastra constructor\n * adds the worker to the default workers list (guarded by\n * `#shouldEnableScheduler()`), and `startWorkers()` initializes it.\n */\nexport class SchedulerWorker extends MastraWorker {\n readonly name = 'scheduler';\n\n #scheduler?: Scheduler;\n #config: SchedulerConfig;\n #running = false;\n\n constructor(config: SchedulerConfig = {}) {\n super();\n this.#config = config;\n }\n\n async init(deps: WorkerDeps): Promise {\n await super.init(deps);\n\n if (!deps.storage) {\n deps.logger.warn('SchedulerWorker: no storage configured, scheduler will not run');\n return;\n }\n\n const schedulesStore = await deps.storage.getStore('schedules');\n if (!schedulesStore) {\n deps.logger.warn('SchedulerWorker: no schedules store available, scheduler will not run');\n return;\n }\n\n // Bind a target-existence predicate so the scheduler can reclaim\n // schedule rows whose target (workflow id or agent id) is no longer\n // registered with Mastra. `getWorkflowById` / `getAgentById` throw on\n // miss; we adapt that into a boolean.\n const mastra = this.mastra;\n const isTargetReady = mastra\n ? (target: ScheduleTarget) => {\n try {\n if (target.type === 'workflow') {\n mastra.getWorkflowById(target.workflowId);\n return true;\n }\n if (target.type === 'agent') {\n mastra.getAgentById(target.agentId);\n return true;\n }\n return false;\n } catch {\n return false;\n }\n }\n : undefined;\n\n this.#scheduler = new Scheduler({\n schedulesStore,\n pubsub: deps.pubsub,\n config: { ...this.#config, isTargetReady },\n });\n this.#scheduler.__setLogger(deps.logger as IMastraLogger);\n\n // Register declarative schedules from workflow configs before starting\n // the tick loop. This syncs code-declared schedules to the DB.\n if (this.mastra) {\n try {\n await this.mastra.registerDeclarativeSchedules(schedulesStore);\n } catch (err) {\n deps.logger.error?.('SchedulerWorker: failed to register declarative schedules', { error: err });\n }\n }\n }\n\n async start(): Promise {\n if (this.#running) return;\n if (this.#scheduler) {\n await this.#scheduler.start();\n }\n this.#running = true;\n }\n\n async stop(): Promise {\n if (!this.#running) return;\n if (this.#scheduler) {\n await this.#scheduler.stop();\n }\n this.#running = false;\n }\n\n get isRunning(): boolean {\n return this.#running;\n }\n\n /** Expose the underlying scheduler for direct API access (e.g., schedule management). */\n get scheduler(): Scheduler | undefined {\n return this.#scheduler;\n }\n}\n","import { BackgroundTaskManager } from '../../background-tasks/manager';\nimport type { Mastra } from '../../mastra';\nimport { MastraWorker } from '../worker';\nimport type { WorkerDeps } from '../worker';\n\n/**\n * Minimal shape of a tool callable usable for cross-process static\n * background-task execution. We intentionally avoid pulling the full\n * `ToolAction` generic into this file — only `execute` is needed.\n */\ntype StaticToolLike = {\n execute?: (\n args: Record,\n options: { toolCallId: string; messages: unknown[]; abortSignal?: AbortSignal },\n ) => Promise;\n};\n\nexport interface BackgroundTaskWorkerConfig {\n globalConcurrency?: number;\n perAgentConcurrency?: number;\n backpressure?: 'queue' | 'reject' | 'fallback-sync';\n defaultTimeoutMs?: number;\n}\n\n/**\n * Manages background tool execution for agents. Handles task queuing,\n * concurrency limits, and lifecycle. Subscribes to PubSub internally\n * via BackgroundTaskManager's own subscription mechanism.\n */\nexport class BackgroundTaskWorker extends MastraWorker {\n readonly name = 'backgroundTasks';\n\n #manager?: BackgroundTaskManager;\n #ownsManager = false;\n #config: BackgroundTaskWorkerConfig;\n #running = false;\n\n constructor(config: BackgroundTaskWorkerConfig = {}) {\n super();\n this.#config = config;\n }\n\n async init(deps: WorkerDeps): Promise {\n await super.init(deps);\n\n // Reuse Mastra's existing BackgroundTaskManager when available so the\n // worker shares the per-task `taskContexts` registry populated by the\n // producer. Spinning up a second manager subscribes the same WORKER_GROUP\n // twice, runs `recoverStaleTasks` twice, and breaks per-task closures —\n // any task dispatched from the producer that lands on this worker's\n // duplicate manager has no `taskContexts` entry.\n const existing = deps.mastra?.backgroundTaskManager;\n if (existing) {\n this.#manager = existing;\n this.#ownsManager = false;\n return;\n }\n\n this.#manager = new BackgroundTaskManager({\n enabled: true,\n mode: 'worker',\n globalConcurrency: this.#config.globalConcurrency,\n perAgentConcurrency: this.#config.perAgentConcurrency,\n backpressure: this.#config.backpressure,\n defaultTimeoutMs: this.#config.defaultTimeoutMs,\n });\n this.#ownsManager = true;\n\n if (deps.mastra) {\n this.#manager.__registerMastra(deps.mastra);\n this.#wireStaticTools(deps.mastra);\n }\n }\n\n /**\n * Populate the manager's static executor registry from tools registered\n * on `Mastra`, so that cross-process dispatches can be resolved by tool\n * name on this worker. Mirrors the wiring Mastra does for its own\n * managed background-task manager — the worker owns a separate manager\n * instance, so it has to populate its own registry.\n */\n #wireStaticTools(mastra: Mastra): void {\n const listTools = (mastra as unknown as { listTools?: () => Record }).listTools;\n const tools = listTools?.call(mastra);\n if (!tools || !this.#manager) return;\n for (const [name, tool] of Object.entries(tools)) {\n if (!tool || typeof tool.execute !== 'function') continue;\n const execute = tool.execute.bind(tool);\n this.#manager.registerStaticExecutor(name, {\n execute: async (args, options) => {\n return execute(args, {\n toolCallId: '',\n messages: [],\n abortSignal: options?.abortSignal,\n });\n },\n });\n }\n }\n\n async start(): Promise {\n if (this.#running) return;\n if (!this.#manager || !this.deps) {\n throw new Error('BackgroundTaskWorker: call init() before start()');\n }\n // When sharing Mastra's manager, Mastra has already fired off init() in\n // its constructor as fire-and-forget. Don't re-await it here — that would\n // surface init errors twice (the constructor's `.catch` already reports\n // them) and serialize startWorkers() behind the manager's full bootstrap.\n if (this.#ownsManager) {\n await this.#manager.init(this.deps.pubsub);\n }\n this.#running = true;\n }\n\n async stop(): Promise {\n if (!this.#running) return;\n // Only tear down the manager if this worker owns it. When sharing Mastra's\n // manager, Mastra's stopWorkers() / shutdown is responsible.\n if (this.#manager && this.#ownsManager) {\n await this.#manager.shutdown();\n }\n this.#running = false;\n }\n\n get isRunning(): boolean {\n return this.#running;\n }\n\n /** Expose the underlying manager for direct API access. */\n get manager(): BackgroundTaskManager | undefined {\n return this.#manager;\n }\n}\n","import { RequestContext } from '../../di';\nimport type { Mastra } from '../../mastra';\nimport { StepExecutor } from '../../workflows/evented/step-executor';\nimport { getStepEntry } from '../../workflows/evented/workflow-event-processor/utils';\nimport type { StepResult } from '../../workflows/types';\nimport type { StepExecutionParams, StepExecutionStrategy } from '../types';\n\n/**\n * Executes workflow steps in the same process by delegating to StepExecutor.\n * This is the default strategy used when the worker runs co-located with the server.\n */\nexport class InProcessStrategy implements StepExecutionStrategy {\n #mastra?: Mastra;\n\n constructor({ mastra }: { mastra?: Mastra } = {}) {\n this.#mastra = mastra;\n }\n\n __registerMastra(mastra: Mastra): void {\n this.#mastra = mastra;\n }\n\n async executeStep(params: StepExecutionParams): Promise> {\n if (!this.#mastra) {\n throw new Error('InProcessStrategy requires Mastra instance. Call __registerMastra() first.');\n }\n\n // Use getWorkflowById — events carry the workflow's `id` property\n // (e.g. \"scheduled-workflow\"), not the config key (\"scheduledWorkflow\").\n const workflow = this.#mastra.getWorkflowById(params.workflowId);\n const entry = getStepEntry(workflow, params.executionPath);\n\n if (!entry) {\n throw new Error(\n `InProcessStrategy: could not resolve step \"${params.stepId}\" at executionPath [${params.executionPath.join(',')}] in workflow \"${params.workflowId}\"`,\n );\n }\n\n const rc = new RequestContext(Object.entries(params.requestContext ?? {}));\n\n let abortController: AbortController | undefined;\n if (params.abortSignal) {\n abortController = new AbortController();\n if (params.abortSignal.aborted) {\n abortController.abort(params.abortSignal.reason);\n } else {\n params.abortSignal.addEventListener(\n 'abort',\n () => {\n abortController!.abort(params.abortSignal!.reason);\n },\n { once: true },\n );\n }\n }\n\n const executor = new StepExecutor({ mastra: this.#mastra });\n\n return executor.execute({\n workflowId: params.workflowId,\n entry,\n runId: params.runId,\n stepResults: params.stepResults as Record>,\n state: params.state,\n requestContext: rc,\n input: params.input,\n resumeData: params.resumeData,\n retryCount: params.retryCount,\n foreachIdx: params.foreachIdx,\n validateInputs: params.validateInputs,\n abortController,\n format: params.format,\n perStep: params.perStep,\n });\n }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAgCA,IAAa,qBAAb,MAAa,mBAAoD;CAC/D;CACA;CACA;CAEA,YAAY,EAAE,WAAW,MAAM,aAAqF;EAElH,MAAM,aAAa,UAAU,SAAS,GAAG,IAAI,YAAY,GAAG,UAAU;EACtE,KAAKA,WAAW,IAAI,IAAI,UAAU;EAClC,KAAKC,QAAQ,QAAQ,mBAAmBC,aAAa;EACrD,KAAKC,aAAa,aAAa;CACjC;;;;;;CAOA,OAAOD,eAAiD;EACtD,MAAM,QAAQ,QAAQ,IAAI;EAC1B,IAAI,CAAC,OAAO,OAAO,KAAA;EACnB,OAAO;GAAE,MAAM;GAAU;EAAM;CACjC;CAEA,MAAM,YAAY,QAAsF;EACtG,MAAM,MAAM,IAAI,IACd,aAAa,mBAAmB,OAAO,UAAU,EAAE,QAAQ,mBAAmB,OAAO,KAAK,EAAE,iBAC5F,KAAKF,QACP;EAEA,MAAM,OAAO,KAAKI,WAAW,MAAM;EAEnC,MAAM,SAAS,KAAKC,gBAAgB,OAAO,WAAW;EAEtD,MAAM,MAAM,MAAM,MAAM,KAAK;GAC3B,QAAQ;GACR,SAAS;IACP,gBAAgB;IAChB,GAAG,KAAKC,kBAAkB;GAC5B;GACA;GACA;EACF,CAAC;EAED,IAAI,CAAC,IAAI,IAAI;GACX,MAAM,OAAO,MAAM,IAAI,KAAK;GAC5B,MAAM,IAAI,mBAAmB,IAAI,QAAQ,IAAI;EAC/C;EAEA,OAAO,IAAI,KAAK;CAClB;;;;;;;;;CAUA,WAAW,QAAqC;EAC9C,MAAM,EAAE,aAAa,cAAc,gBAAgB,GAAG,SAAS;EAC/D,IAAI;EACJ,IAAI;GACF,qBAAqB,KAAK,MAAM,KAAK,UAAU,kBAAkB,CAAC,CAAC,CAAC;EACtE,SAAS,KAAK;GACZ,MAAM,IAAI,MACR,gEAAgE,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG,GACjH;EACF;EAEA,OAAO,KAAK,UAAU;GACpB,GAAG;GACH,gBAAgB;EAClB,CAAC;CACH;CAEA,gBAAgB,gBAA2C;EACzD,MAAM,gBAAgB,YAAY,QAAQ,KAAKH,UAAU;EACzD,IAAI,CAAC,gBAAgB,OAAO;EAE5B,IAAI,OAAO,YAAY,QAAQ,YAC7B,OAAO,YAAY,IAAI,CAAC,eAAe,cAAc,CAAC;EAGxD,MAAM,aAAa,IAAI,gBAAgB;EACvC,MAAM,WAAW,WAAoB,WAAW,MAAM,MAAM;EAC5D,IAAI,eAAe,SAAS,QAAQ,eAAe,MAAM;OACpD,eAAe,iBAAiB,eAAe,QAAQ,eAAe,MAAM,GAAG,EAAE,MAAM,KAAK,CAAC;EAClG,IAAI,cAAc,SAAS,QAAQ,cAAc,MAAM;OAClD,cAAc,iBAAiB,eAAe,QAAQ,cAAc,MAAM,GAAG,EAAE,MAAM,KAAK,CAAC;EAChG,OAAO,WAAW;CACpB;CAEA,oBAA4C;EAC1C,IAAI,CAAC,KAAKF,OAAO,OAAO,CAAC;EACzB,IAAI,KAAKA,MAAM,SAAS,WACtB,OAAO,EAAE,oBAAoB,KAAKA,MAAM,IAAI;EAE9C,IAAI,KAAKA,MAAM,SAAS,UACtB,OAAO,GAAG,KAAKA,MAAM,OAAO,KAAKA,MAAM,MAAM;EAE/C,OAAO,EAAE,eAAe,UAAU,KAAKA,MAAM,QAAQ;CACvD;AACF;AAEA,IAAa,qBAAb,cAAwC,MAAM;CAC5C;CACA;CAEA,YAAY,QAAgB,MAAc;EACxC,MAAM,qCAAqC,OAAO,IAAI,MAAM;EAC5D,KAAK,OAAO;EACZ,KAAK,SAAS;EACd,KAAK,OAAO;CACd;AACF;;;AC3IA,MAAM,gBAAgB;;;;;;;;;;;AAgBtB,IAAa,sBAAb,cAAyCM,uBAAAA,aAAa;CACpD,OAAgB;CAEhB;CACA;CACA;CACA;CACA,WAAW;CAEX,YAAY,SAAoC,CAAC,GAAG;EAClD,MAAM;EACN,KAAKC,UAAU;CACjB;CAEA,MAAM,KAAK,MAAiC;EAC1C,MAAM,MAAM,KAAK,IAAI;EAErB,IAAI,CAAC,KAAK,QACR,MAAM,IAAI,MAAM,8CAA8C;EAMhE,MAAM,QAAQ,KAAK,OAAO,kBAAkB,CAAC,MAAM;EACnD,IAAI,CAAC,MAAM,SAAS,MAAM,GACxB,MAAM,IAAI,MACR,gGAAgG,MAAM,KAAK,IAAI,EAAE,6GAEnH;EAQF,MAAM,YAAY,QAAQ,IAAI;EAC9B,IAAI,WACF,KAAKC,YAAY,IAAI,mBAAmB,EACtC,WAAW,UACb,CAAC;EAGH,KAAKC,aAAa,IAAIC,iCAAAA,uBAAuB;GAC3C,QAAQ,KAAK;GACb,uBAAuB,KAAKF;EAC9B,CAAC;CACH;CAEA,MAAM,QAAuB;EAC3B,IAAI,KAAKG,UAAU;EACnB,IAAI,CAAC,KAAK,MAAM,MAAM,IAAI,MAAM,iDAAiD;EAEjF,MAAM,QAAQ,KAAKJ,QAAQ,SAAS;EACpC,KAAKK,aAAa,IAAIC,uBAAAA,cAAc;GAAE,QAAQ,KAAK,KAAK;GAAQ;GAAO,QAAQ,KAAK,KAAK;EAAO,CAAC;EAEjG,MAAM,KAAKD,WAAW,MAAM,EAC1B,QAAQ,OAAO,KAAK,SAAS,KAAKE,cAAc,OAAO,KAAK,IAAI,EAClE,CAAC;EAED,KAAKH,WAAW;CAClB;CAEA,MAAM,OAAsB;EAC1B,IAAI,CAAC,KAAKA,UAAU;EAEpB,IAAI;GACF,IAAI,KAAKC,YAAY;IACnB,MAAM,KAAKA,WAAW,KAAK;IAC3B,KAAKA,aAAa,KAAA;GACpB;EACF,UAAU;GACR,KAAKD,WAAW;EAClB;CACF;CAEA,IAAI,YAAqB;EACvB,OAAO,KAAKA;CACd;CAEA,MAAMG,cAAc,OAAc,KAA2B,MAA2C;EACtG,IAAI,CAAC,KAAKL,YACR,MAAM,IAAI,MAAM,qCAAqC;EAOvD,MAAM,SAAS,MAAM,KAAKA,WAAW,OAAO,KAAK;EACjD,IAAI,OAAO,IAAI;GACb,IAAI;IACF,MAAM,MAAM;GACd,SAAS,GAAG;IACV,KAAK,MAAM,QAAQ,MAAM,2CAA2C,EAAE,OAAO,EAAE,CAAC;GAClF;GACA;EACF;EAEA,KAAK,MAAM,QAAQ,MAAM,+CAA+C;GACtE,MAAM,MAAM;GACZ,OAAO,MAAM;GACb,OAAO,OAAO;EAChB,CAAC;EAKD,IAAI,OAAO,OAAO;GAChB,IAAI,MACF,IAAI;IACF,MAAM,KAAK;GACb,SAAS,GAAG;IACV,KAAK,MAAM,QAAQ,MAAM,4CAA4C,EAAE,OAAO,EAAE,CAAC;GACnF;GAEF;EACF;EACA,IAAI,KACF,IAAI;GACF,MAAM,IAAI;EACZ,SAAS,GAAG;GACV,KAAK,MAAM,QAAQ,MAAM,oDAAoD,EAAE,OAAO,EAAE,CAAC;EAC3F;CAEJ;AACF;;;;;;;;;;;;ACxIA,IAAa,kBAAb,cAAqCM,uBAAAA,aAAa;CAChD,OAAgB;CAEhB;CACA;CACA,WAAW;CAEX,YAAY,SAA0B,CAAC,GAAG;EACxC,MAAM;EACN,KAAKC,UAAU;CACjB;CAEA,MAAM,KAAK,MAAiC;EAC1C,MAAM,MAAM,KAAK,IAAI;EAErB,IAAI,CAAC,KAAK,SAAS;GACjB,KAAK,OAAO,KAAK,gEAAgE;GACjF;EACF;EAEA,MAAM,iBAAiB,MAAM,KAAK,QAAQ,SAAS,WAAW;EAC9D,IAAI,CAAC,gBAAgB;GACnB,KAAK,OAAO,KAAK,uEAAuE;GACxF;EACF;EAMA,MAAM,SAAS,KAAK;EACpB,MAAM,gBAAgB,UACjB,WAA2B;GAC1B,IAAI;IACF,IAAI,OAAO,SAAS,YAAY;KAC9B,OAAO,gBAAgB,OAAO,UAAU;KACxC,OAAO;IACT;IACA,IAAI,OAAO,SAAS,SAAS;KAC3B,OAAO,aAAa,OAAO,OAAO;KAClC,OAAO;IACT;IACA,OAAO;GACT,QAAQ;IACN,OAAO;GACT;EACF,IACA,KAAA;EAEJ,KAAKC,aAAa,IAAIC,kBAAAA,UAAU;GAC9B;GACA,QAAQ,KAAK;GACb,QAAQ;IAAE,GAAG,KAAKF;IAAS;GAAc;EAC3C,CAAC;EACD,KAAKC,WAAW,YAAY,KAAK,MAAuB;EAIxD,IAAI,KAAK,QACP,IAAI;GACF,MAAM,KAAK,OAAO,6BAA6B,cAAc;EAC/D,SAAS,KAAK;GACZ,KAAK,OAAO,QAAQ,6DAA6D,EAAE,OAAO,IAAI,CAAC;EACjG;CAEJ;CAEA,MAAM,QAAuB;EAC3B,IAAI,KAAKE,UAAU;EACnB,IAAI,KAAKF,YACP,MAAM,KAAKA,WAAW,MAAM;EAE9B,KAAKE,WAAW;CAClB;CAEA,MAAM,OAAsB;EAC1B,IAAI,CAAC,KAAKA,UAAU;EACpB,IAAI,KAAKF,YACP,MAAM,KAAKA,WAAW,KAAK;EAE7B,KAAKE,WAAW;CAClB;CAEA,IAAI,YAAqB;EACvB,OAAO,KAAKA;CACd;;CAGA,IAAI,YAAmC;EACrC,OAAO,KAAKF;CACd;AACF;;;;;;;;AC9EA,IAAa,uBAAb,cAA0CG,uBAAAA,aAAa;CACrD,OAAgB;CAEhB;CACA,eAAe;CACf;CACA,WAAW;CAEX,YAAY,SAAqC,CAAC,GAAG;EACnD,MAAM;EACN,KAAKC,UAAU;CACjB;CAEA,MAAM,KAAK,MAAiC;EAC1C,MAAM,MAAM,KAAK,IAAI;EAQrB,MAAM,WAAW,KAAK,QAAQ;EAC9B,IAAI,UAAU;GACZ,KAAKC,WAAW;GAChB,KAAKC,eAAe;GACpB;EACF;EAEA,KAAKD,WAAW,IAAIE,yBAAAA,sBAAsB;GACxC,SAAS;GACT,MAAM;GACN,mBAAmB,KAAKH,QAAQ;GAChC,qBAAqB,KAAKA,QAAQ;GAClC,cAAc,KAAKA,QAAQ;GAC3B,kBAAkB,KAAKA,QAAQ;EACjC,CAAC;EACD,KAAKE,eAAe;EAEpB,IAAI,KAAK,QAAQ;GACf,KAAKD,SAAS,iBAAiB,KAAK,MAAM;GAC1C,KAAKG,iBAAiB,KAAK,MAAM;EACnC;CACF;;;;;;;;CASA,iBAAiB,QAAsB;EAErC,MAAM,QADa,OAA2E,WACrE,KAAK,MAAM;EACpC,IAAI,CAAC,SAAS,CAAC,KAAKH,UAAU;EAC9B,KAAK,MAAM,CAAC,MAAM,SAAS,OAAO,QAAQ,KAAK,GAAG;GAChD,IAAI,CAAC,QAAQ,OAAO,KAAK,YAAY,YAAY;GACjD,MAAM,UAAU,KAAK,QAAQ,KAAK,IAAI;GACtC,KAAKA,SAAS,uBAAuB,MAAM,EACzC,SAAS,OAAO,MAAM,YAAY;IAChC,OAAO,QAAQ,MAAM;KACnB,YAAY;KACZ,UAAU,CAAC;KACX,aAAa,SAAS;IACxB,CAAC;GACH,EACF,CAAC;EACH;CACF;CAEA,MAAM,QAAuB;EAC3B,IAAI,KAAKI,UAAU;EACnB,IAAI,CAAC,KAAKJ,YAAY,CAAC,KAAK,MAC1B,MAAM,IAAI,MAAM,kDAAkD;EAMpE,IAAI,KAAKC,cACP,MAAM,KAAKD,SAAS,KAAK,KAAK,KAAK,MAAM;EAE3C,KAAKI,WAAW;CAClB;CAEA,MAAM,OAAsB;EAC1B,IAAI,CAAC,KAAKA,UAAU;EAGpB,IAAI,KAAKJ,YAAY,KAAKC,cACxB,MAAM,KAAKD,SAAS,SAAS;EAE/B,KAAKI,WAAW;CAClB;CAEA,IAAI,YAAqB;EACvB,OAAO,KAAKA;CACd;;CAGA,IAAI,UAA6C;EAC/C,OAAO,KAAKJ;CACd;AACF;;;;;;;AC1HA,IAAa,oBAAb,MAAgE;CAC9D;CAEA,YAAY,EAAE,WAAgC,CAAC,GAAG;EAChD,KAAKK,UAAU;CACjB;CAEA,iBAAiB,QAAsB;EACrC,KAAKA,UAAU;CACjB;CAEA,MAAM,YAAY,QAAsE;EACtF,IAAI,CAAC,KAAKA,SACR,MAAM,IAAI,MAAM,4EAA4E;EAM9F,MAAM,QAAQC,iCAAAA,aADG,KAAKD,QAAQ,gBAAgB,OAAO,UACnB,GAAG,OAAO,aAAa;EAEzD,IAAI,CAAC,OACH,MAAM,IAAI,MACR,8CAA8C,OAAO,OAAO,sBAAsB,OAAO,cAAc,KAAK,GAAG,EAAE,iBAAiB,OAAO,WAAW,EACtJ;EAGF,MAAM,KAAK,IAAIE,wBAAAA,eAAwB,OAAO,QAAQ,OAAO,kBAAkB,CAAC,CAAC,CAAC;EAElF,IAAI;EACJ,IAAI,OAAO,aAAa;GACtB,kBAAkB,IAAI,gBAAgB;GACtC,IAAI,OAAO,YAAY,SACrB,gBAAgB,MAAM,OAAO,YAAY,MAAM;QAE/C,OAAO,YAAY,iBACjB,eACM;IACJ,gBAAiB,MAAM,OAAO,YAAa,MAAM;GACnD,GACA,EAAE,MAAM,KAAK,CACf;EAEJ;EAIA,OAAO,IAFcC,iCAAAA,aAAa,EAAE,QAAQ,KAAKH,QAAQ,CAE3C,CAAC,CAAC,QAAQ;GACtB,YAAY,OAAO;GACnB;GACA,OAAO,OAAO;GACd,aAAa,OAAO;GACpB,OAAO,OAAO;GACd,gBAAgB;GAChB,OAAO,OAAO;GACd,YAAY,OAAO;GACnB,YAAY,OAAO;GACnB,YAAY,OAAO;GACnB,gBAAgB,OAAO;GACvB;GACA,QAAQ,OAAO;GACf,SAAS,OAAO;EAClB,CAAC;CACH;AACF"}