spec-controller 0.1.0-alpha.1 → 0.1.0-alpha.2

package/dist/mutation-ratchet/reconcile.d.ts

@@ -1,82 +0,0 @@
-/**
- * THE COMPOSITION — one gate's run reconciled against its record, with every term a project owns
- * arriving from that project (@SCN-RAT-014, 3F-2804).
- *
- * FIVE TERMS, AND FOUR OF THEM ARE WHY THIS MODULE EXISTS RATHER THAN A CALLER WIRING THE PIECES
- * TOGETHER ITSELF. The reader, the report and the verdict below were each built generic, and the
- * reference implementation this library was lifted from was generic in all of them too — right up
- * to the point where something had to say WHICH tree, WHICH file, WHICH report and WHAT to type
- * next. Those four answers were written into the code there, and they are the four that arrive
- * here as a request instead.
- *
- * THE ROOT IS THE CONSUMER'S WORKSPACE, NEVER THIS MODULE'S OWN LOCATION, and that is the term
- * that fails silently rather than loudly. A module finding the tree from where it is installed
- * agrees with its caller for exactly as long as it sits beside that caller's code — which it does
- * in the repository it was written in, and stops doing the day it is installed as a dependency,
- * when it resolves into its own directory inside a package folder and finds nothing there. There
- * is no way to notice from inside: the paths are well-formed, the reads fail as absent files, and
- * a gate that measured perfectly reads as a gate that never ran. So the root arrives, and every
- * path below is joined onto it.
- *
- * THE RECORD FILE IS DEFAULTED AND THE REPORT PATH IS NOT, and the asymmetry is a ruling rather
- * than an oversight. Where a mutation sweep drops its output is a RUNNER'S convention, so a
- * default there would be this module naming a runner — the exact leak the Rule above it forbids.
- * The record's name is owned by whoever owns the record, so a conventional default costs its
- * owner nothing and a caller who wants another writes one.
- *
- * AND THE BANK-IT INSTRUCTION IS CARRIED WHOLE, because the two verdicts that ask for a record to
- * be banked have to say what to type, and what to type is a sentence only the calling project can
- * write. Left to this module it would be somebody's script name, sitting inside a message, reached
- * only on the runs nobody reads twice.
- *
- * NOTHING HERE NAMES A PROJECT, A CHECK, A RUNNER, A WORKFLOW OR A REPOSITORY, and @SCN-RAT-014
- * asserts that over this module's own bytes rather than trusting it.
- */
-import { type MutationVerdict } from "./verdict.js";
-/**
- * The name a record is filed under when its caller does not choose one.
- *
- * A DEFAULT, NEVER A CONSTANT THE READER GOES LOOKING FOR. Which file holds a project's bars is
- * that project's own fact, and a caller naming its own is answered by that name — this is only
- * what stands in when none is given, and it is exported so a caller happy with the convention does
- * not have to respell it and get one character of it wrong.
- */
-export declare const RECORD_FILE = "quality-thresholds.yml";
-/**
- * One reconciliation, as the calling project states it.
- *
- * EVERY FIELD IS A TERM THE PROJECT OWNS. There is nothing else here — no setting, no mode, no
- * threshold of this module's own. The bar is in the project's record and the run is in the
- * project's report; what this asks for is where those two are and what to call things.
- */
-export interface RatchetRequest {
-    /** The gate to reconcile, as the project's own record names it. */
-    readonly gate: string;
-    /**
-     * The CONSUMER'S workspace — the tree the record and the report both sit in.
-     *
-     * Never this module's own installed location, which is the same tree only by coincidence and
-     * only until the day this ships as something another repository installs.
-     */
-    readonly root: string;
-    /**
-     * Where the gate's run left its report, relative to that root.
-     *
-     * REQUIRED, AND THAT IS THE RULING. A default here would be a runner's output convention wearing
-     * this module's name.
-     */
-    readonly reportPath: string;
-    /** What the project's own people type to bank a measurement, carried into the verdicts that ask. */
-    readonly bankCommand: string;
-    /** Where the project's record sits, relative to that root. Defaults to {@link RECORD_FILE}. */
-    readonly recordFile?: string;
-}
-/**
- * Reconcile one gate's run against the bar its project's record states.
- *
- * @param request the five terms the calling project owns
- * @returns the verdict, red or green, carrying the line its reader gets
- * @throws MalformedRecordError when the record cannot be read as a bar, or holds no such gate
- */
-export declare function reconcileGate(request: RatchetRequest): MutationVerdict;
-//# sourceMappingURL=reconcile.d.ts.map

package/dist/mutation-ratchet/reconcile.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"reconcile.d.ts","sourceRoot":"","sources":["../../src/mutation-ratchet/reconcile.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAOH,OAAO,EAA6B,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;AAE/E;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,2BAA2B,CAAC;AAEpD;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC7B,mEAAmE;IACnE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,oGAAoG;IACpG,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,+FAA+F;IAC/F,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,cAAc,GAAG,eAAe,CAWtE"}

package/dist/mutation-ratchet/reconcile.js

@@ -1,67 +0,0 @@
-/**
- * THE COMPOSITION — one gate's run reconciled against its record, with every term a project owns
- * arriving from that project (@SCN-RAT-014, 3F-2804).
- *
- * FIVE TERMS, AND FOUR OF THEM ARE WHY THIS MODULE EXISTS RATHER THAN A CALLER WIRING THE PIECES
- * TOGETHER ITSELF. The reader, the report and the verdict below were each built generic, and the
- * reference implementation this library was lifted from was generic in all of them too — right up
- * to the point where something had to say WHICH tree, WHICH file, WHICH report and WHAT to type
- * next. Those four answers were written into the code there, and they are the four that arrive
- * here as a request instead.
- *
- * THE ROOT IS THE CONSUMER'S WORKSPACE, NEVER THIS MODULE'S OWN LOCATION, and that is the term
- * that fails silently rather than loudly. A module finding the tree from where it is installed
- * agrees with its caller for exactly as long as it sits beside that caller's code — which it does
- * in the repository it was written in, and stops doing the day it is installed as a dependency,
- * when it resolves into its own directory inside a package folder and finds nothing there. There
- * is no way to notice from inside: the paths are well-formed, the reads fail as absent files, and
- * a gate that measured perfectly reads as a gate that never ran. So the root arrives, and every
- * path below is joined onto it.
- *
- * THE RECORD FILE IS DEFAULTED AND THE REPORT PATH IS NOT, and the asymmetry is a ruling rather
- * than an oversight. Where a mutation sweep drops its output is a RUNNER'S convention, so a
- * default there would be this module naming a runner — the exact leak the Rule above it forbids.
- * The record's name is owned by whoever owns the record, so a conventional default costs its
- * owner nothing and a caller who wants another writes one.
- *
- * AND THE BANK-IT INSTRUCTION IS CARRIED WHOLE, because the two verdicts that ask for a record to
- * be banked have to say what to type, and what to type is a sentence only the calling project can
- * write. Left to this module it would be somebody's script name, sitting inside a message, reached
- * only on the runs nobody reads twice.
- *
- * NOTHING HERE NAMES A PROJECT, A CHECK, A RUNNER, A WORKFLOW OR A REPOSITORY, and @SCN-RAT-014
- * asserts that over this module's own bytes rather than trusting it.
- */
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import { gateRecordFor, parseGateRecords } from "./record.js";
-import { readMutationReport } from "./report.js";
-import { noMeasurement, verdictFor } from "./verdict.js";
-/**
- * The name a record is filed under when its caller does not choose one.
- *
- * A DEFAULT, NEVER A CONSTANT THE READER GOES LOOKING FOR. Which file holds a project's bars is
- * that project's own fact, and a caller naming its own is answered by that name — this is only
- * what stands in when none is given, and it is exported so a caller happy with the convention does
- * not have to respell it and get one character of it wrong.
- */
-export const RECORD_FILE = "quality-thresholds.yml";
-/**
- * Reconcile one gate's run against the bar its project's record states.
- *
- * @param request the five terms the calling project owns
- * @returns the verdict, red or green, carrying the line its reader gets
- * @throws MalformedRecordError when the record cannot be read as a bar, or holds no such gate
- */
-export function reconcileGate(request) {
-    const recordFile = request.recordFile ?? RECORD_FILE;
-    const records = parseGateRecords(readFileSync(join(request.root, recordFile), "utf8"), recordFile);
-    const record = gateRecordFor(request.gate, records, recordFile);
-    const read = readMutationReport(request.gate, join(request.root, request.reportPath));
-    // A refusal is carried through as the verdict it implies rather than as an absence: a report that
-    // is not there is a gate that produced no score, which is not a gate that passed.
-    return read.ok
-        ? verdictFor(record, read.measurement, request.bankCommand)
-        : noMeasurement(request.gate, read.reason);
-}
-//# sourceMappingURL=reconcile.js.map

package/dist/mutation-ratchet/reconcile.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"reconcile.js","sourceRoot":"","sources":["../../src/mutation-ratchet/reconcile.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,UAAU,EAAwB,MAAM,cAAc,CAAC;AAE/E;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,wBAAwB,CAAC;AAgCpD;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAAC,OAAuB;IACnD,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,IAAI,WAAW,CAAC;IACrD,MAAM,OAAO,GAAG,gBAAgB,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,UAAU,CAAC,EAAE,MAAM,CAAC,EAAE,UAAU,CAAC,CAAC;IACnG,MAAM,MAAM,GAAG,aAAa,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;IAChE,MAAM,IAAI,GAAG,kBAAkB,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC;IAEtF,kGAAkG;IAClG,kFAAkF;IAClF,OAAO,IAAI,CAAC,EAAE;QACZ,CAAC,CAAC,UAAU,CAAC,MAAM,EAAE,IAAI,CAAC,WAAW,EAAE,OAAO,CAAC,WAAW,CAAC;QAC3D,CAAC,CAAC,aAAa,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;AAC/C,CAAC"}

package/dist/mutation-ratchet/verdict.d.ts

@@ -1,177 +0,0 @@
-/**
- * THE VERDICT — what a gate's run turned out to be, reconciled against the record it last banked
- * (@SCN-RAT-004, 3F-2794; @SCN-RAT-005, 3F-2795; @SCN-RAT-006, 3F-2796; @SCN-RAT-007, 3F-2797;
- * @SCN-RAT-008, 3F-2798; @SCN-RAT-016, 3F-2809).
- *
- * A BAR CAN ONLY ASK WHETHER ONE NUMBER FELL, AND THE INTERESTING QUESTION IS WHY. A mutation score
- * is detected over total, so it drops for two entirely unrelated reasons: a mutant this suite used
- * to kill now survives, which is the fault the gate exists for; or new mutable code arrived carrying
- * survivors with it, which is no fault at all. `record.ts` keeps the two counts apart so that this
- * module can tell those apart — and telling them apart is the whole product.
- *
- * THE KILLS ARE ASKED ABOUT FIRST, AND ASKED ABOUT ALONE. A run that loses kills WHILE its mutant
- * population grows is the shape every looser reading gets wrong. The growth is a true fact about
- * that run and innocent on its own, so a reconciler that notices it before it counts the kills
- * answers with the innocent half — the score fell, the population explains why, nobody looks any
- * further and a real regression ships. So the count comparison is the first thing this module does,
- * and the population's movement is never allowed to be the answer while a kill is missing.
- *
- * AND INSIDE THAT FIRST COMPARISON, THE POPULATION'S DIRECTION DECIDES WHICH RED IS PRINTED. A
- * population that held still or grew is what licenses the regression's sentence: nothing left the
- * scope, so the kills that vanished were lost. A population that SHRANK removes that licence, and
- * `population-shrank` says so rather than asserting it anyway — removing one killed mutant, and
- * removing one survivor beside a weakened assertion, move the two counts identically, and no
- * arithmetic over two whole numbers tells them apart (@SCN-RAT-016). Both readings are red and
- * both stop the gate; only the sentence differs, and the sentence is the whole point.
- *
- * AND THE SCORE HAS EXACTLY ONE JOB, WHICH IS THE SECOND COMPARISON AND NOT THE FIRST. Once the
- * kills are known to have held, the run either scored below what the record banked or it did not,
- * and only the first of those is a population that grew: a run whose kills ROSE far enough carries
- * its growth without any drop at all, and is an improvement rather than this. So the growth is not
- * what is asked about — the fallen score is, and the growth follows from it, because a run that
- * lost no kills can only score lower by measuring more mutants. That is the whole of what the score
- * is allowed to decide here, and it is why it is asked second (@SCN-RAT-006).
- *
- * THE FLOOR IS STATED, NEVER CONSULTED. `floorOf` is deliberately absent from every condition here.
- * It is the same bar expressed as a percentage, carried in the message because a reader arriving
- * from the sweep has a percentage in front of them and wants the bar in the units they are already
- * holding. The enforcement is the count comparison above it. The two agree exactly while the
- * population holds still and part company the moment it moves, so reading the floor AS the gate
- * would put the judgement back on the score — the confusion the counts model exists to prevent.
- *
- * NOTHING HERE NAMES A PROJECT, A CHECK, A RUNNER, A WORKFLOW OR A REPOSITORY. The gate's name
- * arrives on the record and on the measurement, both of them the caller's own words.
- */
-import { type GateRecord } from "./record.js";
-/**
- * One gate's measured run, in the same two counts the record is kept in.
- *
- * THE SAME PAIR AS THE RECORD, AND THAT IS WHAT MAKES THE COMPARISON POSSIBLE. A measurement that
- * arrived as a score would already have folded the two events this module exists to separate into
- * one number, before anything here could look at it.
- */
-export interface MutationMeasurement {
-    /** The gate this run measured, as the caller names it. */
-    readonly gate: string;
-    /** Mutants the suite detected. */
-    readonly detected: number;
-    /** Every mutant the gate measured, detected or not. */
-    readonly total: number;
-}
-/**
- * What a run turned out to be.
- *
- * `regression` IS THE ONE DECIDED ON KILLS, which is what makes it immune to the population moving,
- * and `within-slack` (@SCN-RAT-005) is its neighbour on the other side of the same comparison — the
- * two share one boundary and neither can pin it alone. `population-grew` (@SCN-RAT-006) is the third
- * built, and the first decided on anything but kills — it is the drop a bar shaped like a score
- * cannot express, and the reason the record keeps two counts rather than one. `unrecorded-improvement`
- * (@SCN-RAT-007) is the fourth, and the only RED one not decided on kills — it is the clause that
- * turns a ceiling into a ratchet, and without it every other arm here is a bar that quietly drifts
- * away from the tree it is meant to be holding. `at-baseline` (@SCN-RAT-008) is the fifth and the
- * one that CLOSES the set: it is what is left once those four have each declined a run, so from it
- * on there is no measurement this module can be handed that it cannot answer. `population-shrank`
- * (@SCN-RAT-016) is the sixth built and `population-grew`'s twin on the other side of the same
- * movement: it shares `regression`'s condition exactly and parts from it on the population's
- * direction alone, because the sentence `regression` is allowed to say is licensed by nothing
- * having left the scope. The last member sits
- * outside the comparison entirely — `no-measurement` (@SCN-RAT-009) is reached from a report that
- * holds nothing, before there are two counts to reconcile at all.
- */
-export type MutationVerdictKind = "no-measurement" | "regression" | "population-shrank" | "within-slack" | "population-grew" | "unrecorded-improvement" | "at-baseline";
-/**
- * A verdict: whether the run stands, and the line its reader gets.
- *
- * THE MESSAGE IS NOT DECORATION. A verdict that reds without saying which kills went missing, what
- * allowance they were measured against, and what to do next is a red somebody widens the bar to
- * clear, because widening is cheaper than a hunt with no starting point.
- */
-export interface MutationVerdict {
-    readonly kind: MutationVerdictKind;
-    /** Whether the run stands. */
-    readonly ok: boolean;
-    /** The line its reader gets, carrying every figure the verdict was reached from. */
-    readonly message: string;
-}
-/**
- * The refusal, as a verdict (@SCN-RAT-009, 3F-2800).
- *
- * IT SITS OUTSIDE `verdictFor` BECAUSE IT IS REACHED BEFORE THERE ARE COUNTS TO RECONCILE. Every
- * arm of that function compares two pairs of whole numbers; this one is what a caller has instead
- * of a pair, so handing it a fabricated one — a zero, most temptingly — would put a real verdict's
- * name on a run nobody measured.
- *
- * AND IT IS RED. A sweep that did not run produced no evidence about the tree, and a reconciler
- * that shrugs at no evidence reports success for a run that measured nothing: the build green, the
- * report absent, and the two facts never meeting.
- *
- * @param gate the gate that was to have been measured, as the caller names it
- * @param reason why there is no measurement, naming the path it was sought at
- */
-export declare function noMeasurement(gate: string, reason: string): MutationVerdict;
-/**
- * Reconcile one gate's run against the bar its record states.
- *
- * INSIDE THAT FIRST COMPARISON, `total` DECIDES WHICH RED IS PRINTED, AND IT IS ASKED THERE RATHER
- * THAN BESIDE IT. The kills must already have fallen past the allowance before the population's
- * direction is consulted at all, so a run that lost no kills is not either red however far its
- * population fell, and a run that lost a kill the allowance covers is the pass below whichever way
- * its population moved. What the direction settles is only which sentence a run that has already
- * failed on kills is told: held still or grew licenses `regression`'s claim that a mutant this
- * suite used to kill now survives, because nothing left the scope; SHRANK does not, and
- * `population-shrank` says the two look identical from here instead (@SCN-RAT-016).
- *
- * THE COUNT COMPARISON IS FIRST, AND IT IS ON `detected` ALONE. Everything below it in this
- * reconciler will be a question about the score, and the score cannot separate a lost kill from a
- * grown population — so the one verdict that must not be reachable through the score is settled
- * before the score is consulted at all. A run that loses kills and grows its population at the same
- * time is named as the regression it is, rather than as the growth that would explain it away.
- *
- * `floorOf` IS DELIBERATELY ABSENT FROM THIS CONDITION. It is the same bar as a percentage, carried
- * in the message for its reader; the enforcement is the comparison above. The two agree exactly
- * while the population holds still, so a reconciler judging on the floor greens every example of
- * this Rule and reds a grown population that lost nothing — which is the confusion the counts model
- * exists to prevent.
- *
- * THE SECOND COMPARISON IS THE SAME BOUNDARY FROM THE OTHER SIDE. A run that lost kills the
- * allowance covers is a pass, and `D == D0 - slack` is the last measurement it covers. The two arms
- * meet at that one mutant and neither pins it alone: every run the arm above judges is a regression
- * under `<` and `<=` alike, and under an allowance consulted or forgotten alike. It is the pass at
- * the boundary that reds a comparison widened by one, and the pass one kill inside it that reds a
- * comparison that dropped the allowance — which is why both examples are asserted and not one.
- *
- * THE THIRD COMPARISON IS THE FIRST ONE THE SCORE IS ALLOWED INTO, AND ONLY BECAUSE THE KILLS ARE
- * ALREADY KNOWN TO HAVE HELD. Below this line nothing that used to die is surviving, so a fallen
- * score has exactly one remaining cause — the run measured more mutants — and naming it is safe in
- * a way it was never safe above. The order is the guarantee: the same growth that explains a drop
- * here would have explained away a regression two comparisons ago, which is why it is not consulted
- * until there is no regression left for it to explain away.
- *
- * A RUN THAT LOST A KILL THE ALLOWANCE COVERS **WHILE** ITS POPULATION GREW IS THE ARM ABOVE, NOT
- * THIS ONE, and that is a ruling rather than an accident of ordering (@SCN-RAT-005 surfaced the
- * shape and asserted neither way; ruled on 2026-08-26 under @SCN-RAT-006). Its score can be far
- * below the floor, so the growth is there to be reached for. But this verdict's load-bearing
- * sentence is that no mutant which used to die now survives, and of that run the sentence is false;
- * answering with the growth would print it anyway. The allowance was also SPENT, and an allowance
- * spends in public or it does not spend at all — so the pass that must fire is the one naming the
- * kills lost and the record's own reason for tolerating them. Nothing is lost by the ruling: the
- * growth stays legible in the count pairs that pass already carries.
- *
- * AND THE LAST ARM TAKES NO CONDITION, WHICH IS WHAT MAKES THIS FUNCTION TOTAL (@SCN-RAT-008). The
- * three comparisons above leave exactly one case: kills that held, and a score that neither fell
- * nor rose. `scoreFellFrom` and `scoreRoseFrom` are the same two cross-multiplied products read the
- * two ways round, so between them they claim every inequality and EQUAL is what is left — and equal
- * is a fact about the ratio rather than about the pair, which is why the fall-through is written
- * with no condition at all. Narrowing it to "the same two counts" would leave a run of 4350/4486
- * against a record of 2175/2243 with no verdict, and a reconciler that can be handed a measurement
- * it does not answer is one whose callers must handle a case nobody named. There is no default
- * green here either: `at-baseline` is a verdict somebody wrote, with its own scenario and its own
- * message, not a shrug at the end of a chain of `if`s.
- *
- * @param record the gate's last-banked counts and the allowance stated against them
- * @param measurement the run being judged, in the same two counts
- * @param bankCommand the caller's own words for banking a measurement, carried into the verdicts
- *   that ask for it — never a script name this module invents (@SCN-RAT-006, 3F-2796)
- */
-export declare function verdictFor(record: GateRecord, measurement: MutationMeasurement, bankCommand: string): MutationVerdict;
-//# sourceMappingURL=verdict.d.ts.map

package/dist/mutation-ratchet/verdict.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"verdict.d.ts","sourceRoot":"","sources":["../../src/mutation-ratchet/verdict.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH,OAAO,EAOL,KAAK,UAAU,EAChB,MAAM,aAAa,CAAC;AAErB;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB;IAClC,0DAA0D;IAC1D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,kCAAkC;IAClC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,uDAAuD;IACvD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,mBAAmB,GAC3B,gBAAgB,GAChB,YAAY,GACZ,mBAAmB,GACnB,cAAc,GACd,iBAAiB,GACjB,wBAAwB,GACxB,aAAa,CAAC;AAElB;;;;;;GAMG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;IACnC,8BAA8B;IAC9B,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,oFAAoF;IACpF,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAkQD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,eAAe,CAW3E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,UAAU,EAClB,WAAW,EAAE,mBAAmB,EAChC,WAAW,EAAE,MAAM,GAClB,eAAe,CAgBjB"}