@mcoda/mswarm 0.1.57 → 0.1.61

package/dist/vendor/codali/eval/GateEvaluator.js

@@ -0,0 +1,134 @@
+export const DEFAULT_EVAL_GATE_THRESHOLDS = {
+    patch_apply_drop_max: 0.02,
+    verification_pass_rate_min: 0.9,
+    hallucination_rate_max: 0.02,
+    scope_violation_rate_max: 0,
+};
+const asRate = (value) => value !== null && Number.isFinite(value) ? value : null;
+const normalizeThreshold = (value, fallback, label) => {
+    if (value === undefined)
+        return fallback;
+    if (!Number.isFinite(value) || value < 0 || value > 1) {
+        throw new Error(`Invalid ${label}: expected a number between 0 and 1.`);
+    }
+    return value;
+};
+export const resolveGateThresholds = (...sources) => {
+    const merged = { ...DEFAULT_EVAL_GATE_THRESHOLDS };
+    for (const source of sources) {
+        if (!source)
+            continue;
+        if (source.patch_apply_drop_max !== undefined) {
+            merged.patch_apply_drop_max = source.patch_apply_drop_max;
+        }
+        if (source.verification_pass_rate_min !== undefined) {
+            merged.verification_pass_rate_min = source.verification_pass_rate_min;
+        }
+        if (source.hallucination_rate_max !== undefined) {
+            merged.hallucination_rate_max = source.hallucination_rate_max;
+        }
+        if (source.scope_violation_rate_max !== undefined) {
+            merged.scope_violation_rate_max = source.scope_violation_rate_max;
+        }
+    }
+    return {
+        patch_apply_drop_max: normalizeThreshold(merged.patch_apply_drop_max, DEFAULT_EVAL_GATE_THRESHOLDS.patch_apply_drop_max, "patch_apply_drop_max"),
+        verification_pass_rate_min: normalizeThreshold(merged.verification_pass_rate_min, DEFAULT_EVAL_GATE_THRESHOLDS.verification_pass_rate_min, "verification_pass_rate_min"),
+        hallucination_rate_max: normalizeThreshold(merged.hallucination_rate_max, DEFAULT_EVAL_GATE_THRESHOLDS.hallucination_rate_max, "hallucination_rate_max"),
+        scope_violation_rate_max: normalizeThreshold(merged.scope_violation_rate_max, DEFAULT_EVAL_GATE_THRESHOLDS.scope_violation_rate_max, "scope_violation_rate_max"),
+    };
+};
+const findDelta = (comparison, key) => {
+    if (!comparison || comparison.status !== "compared")
+        return undefined;
+    const entry = comparison.deltas.find((delta) => delta.key === key);
+    if (!entry)
+        return undefined;
+    return {
+        baseline: entry.baseline,
+        current: entry.current,
+        delta: entry.delta,
+    };
+};
+export const evaluateGates = (params) => {
+    const failures = [];
+    const { metrics, thresholds, comparison } = params;
+    const patchDelta = findDelta(comparison, "m003_patch_apply_success_rate");
+    if (patchDelta && patchDelta.baseline !== null && patchDelta.current !== null) {
+        const drop = patchDelta.baseline - patchDelta.current;
+        if (drop > thresholds.patch_apply_drop_max) {
+            failures.push({
+                code: "gate_patch_apply_drop_exceeded",
+                metric: "m003_patch_apply_success_rate",
+                message: "Patch apply success rate dropped more than the allowed threshold.",
+                threshold: thresholds.patch_apply_drop_max,
+                actual: patchDelta.current,
+                baseline: patchDelta.baseline,
+                delta: patchDelta.delta,
+            });
+        }
+    }
+    const verificationRate = asRate(metrics.m004_verification_pass_rate.value);
+    if (verificationRate === null) {
+        failures.push({
+            code: "gate_verification_rate_missing",
+            metric: "m004_verification_pass_rate",
+            message: "Verification pass rate is unavailable.",
+            threshold: thresholds.verification_pass_rate_min,
+            actual: null,
+        });
+    }
+    else if (verificationRate < thresholds.verification_pass_rate_min) {
+        failures.push({
+            code: "gate_verification_rate_below_min",
+            metric: "m004_verification_pass_rate",
+            message: "Verification pass rate is below threshold.",
+            threshold: thresholds.verification_pass_rate_min,
+            actual: verificationRate,
+        });
+    }
+    const hallucinationRate = asRate(metrics.m005_hallucination_rate.value);
+    if (hallucinationRate === null) {
+        failures.push({
+            code: "gate_hallucination_rate_missing",
+            metric: "m005_hallucination_rate",
+            message: "Hallucination rate is unavailable.",
+            threshold: thresholds.hallucination_rate_max,
+            actual: null,
+        });
+    }
+    else if (hallucinationRate > thresholds.hallucination_rate_max) {
+        failures.push({
+            code: "gate_hallucination_rate_exceeded",
+            metric: "m005_hallucination_rate",
+            message: "Hallucination rate is above threshold.",
+            threshold: thresholds.hallucination_rate_max,
+            actual: hallucinationRate,
+        });
+    }
+    const scopeRate = asRate(metrics.m006_scope_violation_rate.value);
+    if (scopeRate === null) {
+        failures.push({
+            code: "gate_scope_violation_rate_missing",
+            metric: "m006_scope_violation_rate",
+            message: "Scope-violation rate is unavailable.",
+            threshold: thresholds.scope_violation_rate_max,
+            actual: null,
+        });
+    }
+    else if (scopeRate > thresholds.scope_violation_rate_max) {
+        failures.push({
+            code: "gate_scope_violation_rate_exceeded",
+            metric: "m006_scope_violation_rate",
+            message: "Scope-violation rate is above threshold.",
+            threshold: thresholds.scope_violation_rate_max,
+            actual: scopeRate,
+        });
+    }
+    return {
+        schema_version: 1,
+        passed: failures.length === 0,
+        thresholds,
+        failures,
+    };
+};

package/dist/vendor/codali/eval/MetricTypes.d.ts

@@ -0,0 +1,28 @@
+export interface RateMetric {
+    numerator: number;
+    denominator: number;
+    missing: number;
+    value: number | null;
+}
+export interface PercentileMetric {
+    sample_size: number;
+    missing: number;
+    median: number | null;
+    p95: number | null;
+}
+export interface EvalMetrics {
+    schema_version: 1;
+    generated_at: string;
+    task_count: number;
+    m001_task_success_rate: RateMetric;
+    m002_first_pass_success_rate: RateMetric;
+    m003_patch_apply_success_rate: RateMetric;
+    m004_verification_pass_rate: RateMetric;
+    m005_hallucination_rate: RateMetric;
+    m006_scope_violation_rate: RateMetric;
+    m007_latency_ms: PercentileMetric;
+    m008_success_tokens: PercentileMetric;
+    m008_success_cost_usd: PercentileMetric;
+}
+export type EvalMetricKey = "m001_task_success_rate" | "m002_first_pass_success_rate" | "m003_patch_apply_success_rate" | "m004_verification_pass_rate" | "m005_hallucination_rate" | "m006_scope_violation_rate" | "m007_latency_ms.median" | "m007_latency_ms.p95" | "m008_success_tokens.median" | "m008_success_tokens.p95" | "m008_success_cost_usd.median" | "m008_success_cost_usd.p95";
+//# sourceMappingURL=MetricTypes.d.ts.map

package/dist/vendor/codali/eval/MetricTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetricTypes.d.ts","sourceRoot":"","sources":["../../src/eval/MetricTypes.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB;AAED,MAAM,WAAW,gBAAgB;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,cAAc,EAAE,CAAC,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,sBAAsB,EAAE,UAAU,CAAC;IACnC,4BAA4B,EAAE,UAAU,CAAC;IACzC,6BAA6B,EAAE,UAAU,CAAC;IAC1C,2BAA2B,EAAE,UAAU,CAAC;IACxC,uBAAuB,EAAE,UAAU,CAAC;IACpC,yBAAyB,EAAE,UAAU,CAAC;IACtC,eAAe,EAAE,gBAAgB,CAAC;IAClC,mBAAmB,EAAE,gBAAgB,CAAC;IACtC,qBAAqB,EAAE,gBAAgB,CAAC;CACzC;AAED,MAAM,MAAM,aAAa,GACrB,wBAAwB,GACxB,8BAA8B,GAC9B,+BAA+B,GAC/B,6BAA6B,GAC7B,yBAAyB,GACzB,2BAA2B,GAC3B,wBAAwB,GACxB,qBAAqB,GACrB,4BAA4B,GAC5B,yBAAyB,GACzB,8BAA8B,GAC9B,2BAA2B,CAAC"}

package/dist/vendor/codali/eval/MetricTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/vendor/codali/eval/MetricsAggregator.d.ts

@@ -0,0 +1,4 @@
+import type { EvalMetrics } from "./MetricTypes.js";
+import type { EvalRunResult } from "./EvalRunner.js";
+export declare const aggregateMetrics: (run: EvalRunResult) => EvalMetrics;
+//# sourceMappingURL=MetricsAggregator.d.ts.map

package/dist/vendor/codali/eval/MetricsAggregator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetricsAggregator.d.ts","sourceRoot":"","sources":["../../src/eval/MetricsAggregator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAgC,MAAM,kBAAkB,CAAC;AAClF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AA0ErD,eAAO,MAAM,gBAAgB,GAAI,KAAK,aAAa,KAAG,WA0BrD,CAAC"}

package/dist/vendor/codali/eval/MetricsAggregator.js

@@ -0,0 +1,97 @@
+const computeRate = (samples) => {
+    let numerator = 0;
+    let denominator = 0;
+    let missing = 0;
+    for (const sample of samples) {
+        if (sample === null) {
+            missing += 1;
+            continue;
+        }
+        denominator += 1;
+        if (sample)
+            numerator += 1;
+    }
+    return {
+        numerator,
+        denominator,
+        missing,
+        value: denominator > 0 ? numerator / denominator : null,
+    };
+};
+const percentile = (values, fraction) => {
+    if (values.length === 0)
+        return null;
+    const sorted = [...values].sort((left, right) => left - right);
+    if (sorted.length === 1)
+        return sorted[0];
+    const index = (sorted.length - 1) * fraction;
+    const lower = Math.floor(index);
+    const upper = Math.ceil(index);
+    const lowerValue = sorted[lower];
+    const upperValue = sorted[upper];
+    if (lower === upper)
+        return lowerValue;
+    const weight = index - lower;
+    return lowerValue + (upperValue - lowerValue) * weight;
+};
+const computePercentiles = (samples) => {
+    const values = samples.filter((entry) => entry !== null);
+    return {
+        sample_size: values.length,
+        missing: samples.length - values.length,
+        median: percentile(values, 0.5),
+        p95: percentile(values, 0.95),
+    };
+};
+const toFirstPassSample = (result) => {
+    if (!result.task_passed)
+        return false;
+    if (result.first_pass === null)
+        return null;
+    return result.first_pass;
+};
+const toPatchApplySample = (result) => {
+    if (result.patch_apply_success !== null)
+        return result.patch_apply_success;
+    const hasPatchExpectation = result.assertion_results.some((assertion) => assertion.code === "assert_expect_patch_apply");
+    if (!hasPatchExpectation)
+        return null;
+    return false;
+};
+const toVerificationSample = (result) => result.verification_passed;
+const toHallucinationSample = (result) => {
+    if (result.hallucination_detected === null)
+        return null;
+    return result.hallucination_detected;
+};
+const toScopeViolationSample = (result) => {
+    if (result.scope_violation_detected === null)
+        return null;
+    return result.scope_violation_detected;
+};
+export const aggregateMetrics = (run) => {
+    const taskSuccess = run.task_results.map((result) => result.task_passed);
+    const firstPass = run.task_results.map((result) => toFirstPassSample(result));
+    const patchApply = run.task_results.map((result) => toPatchApplySample(result));
+    const verificationPass = run.task_results.map((result) => toVerificationSample(result));
+    const hallucinationRate = run.task_results.map((result) => toHallucinationSample(result));
+    const scopeViolationRate = run.task_results.map((result) => toScopeViolationSample(result));
+    const latency = run.task_results.map((result) => result.latency_ms);
+    const successfulTasks = run.task_results.filter((result) => result.task_passed);
+    const successfulTokens = successfulTasks.map((result) => result.tokens_used);
+    const successfulCost = successfulTasks.map((result) => result.cost_usd);
+    return {
+        schema_version: 1,
+        generated_at: new Date().toISOString(),
+        task_count: run.summary.total,
+        m001_task_success_rate: computeRate(taskSuccess.map((value) => value)),
+        m002_first_pass_success_rate: computeRate(firstPass),
+        m003_patch_apply_success_rate: computeRate(patchApply),
+        m004_verification_pass_rate: computeRate(verificationPass),
+        m005_hallucination_rate: computeRate(hallucinationRate),
+        m006_scope_violation_rate: computeRate(scopeViolationRate),
+        m007_latency_ms: computePercentiles(latency),
+        m008_success_tokens: computePercentiles(successfulTokens),
+        m008_success_cost_usd: computePercentiles(successfulCost),
+    };
+};

package/dist/vendor/codali/eval/RegressionComparator.d.ts

@@ -0,0 +1,29 @@
+import type { EvalMetricKey, EvalMetrics } from "./MetricTypes.js";
+export interface EvalMetricDelta {
+    key: EvalMetricKey;
+    unit: "ratio" | "ms" | "tokens" | "usd";
+    higher_is_better: boolean;
+    baseline: number | null;
+    current: number | null;
+    delta: number | null;
+    direction: "up" | "down" | "flat" | "unknown";
+    regression: boolean;
+    improved: boolean;
+}
+export interface EvalRegressionComparison {
+    schema_version: 1;
+    status: "baseline_missing" | "compared";
+    baseline_report_id?: string;
+    baseline_created_at?: string;
+    deltas: EvalMetricDelta[];
+    regression_count: number;
+    improved_count: number;
+    unchanged_count: number;
+}
+export declare const compareAgainstBaseline: (params: {
+    current: EvalMetrics;
+    baseline?: EvalMetrics;
+    baseline_report_id?: string;
+    baseline_created_at?: string;
+}) => EvalRegressionComparison;
+//# sourceMappingURL=RegressionComparator.d.ts.map

package/dist/vendor/codali/eval/RegressionComparator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RegressionComparator.d.ts","sourceRoot":"","sources":["../../src/eval/RegressionComparator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEnE,MAAM,WAAW,eAAe;IAC9B,GAAG,EAAE,aAAa,CAAC;IACnB,IAAI,EAAE,OAAO,GAAG,IAAI,GAAG,QAAQ,GAAG,KAAK,CAAC;IACxC,gBAAgB,EAAE,OAAO,CAAC;IAC1B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,SAAS,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IAC9C,UAAU,EAAE,OAAO,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,wBAAwB;IACvC,cAAc,EAAE,CAAC,CAAC;IAClB,MAAM,EAAE,kBAAkB,GAAG,UAAU,CAAC;IACxC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,gBAAgB,EAAE,MAAM,CAAC;IACzB,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;CACzB;AA0HD,eAAO,MAAM,sBAAsB,GAAI,QAAQ;IAC7C,OAAO,EAAE,WAAW,CAAC;IACrB,QAAQ,CAAC,EAAE,WAAW,CAAC;IACvB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B,KAAG,wBAiDH,CAAC"}

package/dist/vendor/codali/eval/RegressionComparator.js

@@ -0,0 +1,155 @@
+const EPSILON = 1e-12;
+const flattenMetrics = (metrics) => [
+    {
+        key: "m001_task_success_rate",
+        value: metrics.m001_task_success_rate.value,
+        unit: "ratio",
+        higher_is_better: true,
+    },
+    {
+        key: "m002_first_pass_success_rate",
+        value: metrics.m002_first_pass_success_rate.value,
+        unit: "ratio",
+        higher_is_better: true,
+    },
+    {
+        key: "m003_patch_apply_success_rate",
+        value: metrics.m003_patch_apply_success_rate.value,
+        unit: "ratio",
+        higher_is_better: true,
+    },
+    {
+        key: "m004_verification_pass_rate",
+        value: metrics.m004_verification_pass_rate.value,
+        unit: "ratio",
+        higher_is_better: true,
+    },
+    {
+        key: "m005_hallucination_rate",
+        value: metrics.m005_hallucination_rate.value,
+        unit: "ratio",
+        higher_is_better: false,
+    },
+    {
+        key: "m006_scope_violation_rate",
+        value: metrics.m006_scope_violation_rate.value,
+        unit: "ratio",
+        higher_is_better: false,
+    },
+    {
+        key: "m007_latency_ms.median",
+        value: metrics.m007_latency_ms.median,
+        unit: "ms",
+        higher_is_better: false,
+    },
+    {
+        key: "m007_latency_ms.p95",
+        value: metrics.m007_latency_ms.p95,
+        unit: "ms",
+        higher_is_better: false,
+    },
+    {
+        key: "m008_success_tokens.median",
+        value: metrics.m008_success_tokens.median,
+        unit: "tokens",
+        higher_is_better: false,
+    },
+    {
+        key: "m008_success_tokens.p95",
+        value: metrics.m008_success_tokens.p95,
+        unit: "tokens",
+        higher_is_better: false,
+    },
+    {
+        key: "m008_success_cost_usd.median",
+        value: metrics.m008_success_cost_usd.median,
+        unit: "usd",
+        higher_is_better: false,
+    },
+    {
+        key: "m008_success_cost_usd.p95",
+        value: metrics.m008_success_cost_usd.p95,
+        unit: "usd",
+        higher_is_better: false,
+    },
+];
+const compareMetric = (current, baseline) => {
+    if (current.value === null || baseline.value === null) {
+        return {
+            key: current.key,
+            unit: current.unit,
+            higher_is_better: current.higher_is_better,
+            baseline: baseline.value,
+            current: current.value,
+            delta: null,
+            direction: "unknown",
+            regression: false,
+            improved: false,
+        };
+    }
+    const delta = current.value - baseline.value;
+    const direction = Math.abs(delta) <= EPSILON ? "flat" : (delta > 0 ? "up" : "down");
+    const regression = current.higher_is_better ? delta < -EPSILON : delta > EPSILON;
+    const improved = current.higher_is_better ? delta > EPSILON : delta < -EPSILON;
+    return {
+        key: current.key,
+        unit: current.unit,
+        higher_is_better: current.higher_is_better,
+        baseline: baseline.value,
+        current: current.value,
+        delta: Math.abs(delta) <= EPSILON ? 0 : delta,
+        direction,
+        regression,
+        improved,
+    };
+};
+export const compareAgainstBaseline = (params) => {
+    const currentEntries = flattenMetrics(params.current);
+    if (!params.baseline) {
+        return {
+            schema_version: 1,
+            status: "baseline_missing",
+            baseline_report_id: params.baseline_report_id,
+            baseline_created_at: params.baseline_created_at,
+            deltas: currentEntries.map((entry) => ({
+                key: entry.key,
+                unit: entry.unit,
+                higher_is_better: entry.higher_is_better,
+                baseline: null,
+                current: entry.value,
+                delta: null,
+                direction: "unknown",
+                regression: false,
+                improved: false,
+            })),
+            regression_count: 0,
+            improved_count: 0,
+            unchanged_count: currentEntries.length,
+        };
+    }
+    const baselineEntries = flattenMetrics(params.baseline);
+    const baselineByKey = new Map();
+    for (const entry of baselineEntries) {
+        baselineByKey.set(entry.key, entry);
+    }
+    const deltas = [];
+    for (const entry of currentEntries) {
+        const baselineEntry = baselineByKey.get(entry.key);
+        if (!baselineEntry)
+            continue;
+        deltas.push(compareMetric(entry, baselineEntry));
+    }
+    const regressionCount = deltas.filter((entry) => entry.regression).length;
+    const improvedCount = deltas.filter((entry) => entry.improved).length;
+    const unchangedCount = deltas.length - regressionCount - improvedCount;
+    return {
+        schema_version: 1,
+        status: "compared",
+        baseline_report_id: params.baseline_report_id,
+        baseline_created_at: params.baseline_created_at,
+        deltas,
+        regression_count: regressionCount,
+        improved_count: improvedCount,
+        unchanged_count: unchangedCount,
+    };
+};

package/dist/vendor/codali/eval/ReportInputAdapter.d.ts

@@ -0,0 +1,52 @@
+import type { VerificationOutcome } from "../cognitive/Types.js";
+export type NormalizedRunStatus = "pass" | "fail" | "degraded" | "unknown";
+export type NormalizedPhaseStatus = "available" | "missing" | "degraded";
+export interface NormalizedArtifactReference {
+    phase: string;
+    kind: string;
+    status: "present" | "missing";
+    path: string | null;
+    reason_code: string | null;
+}
+export interface NormalizedPhaseOutcome {
+    phase: string;
+    status: NormalizedPhaseStatus;
+    duration_ms: number | null;
+    provider: string | null;
+    model: string | null;
+    input_tokens: number | null;
+    output_tokens: number | null;
+    total_tokens: number | null;
+    cost_usd: number | null;
+    cost_source: string | null;
+    missing_usage_reason: string | null;
+    missing_cost_reason: string | null;
+}
+export interface NormalizedRunRecord {
+    schema_version: 1;
+    run_id: string | null;
+    task_id: string | null;
+    fingerprint: string | null;
+    duration_ms: number | null;
+    final_status: NormalizedRunStatus;
+    failure_class: string | null;
+    reason_codes: string[];
+    retryable: boolean | null;
+    verification_outcome: VerificationOutcome | null;
+    touched_files: string[];
+    artifact_references: NormalizedArtifactReference[];
+    missing_artifacts: string[];
+    phase_outcomes: NormalizedPhaseOutcome[];
+    usage_tokens_total: number | null;
+    cost_usd: number | null;
+    missing_data_markers: string[];
+}
+export interface AdaptRunSummaryInput {
+    runSummary?: unknown;
+    runId?: string;
+    taskId?: string;
+    verificationOutcome?: VerificationOutcome | null;
+    touchedFiles?: string[];
+}
+export declare const adaptRunSummaryForReport: (input?: AdaptRunSummaryInput) => NormalizedRunRecord;
+//# sourceMappingURL=ReportInputAdapter.d.ts.map

package/dist/vendor/codali/eval/ReportInputAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReportInputAdapter.d.ts","sourceRoot":"","sources":["../../src/eval/ReportInputAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAEjE,MAAM,MAAM,mBAAmB,GAAG,MAAM,GAAG,MAAM,GAAG,UAAU,GAAG,SAAS,CAAC;AAC3E,MAAM,MAAM,qBAAqB,GAAG,WAAW,GAAG,SAAS,GAAG,UAAU,CAAC;AAEzE,MAAM,WAAW,2BAA2B;IAC1C,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,SAAS,GAAG,SAAS,CAAC;IAC9B,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAED,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,qBAAqB,CAAC;IAC9B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAC;CACpC;AAED,MAAM,WAAW,mBAAmB;IAClC,cAAc,EAAE,CAAC,CAAC;IAClB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,YAAY,EAAE,mBAAmB,CAAC;IAClC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,EAAE,OAAO,GAAG,IAAI,CAAC;IAC1B,oBAAoB,EAAE,mBAAmB,GAAG,IAAI,CAAC;IACjD,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,mBAAmB,EAAE,2BAA2B,EAAE,CAAC;IACnD,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,cAAc,EAAE,sBAAsB,EAAE,CAAC;IACzC,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,oBAAoB,EAAE,MAAM,EAAE,CAAC;CAChC;AAED,MAAM,WAAW,oBAAoB;IACnC,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,mBAAmB,CAAC,EAAE,mBAAmB,GAAG,IAAI,CAAC;IACjD,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB;AAmMD,eAAO,MAAM,wBAAwB,GAAI,QAAO,oBAAyB,KAAG,mBAsE3E,CAAC"}