@memberjunction/testing-engine 6.1.0-edge.5 → 6.1.0-edge.7

package/dist/drivers/AgentPromptComposer.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @fileoverview Composes an agent's prompt the way production does, for evaluation.
+ * @module @memberjunction/testing-engine
+ */
+import { BaseAgent } from '@memberjunction/ai-agents';
+import type { NativeToolBinding } from '@memberjunction/ai-agents';
+import type { AgentConfiguration, AIPromptParams, ExecuteAgentParams, MJAIAgentEntityExtended } from '@memberjunction/ai-core-plus';
+/**
+ * Exposes `BaseAgent`'s prompt composition so an evaluation driver can build the SAME prompt the
+ * runtime would build.
+ *
+ * **Why this exists rather than the driver assembling a prompt itself.** An MJ agent's prompt is
+ * not its own prompt record. `BaseAgent` runs the *agent type's* system prompt as the parent and
+ * injects the agent's prompt as a child at `agentType.AgentPromptPlaceholder`, and the parent is
+ * what carries the response contract, the action catalog and the sub-agent list. A driver that
+ * executes the agent's own prompt alone therefore measures something production never runs:
+ * a baseline run scored the Demo Loop Agent at 100% malformed with a 626-character
+ * system prompt containing no action catalog, so the model invented an action name it had never
+ * been shown. Codesmith, whose own prompt happens to restate everything, scored 88% on the same
+ * models — the gap was the harness, not the agents.
+ *
+ * Reimplementing the composition here would reproduce that class of error the moment `BaseAgent`
+ * changed. Subclassing and widening the two protected members keeps exactly one implementation:
+ * whatever production does, the evaluation inherits.
+ *
+ * Nothing is overridden and no agent is executed — this class is used only to build parameters.
+ */
+export declare class AgentPromptComposer extends BaseAgent {
+    /** Resolves the agent's type, system prompt and child prompt. */
+    LoadConfiguration(agent: MJAIAgentEntityExtended): Promise<AgentConfiguration>;
+    /**
+     * Builds the composed `AIPromptParams` — parent system prompt, child agent prompt, and the
+     * template data that renders the action catalog and sub-agent list.
+     */
+    ComposeParams<P>(config: AgentConfiguration, payload: P, params: ExecuteAgentParams): Promise<AIPromptParams>;
+    /**
+     * The tool-name → Action map produced by the most recent {@link ComposeParams} call.
+     *
+     * A native tool call comes back under the SANITIZED name (`execute_code`), while the corpus
+     * states its expectation as the Action's real name (`Execute Code`) — test plan §1.2 requires
+     * a case to say what the agent should decide, never how the wire spells it. Without this map
+     * the eval harness would score every correct native call as a wrong action, which is not a
+     * measurement of the feature but of the sanitizer.
+     *
+     * Exposing the framework's own map rather than re-deriving it is the point: the harness reads
+     * the same table the loop dispatches from, so the two cannot drift.
+     */
+    get NativeToolBindings(): ReadonlyMap<string, NativeToolBinding> | undefined;
+}
+//# sourceMappingURL=AgentPromptComposer.d.ts.map

package/dist/drivers/AgentPromptComposer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgentPromptComposer.d.ts","sourceRoot":"","sources":["../../src/drivers/AgentPromptComposer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AACtD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AACnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,cAAc,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAEpI;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,mBAAoB,SAAQ,SAAS;IAC9C,iEAAiE;IACpD,iBAAiB,CAAC,KAAK,EAAE,uBAAuB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAI3F;;;OAGG;IACU,aAAa,CAAC,CAAC,EACxB,MAAM,EAAE,kBAAkB,EAC1B,OAAO,EAAE,CAAC,EACV,MAAM,EAAE,kBAAkB,GAC3B,OAAO,CAAC,cAAc,CAAC;IAU1B;;;;;;;;;;;OAWG;IACH,IAAW,kBAAkB,IAAI,WAAW,CAAC,MAAM,EAAE,iBAAiB,CAAC,GAAG,SAAS,CAElF;CACJ"}

package/dist/drivers/AgentPromptComposer.js

@@ -0,0 +1,60 @@
+/**
+ * @fileoverview Composes an agent's prompt the way production does, for evaluation.
+ * @module @memberjunction/testing-engine
+ */
+import { BaseAgent } from '@memberjunction/ai-agents';
+/**
+ * Exposes `BaseAgent`'s prompt composition so an evaluation driver can build the SAME prompt the
+ * runtime would build.
+ *
+ * **Why this exists rather than the driver assembling a prompt itself.** An MJ agent's prompt is
+ * not its own prompt record. `BaseAgent` runs the *agent type's* system prompt as the parent and
+ * injects the agent's prompt as a child at `agentType.AgentPromptPlaceholder`, and the parent is
+ * what carries the response contract, the action catalog and the sub-agent list. A driver that
+ * executes the agent's own prompt alone therefore measures something production never runs:
+ * a baseline run scored the Demo Loop Agent at 100% malformed with a 626-character
+ * system prompt containing no action catalog, so the model invented an action name it had never
+ * been shown. Codesmith, whose own prompt happens to restate everything, scored 88% on the same
+ * models — the gap was the harness, not the agents.
+ *
+ * Reimplementing the composition here would reproduce that class of error the moment `BaseAgent`
+ * changed. Subclassing and widening the two protected members keeps exactly one implementation:
+ * whatever production does, the evaluation inherits.
+ *
+ * Nothing is overridden and no agent is executed — this class is used only to build parameters.
+ */
+export class AgentPromptComposer extends BaseAgent {
+    /** Resolves the agent's type, system prompt and child prompt. */
+    async LoadConfiguration(agent) {
+        return this.loadAgentConfiguration(agent);
+    }
+    /**
+     * Builds the composed `AIPromptParams` — parent system prompt, child agent prompt, and the
+     * template data that renders the action catalog and sub-agent list.
+     */
+    async ComposeParams(config, payload, params) {
+        // The runtime resolves the agent TYPE before its first turn, and `BaseAgent` now consults it
+        // when deciding whether Actions may be declared as tools (`SupportsNativeToolCalls`). A
+        // composer that skipped this step would compose a prompt for a type-less agent, declare
+        // nothing, and every "native" eval cell would quietly measure the envelope — the exact
+        // mislabelling the scorecard's attribution guard exists to catch. Same call the loop makes.
+        await this.initializeAgentType(params, config);
+        return this.preparePromptParams(config, payload, params);
+    }
+    /**
+     * The tool-name → Action map produced by the most recent {@link ComposeParams} call.
+     *
+     * A native tool call comes back under the SANITIZED name (`execute_code`), while the corpus
+     * states its expectation as the Action's real name (`Execute Code`) — test plan §1.2 requires
+     * a case to say what the agent should decide, never how the wire spells it. Without this map
+     * the eval harness would score every correct native call as a wrong action, which is not a
+     * measurement of the feature but of the sanitizer.
+     *
+     * Exposing the framework's own map rather than re-deriving it is the point: the harness reads
+     * the same table the loop dispatches from, so the two cannot drift.
+     */
+    get NativeToolBindings() {
+        return this._nativeToolBindings;
+    }
+}
+//# sourceMappingURL=AgentPromptComposer.js.map

package/dist/drivers/AgentPromptComposer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgentPromptComposer.js","sourceRoot":"","sources":["../../src/drivers/AgentPromptComposer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAItD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,OAAO,mBAAoB,SAAQ,SAAS;IAC9C,iEAAiE;IAC1D,KAAK,CAAC,iBAAiB,CAAC,KAA8B;QACzD,OAAO,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC,CAAC;IAC9C,CAAC;IAED;;;OAGG;IACI,KAAK,CAAC,aAAa,CACtB,MAA0B,EAC1B,OAAU,EACV,MAA0B;QAE1B,6FAA6F;QAC7F,wFAAwF;QACxF,wFAAwF;QACxF,uFAAuF;QACvF,4FAA4F;QAC5F,MAAM,IAAI,CAAC,mBAAmB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAC/C,OAAO,IAAI,CAAC,mBAAmB,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;IAC7D,CAAC;IAED;;;;;;;;;;;OAWG;IACH,IAAW,kBAAkB;QACzB,OAAO,IAAI,CAAC,mBAAmB,CAAC;IACpC,CAAC;CACJ"}

package/dist/drivers/PinnedVendorPromptRunner.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @fileoverview A prompt runner that will not fail over away from the cell's pinned vendor.
+ * @module @memberjunction/testing-engine
+ */
+import { AIPromptRunner } from '@memberjunction/ai-prompts';
+import type { FailoverConfiguration } from '@memberjunction/ai-prompts';
+import type { MJAIPromptEntityExtended } from '@memberjunction/ai-core-plus';
+/**
+ * Disables cross-vendor failover for a matrix cell that pinned a (model, vendor).
+ *
+ * **Why an eval run must not fail over.** A cell IS a vendor: `gpt-oss-120b · Cerebras · native`
+ * means "this model, on Cerebras, with tools". The Loop agent-type system prompt ships
+ * `FailoverStrategy = 'SameModelDifferentVendor'`, which is the right production behavior — a
+ * transient Cerebras outage should not fail a user's agent run — and exactly the wrong measurement
+ * behavior, because the row still lands in the results table under the Cerebras label.
+ *
+ * That is not hypothetical. An aborted comparison run recorded 27 results whose actual
+ * failure was `Invalid Vertex AI credentials JSON`: a transient error on the pinned Google vendor
+ * failed over to Vertex, whose credential in this environment is malformed. Those rows scored as
+ * Google cells producing no output. A pinned run that fails is a data point; a pinned run that
+ * silently measures somewhere else is a corrupted one.
+ *
+ * `getFailoverConfiguration` is `protected` and documented as the override point for exactly this,
+ * so no production surface changes — the harness declines a behavior rather than the runner
+ * growing a switch for it.
+ */
+export declare class PinnedVendorPromptRunner extends AIPromptRunner {
+    protected getFailoverConfiguration(prompt: MJAIPromptEntityExtended): FailoverConfiguration;
+}
+//# sourceMappingURL=PinnedVendorPromptRunner.d.ts.map

package/dist/drivers/PinnedVendorPromptRunner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PinnedVendorPromptRunner.d.ts","sourceRoot":"","sources":["../../src/drivers/PinnedVendorPromptRunner.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACxE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AAE7E;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,wBAAyB,SAAQ,cAAc;cACrC,wBAAwB,CAAC,MAAM,EAAE,wBAAwB,GAAG,qBAAqB;CAGvG"}

package/dist/drivers/PinnedVendorPromptRunner.js

@@ -0,0 +1,30 @@
+/**
+ * @fileoverview A prompt runner that will not fail over away from the cell's pinned vendor.
+ * @module @memberjunction/testing-engine
+ */
+import { AIPromptRunner } from '@memberjunction/ai-prompts';
+/**
+ * Disables cross-vendor failover for a matrix cell that pinned a (model, vendor).
+ *
+ * **Why an eval run must not fail over.** A cell IS a vendor: `gpt-oss-120b · Cerebras · native`
+ * means "this model, on Cerebras, with tools". The Loop agent-type system prompt ships
+ * `FailoverStrategy = 'SameModelDifferentVendor'`, which is the right production behavior — a
+ * transient Cerebras outage should not fail a user's agent run — and exactly the wrong measurement
+ * behavior, because the row still lands in the results table under the Cerebras label.
+ *
+ * That is not hypothetical. An aborted comparison run recorded 27 results whose actual
+ * failure was `Invalid Vertex AI credentials JSON`: a transient error on the pinned Google vendor
+ * failed over to Vertex, whose credential in this environment is malformed. Those rows scored as
+ * Google cells producing no output. A pinned run that fails is a data point; a pinned run that
+ * silently measures somewhere else is a corrupted one.
+ *
+ * `getFailoverConfiguration` is `protected` and documented as the override point for exactly this,
+ * so no production surface changes — the harness declines a behavior rather than the runner
+ * growing a switch for it.
+ */
+export class PinnedVendorPromptRunner extends AIPromptRunner {
+    getFailoverConfiguration(prompt) {
+        return { ...super.getFailoverConfiguration(prompt), strategy: 'None' };
+    }
+}
+//# sourceMappingURL=PinnedVendorPromptRunner.js.map

package/dist/drivers/PinnedVendorPromptRunner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PinnedVendorPromptRunner.js","sourceRoot":"","sources":["../../src/drivers/PinnedVendorPromptRunner.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAI5D;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,OAAO,wBAAyB,SAAQ,cAAc;IACrC,wBAAwB,CAAC,MAAgC;QACxE,OAAO,EAAE,GAAG,KAAK,CAAC,wBAAwB,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;IAC3E,CAAC;CACJ"}

package/dist/drivers/PromptEvalDriver.d.ts

@@ -0,0 +1,158 @@
+/**
+ * @fileoverview Prompt-eval driver — one model decision, evaluated deterministically.
+ * @module @memberjunction/testing-engine
+ */
+import type { MJTestEntity } from '@memberjunction/core-entities';
+import type { ChatMessage, ChatToolChoice } from '@memberjunction/ai';
+import { BaseTestDriver } from './BaseTestDriver.js';
+import { DriverExecutionContext, DriverExecutionResult, ValidationResult } from '../types.js';
+/** One oracle to run, as it appears in the test's `Configuration`. */
+export interface PromptEvalOracleConfig {
+    type: string;
+    weight?: number;
+    config?: Record<string, unknown>;
+}
+/** `Configuration` for a Prompt Eval test. */
+export interface PromptEvalConfig {
+    /** The prompt to run. Exactly one of `promptId` / `agentId` is required. */
+    promptId?: string;
+    /** Resolve the prompt from an agent's active prompt binding instead of naming it. */
+    agentId?: string;
+    /**
+     * Same, by agent NAME. The corpus states its agent by name — golden files stay readable and
+     * diffable, and the suite generator runs offline with no database to resolve a GUID against.
+     */
+    agentName?: string;
+    oracles: PromptEvalOracleConfig[];
+    /** Per-cell model pinning — this is the matrix axis (§3.3). */
+    modelId?: string;
+    vendorId?: string;
+    configurationId?: string;
+    /**
+     * Per-cell reasoning effort. Numeric 1-100 is MJ's cross-provider scale; a provider-named
+     * level (OpenAI's `'xhigh'` / `'none'`) is passed through verbatim for the levels that scale
+     * cannot express. Part of the cell identity, so two effort levels are two cells, not noise
+     * pooled into one.
+     */
+    effortLevel?: number | string;
+    /**
+     * Which wire encoding this cell observes.
+     *
+     * The composer attaches the agent's Actions as native tool declarations unconditionally,
+     * because that is what `BaseAgent` does and the whole point of composing through it is to send
+     * what production sends. A cell measuring the ENVELOPE therefore has to take them back off:
+     * `toolsProvided` is one of the three terms in the runner's gate, so withholding declarations
+     * is exactly how a real envelope-mode call differs from a native one. Nothing else about the
+     * request changes, which is what keeps the two arms comparable.
+     *
+     * Defaults to `'envelope'`, so a record written before this axis existed —
+     * keeps measuring the baseline it was generated to measure.
+     */
+    toolCallingMode?: 'envelope' | 'native';
+    /**
+     * Control-flow arm for a native cell. `'implicit'` keeps the control tools the composer
+     * declared (the model's catalog must also say `NativeControlFlow: 'implicit'` for the runner to
+     * send them); `'envelope'` (default) strips them here so the cell measures the hybrid on a
+     * model whose catalog has been switched to implicit for the gate run.
+     */
+    nativeControlFlow?: 'envelope' | 'implicit';
+    /**
+     * Native-tool-results arm: send tool-form history (assistant toolCalls + tool turns) as native tool turns.
+     * Otherwise the driver renders that history as the corpus's `[Action Result] …` prose, which is
+     * what the loop shows models that do not return results natively.
+     */
+    nativeToolResults?: boolean;
+    /** `tool_choice` for a native cell. Omitted accepts the agent's own default (`'auto'`). */
+    toolChoice?: ChatToolChoice;
+    /** Replaces the composed system prompt wholesale. Used by the trimmed-prompt variant cells. */
+    systemPromptOverride?: string;
+    maxExecutionTime?: number;
+    scoringWeights?: Record<string, number>;
+}
+/** `InputDefinition` for a Prompt Eval test — the frozen state the model decides from. */
+export interface PromptEvalInput {
+    /** Prior conversation, including any action-result annotations for mid-loop cases. */
+    conversationMessages?: ChatMessage[];
+    /** The starting payload. Surfaced to the template as `_CURRENT_PAYLOAD` (§3.1). */
+    payload?: Record<string, unknown>;
+    /** Anything else the template needs. */
+    templateData?: Record<string, unknown>;
+}
+/**
+ * Runs ONE prompt and evaluates the single decision it produced.
+ *
+ * This is the corpus workhorse (test plan §3.1). Given frozen mid-loop state — a payload, a
+ * conversation, a system prompt — it asks the model for exactly one decision and hands the raw turn
+ * to the decision oracles. **No action ever executes.** `AIPromptRunner.ExecutePrompt` returns the
+ * model's reply and nothing is dispatched, which is what makes the evaluation a plain data
+ * assertion rather than a side-effecting integration test.
+ *
+ * Why a separate driver rather than reusing `AgentEvalDriver`: an agent run is a *loop*, and a loop
+ * confounds the measurement. If the corpus is asking "does this model, in this state, choose action
+ * B", then a run that recovered on iteration three answers a different question. Loop-level cases
+ * still go through `AgentEvalDriver`; this driver isolates the single decision.
+ *
+ * Three execution details are load-bearing and easy to get wrong:
+ * - **explicit `contextUser`** — the CLI provider's `CurrentUser` is null (#3251), so an omitted
+ *   context user fails deep inside template rendering with an unrelated-looking error;
+ * - **`AIEngine.Config()` before the first run** — otherwise prompt/model metadata is empty;
+ * - **`WaitForPendingPromptRunSaves()` before oracles read back** — prompt-run persistence is
+ *   fire-and-forget, so an oracle asserting on `AIPromptRun` would race it.
+ */
+export declare class PromptEvalDriver extends BaseTestDriver {
+    private static readonly AI_PROMPT_RUNS_ENTITY_NAME;
+    private _promptRunsEntityId;
+    Execute(context: DriverExecutionContext): Promise<DriverExecutionResult>;
+    /**
+     * Turns the runner's result into the encoding-neutral shape the decision oracles read.
+     *
+     * Both channels are carried, unjudged: the raw text and any native tool calls. Deciding which
+     * one *counts* is the normalizer's job, not the driver's — that separation is what lets the
+     * same corpus case score an envelope run and a native run.
+     */
+    /** Which protocol a cell measures — the normalizer reads plain text differently under implicit. */
+    private protocolOf;
+    private extractTurn;
+    private buildParams;
+    /**
+     * Builds the prompt parameters, composing the agent the way the runtime composes it.
+     *
+     * An MJ agent's prompt is not its own prompt record: `BaseAgent` runs the AGENT TYPE's system
+     * prompt as the parent and injects the agent's prompt as a child, and only the parent carries
+     * the response contract, the action catalog and the sub-agent list. Executing the agent's own
+     * prompt alone measures a prompt production never sends — see {@link AgentPromptComposer}.
+     *
+     * `promptId` still runs that one prompt bare, which is the point of naming a prompt rather
+     * than an agent: it is the only way to evaluate a prompt outside any agent.
+     */
+    private buildComposedParams;
+    /** The matrix axes (§3.3): model/vendor pinning, effort, configuration — applied last so a cell wins. */
+    private applyCellOverrides;
+    /**
+     * Applies the cell's tool-calling mode by adding or withholding the tool declarations.
+     *
+     * This driver never decides whether tools GO OUT — `AIPromptRunner`'s gate does, from metadata,
+     * exactly as it does in production. All the cell controls is whether any were offered. That
+     * split matters for what a comparison number means: a `native` cell whose model or prompt is not
+     * configured for native mode does not quietly become a native run, it records an envelope one,
+     * and the mismatch shows up here rather than as an unexplained delta in the scorecard.
+     */
+    private applyToolCallingMode;
+    /** Resolves the prompt either directly or through the agent's active prompt binding. */
+    private resolvePrompt;
+    /** Agent name -> ID. Returns undefined when no name was given, so `agentId` can be absent too. */
+    private resolveAgentIdByName;
+    private findAgentPromptId;
+    /**
+     * Runs the configured oracles.
+     *
+     * A missing oracle becomes a FAILED result naming it, rather than being skipped. Skipping is
+     * how `trace-validate-sub-agents` went unimplemented while the tests referencing it reported
+     * green — a quarter of their weight silently left the score. A weighted check that cannot run
+     * is a failure of the test, not an absence of one.
+     */
+    private runOracles;
+    Validate(test: MJTestEntity): Promise<ValidationResult>;
+    private getPromptRunsEntityId;
+}
+//# sourceMappingURL=PromptEvalDriver.d.ts.map

package/dist/drivers/PromptEvalDriver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PromptEvalDriver.d.ts","sourceRoot":"","sources":["../../src/drivers/PromptEvalDriver.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,OAAO,KAAK,EAAE,YAAY,EAAyB,MAAM,+BAA+B,CAAC;AAMzF,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACtE,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,sBAAsB,EAAE,qBAAqB,EAAe,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAIxG,sEAAsE;AACtE,MAAM,WAAW,sBAAsB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED,8CAA8C;AAC9C,MAAM,WAAW,gBAAgB;IAC7B,4EAA4E;IAC5E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,qFAAqF;IACrF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,sBAAsB,EAAE,CAAC;IAClC,+DAA+D;IAC/D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC9B;;;;;;;;;;;;OAYG;IACH,eAAe,CAAC,EAAE,UAAU,GAAG,QAAQ,CAAC;IACxC;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,UAAU,GAAG,UAAU,CAAC;IAC5C;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,2FAA2F;IAC3F,UAAU,CAAC,EAAE,cAAc,CAAC;IAC5B,+FAA+F;IAC/F,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC3C;AAiBD,0FAA0F;AAC1F,MAAM,WAAW,eAAe;IAC5B,sFAAsF;IACtF,oBAAoB,CAAC,EAAE,WAAW,EAAE,CAAC;IACrC,mFAAmF;IACnF,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,wCAAwC;IACxC,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC1C;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBACa,gBAAiB,SAAQ,cAAc;IAChD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,0BAA0B,CAAwB;IAC1E,OAAO,CAAC,mBAAmB,CAAuB;IAErC,OAAO,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,qBAAqB,CAAC;IA2CrF;;;;;;OAMG;IACH,mGAAmG;IACnG,OAAO,CAAC,UAAU;IAKlB,OAAO,CAAC,WAAW;IAoBnB,OAAO,CAAC,WAAW;IAwBnB;;;;;;;;;;OAUG;YACW,mBAAmB;IA2DjC,yGAAyG;IACzG,OAAO,CAAC,kBAAkB;IAkB1B;;;;;;;;OAQG;IACH,OAAO,CAAC,oBAAoB;IAsC5B,wFAAwF;YAC1E,aAAa;IAU3B,kGAAkG;YACpF,oBAAoB;YAsBpB,iBAAiB;IAiB/B;;;;;;;OAOG;YACW,UAAU;IAwCF,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAwB7E,OAAO,CAAC,qBAAqB;CAQhC"}