@openprose/reactor-cradle 0.1.0-rc.1

package/dist/spikes/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REACTOR_CRADLE_SPIKE_INTEGRATION_NOTES_V0 = exports.REACTOR_CRADLE_SPIKE_PUBLIC_EXPORTS_V0 = void 0;
+__exportStar(require("./k1-ensemble-spread"), exports);
+__exportStar(require("./k2-policy-author"), exports);
+__exportStar(require("./live-refresh"), exports);
+exports.REACTOR_CRADLE_SPIKE_PUBLIC_EXPORTS_V0 = Object.freeze({
+    live_refresh: "./spikes/live-refresh",
+    k1_ensemble_spread: "./spikes/k1-ensemble-spread",
+    k2_policy_author: "./spikes/k2-policy-author",
+});
+exports.REACTOR_CRADLE_SPIKE_INTEGRATION_NOTES_V0 = Object.freeze([
+    "K1/K2 spike evaluators are recorded-only by default; normal tests must not invoke live model refresh.",
+    "Live OpenRouter refresh is an explicit opt-in guard path with cap/accounting input and secret redaction.",
+]);

package/dist/spikes/k1-ensemble-spread.d.ts

@@ -0,0 +1,88 @@
+export declare const K1_ENSEMBLE_SPREAD_SCHEMA_V0: "openprose.reactor-cradle.k1-ensemble-spread";
+export declare const K1_ENSEMBLE_SPREAD_VERSION_V0: 0;
+export type K1AnchorCalibrationGradeV0 = "authored" | "accrued";
+export type K1EnsembleVerdictStatusV0 = "up" | "drifting" | "down" | "blocked";
+export type K1DiversityFloorComponentV0 = "model-family" | "provider" | "size-boundary";
+export type K1CalibrationStatusV0 = "calibrated" | "degraded";
+export type K1IssueCodeV0 = "fixture-not-object" | "schema-invalid" | "version-invalid" | "field-invalid" | "anchor-invalid" | "calibration-bar-invalid" | "outputs-invalid" | "ensemble-too-small" | "diversity-floor-unmet" | "mean-error-too-high" | "spread-error-gap-too-high" | "low-spread-anchor-error";
+export interface K1CalibrationAnchorV0 {
+    readonly label_source: string;
+    readonly calibration_grade: K1AnchorCalibrationGradeV0;
+    readonly verdict: K1EnsembleVerdictStatusV0;
+    readonly score: number;
+}
+export interface K1CalibrationBarV0 {
+    readonly max_mean_error: number;
+    readonly max_spread_error_gap: number;
+    readonly low_spread_threshold: number;
+    readonly max_error_when_low_spread: number;
+}
+export interface K1RecordedModelOutputV0 {
+    readonly output_id: string;
+    readonly provider: string;
+    readonly model: string;
+    readonly family: string;
+    readonly size_class: string;
+    readonly verdict: K1EnsembleVerdictStatusV0;
+    readonly score: number;
+    readonly confidence: number;
+    readonly text: string;
+}
+export interface K1EnsembleSpreadFixtureV0 {
+    readonly schema: typeof K1_ENSEMBLE_SPREAD_SCHEMA_V0;
+    readonly v: typeof K1_ENSEMBLE_SPREAD_VERSION_V0;
+    readonly fixture_id: string;
+    readonly responsibility_id: string;
+    readonly recorded_at: string;
+    readonly anchor: K1CalibrationAnchorV0;
+    readonly calibration_bar: K1CalibrationBarV0;
+    readonly outputs: readonly K1RecordedModelOutputV0[];
+}
+export interface K1DiversityFloorEvaluationV0 {
+    readonly floor_met: boolean;
+    readonly families: readonly string[];
+    readonly providers: readonly string[];
+    readonly size_classes: readonly string[];
+    readonly missing: readonly K1DiversityFloorComponentV0[];
+}
+export interface K1OutputAnchorScoreV0 {
+    readonly output_id: string;
+    readonly provider: string;
+    readonly model: string;
+    readonly family: string;
+    readonly size_class: string;
+    readonly verdict: K1EnsembleVerdictStatusV0;
+    readonly score: number;
+    readonly anchor_error: number;
+    readonly matches_anchor_verdict: boolean;
+}
+export interface K1SpreadMetricsV0 {
+    readonly output_count: number;
+    readonly spread: number;
+    readonly mean_anchor_error: number;
+    readonly max_anchor_error: number;
+    readonly spread_error_gap: number;
+    readonly calibrated_confidence: number | null;
+}
+export interface K1EvaluationIssueV0 {
+    readonly path: string;
+    readonly code: K1IssueCodeV0;
+    readonly message: string;
+    readonly observed: unknown;
+}
+export interface K1EnsembleSpreadEvaluationV0 {
+    readonly ok: boolean;
+    readonly status: K1CalibrationStatusV0;
+    readonly accepted_as_calibrated_confidence: boolean;
+    readonly summary: string;
+    readonly fixture_id: string | null;
+    readonly responsibility_id: string | null;
+    readonly anchor: K1CalibrationAnchorV0 | null;
+    readonly diversity: K1DiversityFloorEvaluationV0;
+    readonly metrics: K1SpreadMetricsV0;
+    readonly output_scores: readonly K1OutputAnchorScoreV0[];
+    readonly issues: readonly K1EvaluationIssueV0[];
+}
+export declare function evaluateK1EnsembleSpreadV0(input: unknown): K1EnsembleSpreadEvaluationV0;
+export declare function evaluateK1DiversityFloorV0(outputs: readonly K1RecordedModelOutputV0[]): K1DiversityFloorEvaluationV0;
+//# sourceMappingURL=k1-ensemble-spread.d.ts.map

package/dist/spikes/k1-ensemble-spread.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"k1-ensemble-spread.d.ts","sourceRoot":"","sources":["../../src/spikes/k1-ensemble-spread.ts"],"names":[],"mappings":"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"}

package/dist/spikes/k1-ensemble-spread.js

@@ -0,0 +1,396 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.K1_ENSEMBLE_SPREAD_VERSION_V0 = exports.K1_ENSEMBLE_SPREAD_SCHEMA_V0 = void 0;
+exports.evaluateK1EnsembleSpreadV0 = evaluateK1EnsembleSpreadV0;
+exports.evaluateK1DiversityFloorV0 = evaluateK1DiversityFloorV0;
+exports.K1_ENSEMBLE_SPREAD_SCHEMA_V0 = "openprose.reactor-cradle.k1-ensemble-spread";
+exports.K1_ENSEMBLE_SPREAD_VERSION_V0 = 0;
+const VERDICT_STATUSES = new Set([
+    "up",
+    "drifting",
+    "down",
+    "blocked",
+]);
+const ANCHOR_GRADES = new Set([
+    "authored",
+    "accrued",
+]);
+const EPSILON = 1e-12;
+function evaluateK1EnsembleSpreadV0(input) {
+    const read = readFixture(input);
+    if (!read.ok) {
+        return degradedResult({
+            summary: "K1 ensemble spread fixture failed validation",
+            fixture_id: null,
+            responsibility_id: null,
+            anchor: null,
+            diversity: emptyDiversity(),
+            metrics: emptyMetrics(),
+            output_scores: [],
+            issues: read.issues,
+        });
+    }
+    const fixture = read.fixture;
+    const diversity = evaluateK1DiversityFloorV0(fixture.outputs);
+    const outputScores = fixture.outputs.map((output) => scoreOutputAgainstAnchor(output, fixture.anchor));
+    const rawErrors = outputScores.map((score) => score.anchor_error);
+    const rawSpread = meanPairwiseDistance(fixture.outputs.map((output) => output.score));
+    const rawMeanError = mean(rawErrors);
+    const rawMaxError = rawErrors.length === 0 ? 0 : Math.max(...rawErrors);
+    const rawSpreadErrorGap = Math.abs(rawMeanError - rawSpread);
+    const issues = [];
+    if (fixture.outputs.length < 2) {
+        issues.push(issue("outputs", "ensemble-too-small", "K1 ensemble spread requires at least two recorded outputs", { outputs: fixture.outputs.length }));
+    }
+    if (!diversity.floor_met) {
+        issues.push(issue("outputs", "diversity-floor-unmet", "spread cannot be treated as calibrated confidence until the ensemble spans at least two families, two providers, and two size classes", {
+            families: diversity.families,
+            providers: diversity.providers,
+            size_classes: diversity.size_classes,
+            missing: diversity.missing,
+        }));
+    }
+    if (rawMeanError > fixture.calibration_bar.max_mean_error + EPSILON) {
+        issues.push(issue("outputs", "mean-error-too-high", "ensemble outputs exceed the anchor mean-error calibration bar", {
+            mean_anchor_error: roundMetric(rawMeanError),
+            max_mean_error: fixture.calibration_bar.max_mean_error,
+        }));
+    }
+    if (rawSpreadErrorGap >
+        fixture.calibration_bar.max_spread_error_gap + EPSILON) {
+        issues.push(issue("outputs", "spread-error-gap-too-high", "spread does not track anchor error within the recorded calibration bar", {
+            spread: roundMetric(rawSpread),
+            mean_anchor_error: roundMetric(rawMeanError),
+            max_spread_error_gap: fixture.calibration_bar.max_spread_error_gap,
+        }));
+    }
+    if (rawSpread <= fixture.calibration_bar.low_spread_threshold + EPSILON &&
+        rawMeanError >
+            fixture.calibration_bar.max_error_when_low_spread + EPSILON) {
+        issues.push(issue("outputs", "low-spread-anchor-error", "low inter-model spread disagrees with the correctness anchor and cannot license calibrated confidence", {
+            spread: roundMetric(rawSpread),
+            mean_anchor_error: roundMetric(rawMeanError),
+            low_spread_threshold: fixture.calibration_bar.low_spread_threshold,
+            max_error_when_low_spread: fixture.calibration_bar.max_error_when_low_spread,
+        }));
+    }
+    const accepted = issues.length === 0;
+    const metrics = {
+        output_count: fixture.outputs.length,
+        spread: roundMetric(rawSpread),
+        mean_anchor_error: roundMetric(rawMeanError),
+        max_anchor_error: roundMetric(rawMaxError),
+        spread_error_gap: roundMetric(rawSpreadErrorGap),
+        calibrated_confidence: accepted
+            ? roundMetric(1 - Math.min(1, rawSpread))
+            : null,
+    };
+    if (!accepted) {
+        return degradedResult({
+            summary: "K1 ensemble spread is degraded; spread is not accepted as calibrated confidence",
+            fixture_id: fixture.fixture_id,
+            responsibility_id: fixture.responsibility_id,
+            anchor: fixture.anchor,
+            diversity,
+            metrics,
+            output_scores: outputScores,
+            issues,
+        });
+    }
+    return {
+        ok: true,
+        status: "calibrated",
+        accepted_as_calibrated_confidence: true,
+        summary: "K1 ensemble spread is calibrated against the anchor with the diversity floor met",
+        fixture_id: fixture.fixture_id,
+        responsibility_id: fixture.responsibility_id,
+        anchor: fixture.anchor,
+        diversity,
+        metrics,
+        output_scores: Object.freeze([...outputScores]),
+        issues: Object.freeze([]),
+    };
+}
+function evaluateK1DiversityFloorV0(outputs) {
+    const families = uniqueSorted(outputs.map((output) => output.family));
+    const providers = uniqueSorted(outputs.map((output) => output.provider));
+    const sizeClasses = uniqueSorted(outputs.map((output) => output.size_class));
+    const missing = [];
+    if (families.length < 2) {
+        missing.push("model-family");
+    }
+    if (providers.length < 2) {
+        missing.push("provider");
+    }
+    if (sizeClasses.length < 2) {
+        missing.push("size-boundary");
+    }
+    return {
+        floor_met: missing.length === 0,
+        families,
+        providers,
+        size_classes: sizeClasses,
+        missing: Object.freeze([...missing]),
+    };
+}
+function readFixture(input) {
+    const issues = [];
+    if (!isRecord(input)) {
+        return {
+            ok: false,
+            issues: [
+                issue("fixture", "fixture-not-object", "K1 ensemble spread fixture must be an object", input),
+            ],
+        };
+    }
+    if (input["schema"] !== exports.K1_ENSEMBLE_SPREAD_SCHEMA_V0) {
+        issues.push(issue("schema", "schema-invalid", "K1 fixture schema must be openprose.reactor-cradle.k1-ensemble-spread", input["schema"]));
+    }
+    if (input["v"] !== exports.K1_ENSEMBLE_SPREAD_VERSION_V0) {
+        issues.push(issue("v", "version-invalid", "K1 fixture version must be 0", input["v"]));
+    }
+    const fixtureId = readNonEmptyString(input, "fixture_id", "fixture", issues);
+    const responsibilityId = readNonEmptyString(input, "responsibility_id", "fixture", issues);
+    const recordedAt = readNonEmptyString(input, "recorded_at", "fixture", issues);
+    const anchor = readAnchor(input["anchor"], issues);
+    const calibrationBar = readCalibrationBar(input["calibration_bar"], issues);
+    const outputs = readOutputs(input["outputs"], issues);
+    if (issues.length > 0 ||
+        fixtureId === undefined ||
+        responsibilityId === undefined ||
+        recordedAt === undefined ||
+        anchor === undefined ||
+        calibrationBar === undefined ||
+        outputs === undefined) {
+        return { ok: false, issues: Object.freeze([...issues]) };
+    }
+    return {
+        ok: true,
+        fixture: {
+            schema: exports.K1_ENSEMBLE_SPREAD_SCHEMA_V0,
+            v: exports.K1_ENSEMBLE_SPREAD_VERSION_V0,
+            fixture_id: fixtureId,
+            responsibility_id: responsibilityId,
+            recorded_at: recordedAt,
+            anchor,
+            calibration_bar: calibrationBar,
+            outputs,
+        },
+    };
+}
+function readAnchor(value, issues) {
+    if (!isRecord(value)) {
+        issues.push(issue("anchor", "anchor-invalid", "K1 fixture must include a correctness anchor object", value));
+        return undefined;
+    }
+    const labelSource = readNonEmptyString(value, "label_source", "anchor", issues);
+    const verdict = readVerdict(value, "verdict", "anchor", issues);
+    const score = readUnitInterval(value, "score", "anchor", issues);
+    const grade = value["calibration_grade"];
+    if (typeof grade !== "string" ||
+        !ANCHOR_GRADES.has(grade)) {
+        issues.push(issue("anchor.calibration_grade", "anchor-invalid", "K1 correctness anchor must be authored or accrued", grade));
+    }
+    if (labelSource === undefined ||
+        verdict === undefined ||
+        score === undefined ||
+        typeof grade !== "string" ||
+        !ANCHOR_GRADES.has(grade)) {
+        return undefined;
+    }
+    return {
+        label_source: labelSource,
+        calibration_grade: grade,
+        verdict,
+        score,
+    };
+}
+function readCalibrationBar(value, issues) {
+    if (!isRecord(value)) {
+        issues.push(issue("calibration_bar", "calibration-bar-invalid", "K1 fixture must include a calibration bar object", value));
+        return undefined;
+    }
+    const maxMeanError = readUnitInterval(value, "max_mean_error", "calibration_bar", issues);
+    const maxSpreadErrorGap = readUnitInterval(value, "max_spread_error_gap", "calibration_bar", issues);
+    const lowSpreadThreshold = readUnitInterval(value, "low_spread_threshold", "calibration_bar", issues);
+    const maxErrorWhenLowSpread = readUnitInterval(value, "max_error_when_low_spread", "calibration_bar", issues);
+    if (maxMeanError === undefined ||
+        maxSpreadErrorGap === undefined ||
+        lowSpreadThreshold === undefined ||
+        maxErrorWhenLowSpread === undefined) {
+        return undefined;
+    }
+    return {
+        max_mean_error: maxMeanError,
+        max_spread_error_gap: maxSpreadErrorGap,
+        low_spread_threshold: lowSpreadThreshold,
+        max_error_when_low_spread: maxErrorWhenLowSpread,
+    };
+}
+function readOutputs(value, issues) {
+    if (!Array.isArray(value)) {
+        issues.push(issue("outputs", "outputs-invalid", "K1 fixture outputs must be an array of recorded model outputs", value));
+        return undefined;
+    }
+    const outputs = [];
+    for (const [index, item] of value.entries()) {
+        const output = readOutput(item, index, issues);
+        if (output !== undefined) {
+            outputs.push(output);
+        }
+    }
+    return Object.freeze([...outputs]);
+}
+function readOutput(value, index, issues) {
+    const path = `outputs[${index}]`;
+    if (!isRecord(value)) {
+        issues.push(issue(path, "outputs-invalid", "K1 recorded model output must be an object", value));
+        return undefined;
+    }
+    const outputId = readNonEmptyString(value, "output_id", path, issues);
+    const provider = readNonEmptyString(value, "provider", path, issues);
+    const model = readNonEmptyString(value, "model", path, issues);
+    const family = readNonEmptyString(value, "family", path, issues);
+    const sizeClass = readNonEmptyString(value, "size_class", path, issues);
+    const verdict = readVerdict(value, "verdict", path, issues);
+    const score = readUnitInterval(value, "score", path, issues);
+    const confidence = readUnitInterval(value, "confidence", path, issues);
+    const text = readNonEmptyString(value, "text", path, issues);
+    if (outputId === undefined ||
+        provider === undefined ||
+        model === undefined ||
+        family === undefined ||
+        sizeClass === undefined ||
+        verdict === undefined ||
+        score === undefined ||
+        confidence === undefined ||
+        text === undefined) {
+        return undefined;
+    }
+    return {
+        output_id: outputId,
+        provider,
+        model,
+        family,
+        size_class: sizeClass,
+        verdict,
+        score,
+        confidence,
+        text,
+    };
+}
+function readNonEmptyString(record, key, path, issues) {
+    const value = record[key];
+    if (typeof value !== "string" || value.length === 0) {
+        issues.push(issue(`${path}.${key}`, "field-invalid", `${path}.${key} must be a non-empty string`, value));
+        return undefined;
+    }
+    return value;
+}
+function readUnitInterval(record, key, path, issues) {
+    const value = record[key];
+    if (typeof value !== "number" ||
+        !Number.isFinite(value) ||
+        value < 0 ||
+        value > 1) {
+        issues.push(issue(`${path}.${key}`, "field-invalid", `${path}.${key} must be a finite number in [0, 1]`, value));
+        return undefined;
+    }
+    return value;
+}
+function readVerdict(record, key, path, issues) {
+    const value = record[key];
+    if (typeof value !== "string" ||
+        !VERDICT_STATUSES.has(value)) {
+        issues.push(issue(`${path}.${key}`, "field-invalid", `${path}.${key} must be one of up, drifting, down, blocked`, value));
+        return undefined;
+    }
+    return value;
+}
+function scoreOutputAgainstAnchor(output, anchor) {
+    return {
+        output_id: output.output_id,
+        provider: output.provider,
+        model: output.model,
+        family: output.family,
+        size_class: output.size_class,
+        verdict: output.verdict,
+        score: output.score,
+        anchor_error: roundMetric(Math.abs(output.score - anchor.score)),
+        matches_anchor_verdict: output.verdict === anchor.verdict,
+    };
+}
+function degradedResult(input) {
+    return {
+        ok: false,
+        status: "degraded",
+        accepted_as_calibrated_confidence: false,
+        summary: input.summary,
+        fixture_id: input.fixture_id,
+        responsibility_id: input.responsibility_id,
+        anchor: input.anchor,
+        diversity: input.diversity,
+        metrics: input.metrics,
+        output_scores: Object.freeze([...input.output_scores]),
+        issues: Object.freeze([...input.issues]),
+    };
+}
+function emptyDiversity() {
+    return {
+        floor_met: false,
+        families: Object.freeze([]),
+        providers: Object.freeze([]),
+        size_classes: Object.freeze([]),
+        missing: Object.freeze(["model-family", "provider", "size-boundary"]),
+    };
+}
+function emptyMetrics() {
+    return {
+        output_count: 0,
+        spread: 0,
+        mean_anchor_error: 0,
+        max_anchor_error: 0,
+        spread_error_gap: 0,
+        calibrated_confidence: null,
+    };
+}
+function meanPairwiseDistance(values) {
+    if (values.length < 2) {
+        return 0;
+    }
+    let total = 0;
+    let count = 0;
+    for (let left = 0; left < values.length; left += 1) {
+        const leftValue = values[left];
+        if (leftValue === undefined) {
+            continue;
+        }
+        for (let right = left + 1; right < values.length; right += 1) {
+            const rightValue = values[right];
+            if (rightValue === undefined) {
+                continue;
+            }
+            total += Math.abs(leftValue - rightValue);
+            count += 1;
+        }
+    }
+    return count === 0 ? 0 : total / count;
+}
+function mean(values) {
+    if (values.length === 0) {
+        return 0;
+    }
+    return values.reduce((total, value) => total + value, 0) / values.length;
+}
+function roundMetric(value) {
+    return Number(value.toFixed(6));
+}
+function uniqueSorted(values) {
+    return Object.freeze(Array.from(new Set(values)).sort());
+}
+function issue(path, code, message, observed) {
+    return { path, code, message, observed };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/spikes/k2-policy-author.d.ts

@@ -0,0 +1,25 @@
+import type { KernelPolicyArtifactValidation } from "@openprose/reactor/kernel";
+export declare const K2_POLICY_AUTHOR_FIXTURE_SCHEMA_V0: "openprose.reactor-cradle.k2-policy-author-fixture";
+export declare const K2_POLICY_AUTHOR_FIXTURE_VERSION_V0: 0;
+export declare const K2_KNOWN_RESPONSIBILITY_ID: "incident-channel-current-briefing";
+export type K2PolicyAuthorEvaluationStatusV0 = "pass" | "fail";
+export interface K2PolicyAuthorEvaluationOptionsV0 {
+    readonly expected_responsibility_id?: string;
+}
+export interface K2PolicyAuthorEvidenceV0 {
+    readonly path: string;
+    readonly message: string;
+    readonly observed?: unknown;
+}
+export interface K2PolicyAuthorEvaluationV0 {
+    readonly ok: boolean;
+    readonly status: K2PolicyAuthorEvaluationStatusV0;
+    readonly summary: string;
+    readonly responsibility_id?: string;
+    readonly live_observable_refs: readonly string[];
+    readonly evidence: readonly K2PolicyAuthorEvidenceV0[];
+    readonly failures: readonly K2PolicyAuthorEvidenceV0[];
+    readonly kernel_validation?: KernelPolicyArtifactValidation;
+}
+export declare function evaluateK2PolicyAuthorFixtureV0(fixture: unknown, options?: K2PolicyAuthorEvaluationOptionsV0): K2PolicyAuthorEvaluationV0;
+//# sourceMappingURL=k2-policy-author.d.ts.map

package/dist/spikes/k2-policy-author.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"k2-policy-author.d.ts","sourceRoot":"","sources":["../../src/spikes/k2-policy-author.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,8BAA8B,EAE/B,MAAM,2BAA2B,CAAC;AAOnC,eAAO,MAAM,kCAAkC,EAC7C,mDAA4D,CAAC;AAC/D,eAAO,MAAM,mCAAmC,EAAG,CAAU,CAAC;AAC9D,eAAO,MAAM,0BAA0B,EACrC,mCAA4C,CAAC;AAE/C,MAAM,MAAM,gCAAgC,GAAG,MAAM,GAAG,MAAM,CAAC;AAE/D,MAAM,WAAW,iCAAiC;IAChD,QAAQ,CAAC,0BAA0B,CAAC,EAAE,MAAM,CAAC;CAC9C;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,gCAAgC,CAAC;IAClD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,oBAAoB,EAAE,SAAS,MAAM,EAAE,CAAC;IACjD,QAAQ,CAAC,QAAQ,EAAE,SAAS,wBAAwB,EAAE,CAAC;IACvD,QAAQ,CAAC,QAAQ,EAAE,SAAS,wBAAwB,EAAE,CAAC;IACvD,QAAQ,CAAC,iBAAiB,CAAC,EAAE,8BAA8B,CAAC;CAC7D;AAUD,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,OAAO,EAChB,OAAO,GAAE,iCAAsC,GAC9C,0BAA0B,CAmG5B"}