audit-tools 0.40.1 → 0.41.0

package/dist/audit/cli/laneSubmissions.js

@@ -0,0 +1,438 @@
+/**
+ * The audit draw of the shared submission core: how a GATE lane's bound path is
+ * computed, and where the expected-set / ledger for those lanes are persisted.
+ *
+ * Two facts about the audit gates shape everything here:
+ *
+ * 1. **They carry no run id.** `NextStepParams` has none, and threading one
+ *    into every gate would change ten signatures to carry a value the gates
+ *    never use. Their submissions are therefore ARTIFACTS-DIR-scoped: the
+ *    constant `AUDIT_GATE_SUBMISSION_SCOPE` stands in for run identity, so the
+ *    same gate lane in the same artifacts dir denotes the same submission
+ *    across `next-step` calls. That is not a shortcut — it is exactly the
+ *    K-of-N resume property, which requires a re-emitted step to re-declare
+ *    the identical bound path rather than mint a new one and re-ask for work
+ *    the host already delivered.
+ *
+ * 2. **The lane id is the only join key.** The emitter and the gate reader
+ *    never meet; they agree because both derive the id from the lane id
+ *    through this module. A lane id is declared once in
+ *    `HOST_GATE_DESCRIPTORS` and used verbatim on both sides.
+ *
+ * The bound path is DERIVED, not looked up. The persisted expected set states
+ * what is owed (and feeds the diff and the ledger), but a gate that could only
+ * read a submission when a bookkeeping file happened to exist would lose a
+ * valid submission the first time that file was absent — so derivation is the
+ * mechanism and the record is the record.
+ */
+import { z } from "zod";
+import { CharterKindSchema, absoluteSubmissionPath, buildExpectedSubmissionSet, diffExpectedSet, discardOnSchemaVersionMismatch, expectedSubmissionsPath, hashContent, mergeExpectedSets, mintSubmissionId, outputDirFor, readOptionalJsonFile, readSubmissionDocument, readSubmissionLedger, submissionsDir, withoutExpectedSubmissions, writeJsonFile, EXPECTED_SET_CONTRACT_VERSION, SUBMISSION_LEDGER_EVENT_CONTRACT_VERSION, appendSubmissionEvent, } from "audit-tools/shared";
+/**
+ * Gate lane ids — the single join key between an emitter and its gate reader.
+ *
+ * The two never meet: an emitter writes a lane's prompt and declares where the
+ * answer goes, and (possibly several `next-step` calls later) the gate reader
+ * looks for it. They agree because both derive the bound path from the lane id
+ * through this module. Declared once, here, so no site can spell a lane one way
+ * on the emit side and another on the read side.
+ */
+export const GATE_LANES = {
+    analyzer_consent: "analyzer_consent",
+    analyzer_decisions: "analyzer_decisions",
+    edge_reasoning: "edge_reasoning",
+    design_review_legacy: "design_review_legacy",
+    design_review_contract: "design_review_contract",
+    design_review_conceptual: "design_review_conceptual",
+    critical_flow_fallback: "critical_flow_fallback",
+    intent_equivalence: "intent_equivalence",
+    synthesis_narrative: "synthesis_narrative",
+    charter_delta: "charter_delta",
+    charter_clarification: "charter_clarification",
+    systemic_challenge: "systemic_challenge",
+};
+/** The blind per-kind charter lanes (one per estimator channel). */
+export function charterExtractionLane(kind) {
+    return `charter_extraction_${kind}`;
+}
+/** Recover the charter kind a `charter_extraction_*` lane id denotes. */
+export function charterKindForLane(lane) {
+    if (!lane.startsWith(CHARTER_EXTRACTION_LANE_PREFIX))
+        return undefined;
+    const parsed = CharterKindSchema.safeParse(lane.slice(CHARTER_EXTRACTION_LANE_PREFIX.length));
+    return parsed.success ? parsed.data : undefined;
+}
+const CHARTER_EXTRACTION_LANE_PREFIX = "charter_extraction_";
+export const CONCEPTUAL_PERSPECTIVE_LANE_PREFIX = "design_review_conceptual_p";
+/**
+ * The deep conceptual pass's independent perspective lanes. Their COUNT is
+ * resolved at emit from confirmed intent, so the ids are generated rather than
+ * enumerated.
+ *
+ * The id carries the ROUND — a digest of the upstream content the round asks
+ * about — because a perspective is the one lane class whose reuse is WRONG.
+ * Every other lane's identity is deliberately stable so a re-emitted step
+ * re-declares the same bound path (K-of-N resume); a perspective, though, is a
+ * fresh independent reading of the artifacts as they now stand. Keyed on the
+ * index alone, a re-review after staleness would find the PREVIOUS round's
+ * submission at the bound path, skip the lane, leave its prompt unrewritten,
+ * and hand the judge the old round's findings as if they were this round's.
+ * Same round, same digest, same id — so resume WITHIN a round still works.
+ */
+export function conceptualPerspectiveLane(index, roundToken) {
+    return `${CONCEPTUAL_PERSPECTIVE_LANE_PREFIX}${index}_${roundToken}`;
+}
+/**
+ * The round token every perspective lane in one deep conceptual emission
+ * shares: a digest of exactly what this round asks. Deterministic in its inputs
+ * — never a timestamp or a counter, which would mint new ids (and re-ask for
+ * already-delivered work) on every re-emission of an unchanged round.
+ */
+export function conceptualRoundToken(inputs) {
+    return hashContent(inputs.join("\n"), { length: 12 });
+}
+/**
+ * The per-kind evidence packet a charter lane reads. TOOL-written, so it lives
+ * under the lane-asset dir with the lane prompts — a host only ever reads it.
+ */
+export function charterExtractionPacketFilename(kind) {
+    return `charter-extraction-${kind}-packet.md`;
+}
+/**
+ * The tool-side merge of the per-kind charter lanes, handed to the extraction
+ * executor by path and deleted once ingested. Tool-written, so it is a lane
+ * asset and not a submission.
+ */
+export const CHARTER_EXTRACTION_MERGED_FILENAME = "charter-extraction-merged.json";
+/**
+ * The submission FAMILY every audit gate lane belongs to. Distinguishes these
+ * from the host-handoff work-item submissions, which mint through the same rule
+ * under their own run id.
+ */
+export const AUDIT_LANE_SUBMISSION_KIND = "audit_host_lane";
+/** See the module comment: the audit gates' stand-in for run identity. */
+export const AUDIT_GATE_SUBMISSION_SCOPE = "audit-host-gates";
+/**
+ * Bound paths for gate lanes are expressed relative to the artifact tree root
+ * (`.audit-tools/`), not the repository root: the gates are handed an artifacts
+ * dir and nothing else, and a recorded path must be derivable from exactly what
+ * the reader has.
+ */
+export function laneSubmissionRoots(artifactsDir) {
+    return {
+        root: outputDirFor(artifactsDir),
+        submissionDir: submissionsDir(artifactsDir),
+    };
+}
+/** The tool-minted id for one lane. Deterministic in the lane id alone. */
+export function laneSubmissionId(lane, runId = AUDIT_GATE_SUBMISSION_SCOPE) {
+    return mintSubmissionId({ kind: AUDIT_LANE_SUBMISSION_KIND, lane, runId });
+}
+/**
+ * Absolute on-disk path a lane's submission must land at.
+ *
+ * `runId` is threaded rather than defaulted-and-forgotten: the bound path and
+ * the recorded expectation must come from ONE derivation. They were two — the
+ * path taking the module constant while the record took the caller's scope —
+ * which coincided only because every caller happened to pass the constant, i.e.
+ * the invariant held by the caller remembering.
+ */
+export function laneSubmissionPath(artifactsDir, lane, runId = AUDIT_GATE_SUBMISSION_SCOPE) {
+    return absoluteSubmissionPath(laneSubmissionRoots(artifactsDir), laneSubmissionId(lane, runId));
+}
+/**
+ * The current statement of what is owed, or `undefined` when there isn't one.
+ *
+ * REGENERABLE state: the set is rewritten at every emit from the lanes the
+ * emission declares, so a set left by another release is DISCARDED rather than
+ * reinterpreted under this release's field semantics. The fail-shape is the one
+ * this reader already has for an absent file — the merge below starts from
+ * nothing, every declared lane counts as newly added, and the carried-lane diff
+ * therefore sees no prior entries and reports no shortfall. That is exactly
+ * right after an upgrade: nothing was carried into this emission that this
+ * release ever asked for, so the emission is first-emission-silent instead of
+ * accusing the host of dropping lanes it was never coherently asked for.
+ */
+async function loadExpectedSet(artifactsDir) {
+    try {
+        return discardOnSchemaVersionMismatch(await readOptionalJsonFile(expectedSubmissionsPath(artifactsDir)), EXPECTED_SET_CONTRACT_VERSION);
+    }
+    catch {
+        // Corrupt bookkeeping must never fail the emission it is recording; the
+        // merge below simply starts from nothing.
+        return undefined;
+    }
+}
+/**
+ * What a re-emission is still owed, stated by name.
+ *
+ * Persisted on the step contract and rendered into the step prompt, so "the
+ * host dropped a lane" is a fact the run REPORTS rather than one an operator
+ * has to infer from an identical step arriving twice.
+ */
+const OutstandingLaneSubmissionSchema = z
+    .object({
+    lane: z.string(),
+    submission_id: z.string(),
+    /**
+     * The tool-computed bound path, ABSOLUTE — the same form (and the same
+     * file) as the step's `access.write_paths` entry for this lane, so the two
+     * compare directly. Deliberately NOT the expected set's recorded form:
+     * that one is relative to the artifact tree root, a base the step contract
+     * declares nowhere, so a consumer joining it against `repo_root` or
+     * `artifacts_dir` would build a path that never existed. `extraFields` ride
+     * through `writeStepContract` un-normalized (only prompt_path / repo_root /
+     * artifacts_dir / artifact_paths are), exactly as `access` does.
+     */
+    submission_path: z.string(),
+    issue_code: z.string(),
+    message: z.string(),
+})
+    .strict();
+export const LaneSubmissionShortfallSchema = z
+    .object({
+    /** Lanes CARRIED into this emission (a prior emission already asked). */
+    expected: z.number().int(),
+    /** How many of those have a readable submission at their bound path. */
+    accepted: z.number().int(),
+    outstanding: z.array(OutstandingLaneSubmissionSchema),
+})
+    .strict();
+const NO_SHORTFALL = {
+    expected: 0,
+    accepted: 0,
+    outstanding: [],
+};
+/** Read every carried member's bound path once, for the diff below. */
+async function observeLanes(artifactsDir, entries) {
+    const roots = laneSubmissionRoots(artifactsDir);
+    return new Map(await Promise.all(entries.map(async (entry) => [
+        entry.submission_id,
+        await readSubmissionDocument(absoluteSubmissionPath(roots, entry.submission_id)),
+    ])));
+}
+/**
+ * Record what this emission owes, and report what a PREVIOUS one is still owed.
+ *
+ * Merges into the current statement (a step that materializes several lane
+ * groups accumulates them) and appends one `expected` event per NEWLY declared
+ * lane, so a re-emission does not spam the arrival record.
+ *
+ * The returned shortfall diffs only the lanes CARRIED into this emission — the
+ * ones an earlier emission already asked for and that are still not on disk.
+ * Restricting it to carried lanes is what makes the report meaningful: on a
+ * first emission every lane is legitimately absent (it is being asked for right
+ * now), so counting those would make every fan-out look like a failure.
+ */
+export async function recordExpectedLanes(artifactsDir, runId, lanes) {
+    if (lanes.length === 0)
+        return NO_SHORTFALL;
+    const declared = buildExpectedSubmissionSet({
+        runId,
+        paths: laneSubmissionRoots(artifactsDir),
+        lanes: lanes.map((lane) => ({
+            lane: lane.lane,
+            submissionId: laneSubmissionId(lane.lane, runId),
+            promptSha256: hashContent(lane.promptText),
+        })),
+    });
+    const { set, addedIds } = mergeExpectedSets(await loadExpectedSet(artifactsDir), declared);
+    await writeJsonFile(expectedSubmissionsPath(artifactsDir), set);
+    const added = new Set(addedIds);
+    for (const entry of set.entries) {
+        if (!added.has(entry.submission_id))
+            continue;
+        await appendSubmissionEvent(artifactsDir, {
+            contract_version: SUBMISSION_LEDGER_EVENT_CONTRACT_VERSION,
+            run_id: runId,
+            submission_id: entry.submission_id,
+            lane: entry.lane,
+            kind: "expected",
+            recorded_at: new Date().toISOString(),
+        });
+    }
+    const carried = {
+        ...declared,
+        entries: declared.entries.filter((entry) => !added.has(entry.submission_id)),
+    };
+    if (carried.entries.length === 0)
+        return NO_SHORTFALL;
+    const byId = new Map(carried.entries.map((entry) => [entry.submission_id, entry]));
+    const diff = diffExpectedSet(carried, await observeLanes(artifactsDir, carried.entries));
+    const outstanding = diff.members.flatMap((member) => member.status === "issue" ? [member] : []);
+    // A REFUSED lane also reads as ENOENT, because quarantining moves the file
+    // off the bound path and only an ACCEPTED lane is dropped from the set. The
+    // disk cannot tell the two apart, so the record does: without this, a host
+    // whose submission was received and rejected is told it "submitted nothing",
+    // which is false and points it at the wrong repair.
+    const refusals = outstanding.length > 0
+        ? await lastRefusals(artifactsDir, outstanding.map((member) => member.submission_id))
+        : new Map();
+    const roots = laneSubmissionRoots(artifactsDir);
+    return {
+        expected: diff.expected,
+        accepted: diff.accepted,
+        outstanding: outstanding.map((member) => {
+            const entry = byId.get(member.submission_id);
+            const lane = entry?.lane ?? member.submission_id;
+            const refusal = refusals.get(member.submission_id);
+            return {
+                lane,
+                submission_id: member.submission_id,
+                // Absolute, matching this step's `access.write_paths` entry — see the
+                // schema note; the expected set's own record stays artifact-relative.
+                submission_path: absoluteSubmissionPath(roots, member.submission_id),
+                issue_code: refusal ? "submission_rejected" : member.issue.code,
+                message: refusal
+                    ? `lane '${lane}' submitted, and the submission was refused` +
+                        `${refusal.message ? `: ${refusal.message}` : ""}` +
+                        " — fix it and resubmit at the bound path"
+                    : member.issue.message,
+            };
+        }),
+    };
+}
+/**
+ * The last ledger event per submission id, kept only where it is a REFUSAL.
+ * A later acceptance or hand recovery ends the refusal, so only the trailing
+ * state counts: this answers "is this lane outstanding BECAUSE it was refused",
+ * never "was it ever refused".
+ */
+async function lastRefusals(artifactsDir, submissionIds) {
+    const wanted = new Set(submissionIds);
+    const last = new Map();
+    for (const event of await readSubmissionLedger(artifactsDir)) {
+        if (!wanted.has(event.submission_id))
+            continue;
+        if (event.kind === "expected")
+            continue;
+        last.set(event.submission_id, event);
+    }
+    for (const [id, event] of [...last.entries()]) {
+        if (event.kind !== "rejected")
+            last.delete(id);
+    }
+    return last;
+}
+/** Merge the shortfalls of a step that materializes several lane groups. */
+export function mergeLaneShortfalls(shortfalls) {
+    return {
+        expected: shortfalls.reduce((total, one) => total + one.expected, 0),
+        accepted: shortfalls.reduce((total, one) => total + one.accepted, 0),
+        outstanding: shortfalls.flatMap((one) => one.outstanding),
+    };
+}
+/**
+ * The host-facing statement of an unmet expectation, by lane and issue code.
+ * Empty when nothing was carried or everything carried has arrived — a clean
+ * emission says nothing, so the notice's presence is itself the signal.
+ */
+export function renderLaneShortfallLines(shortfall) {
+    if (shortfall.outstanding.length === 0)
+        return [];
+    return [
+        "## Submissions still outstanding",
+        "",
+        `A previous emission asked for ${shortfall.expected} lane submission(s); ${shortfall.accepted} arrived. ` +
+            "These are still unsatisfied at the bound paths the tool declared — nothing was lost, and the paths are unchanged:",
+        "",
+        ...shortfall.outstanding.map((entry) => `- lane \`${entry.lane}\` (${entry.issue_code}): ${entry.message}`),
+        "",
+    ];
+}
+/**
+ * Record the outcome of one lane. An accepted lane stops being owed; a rejected
+ * one stays owed (the host is asked again) but the refusal is on the record
+ * with its reason, which is what makes a repaired run distinguishable from a
+ * clean one.
+ */
+export async function recordLaneOutcome(artifactsDir, lane, outcome) {
+    // ONE derivation of the scope: the id and the event's run field are the same
+    // value by construction, not two sites spelling the same constant.
+    const runId = AUDIT_GATE_SUBMISSION_SCOPE;
+    const submissionId = laneSubmissionId(lane, runId);
+    await appendSubmissionEvent(artifactsDir, {
+        contract_version: SUBMISSION_LEDGER_EVENT_CONTRACT_VERSION,
+        run_id: runId,
+        submission_id: submissionId,
+        lane,
+        kind: outcome.kind,
+        ...(outcome.kind === "rejected"
+            ? { issue_code: outcome.issueCode, message: outcome.message }
+            : {}),
+        ...(outcome.kind === "accepted" && outcome.message
+            ? { message: outcome.message }
+            : {}),
+        recorded_at: new Date().toISOString(),
+    });
+    if (outcome.kind !== "accepted")
+        return;
+    const set = await loadExpectedSet(artifactsDir);
+    if (!set)
+        return;
+    await writeJsonFile(expectedSubmissionsPath(artifactsDir), withoutExpectedSubmissions(set, [submissionId]));
+}
+/** How an event reads for dedupe: kind, code, and message, in one string. */
+function eventSignature(kind, issueCode, message) {
+    return [kind, issueCode ?? "", message ?? ""].join("|");
+}
+/**
+ * Record what the host-handoff ingest just decided about each work item, on the
+ * same ledger the gate lanes use — so a submission that never arrived (or
+ * arrived unreadable) is a durable fact rather than a value that died inside
+ * the call that computed it.
+ *
+ * Two rules keep the record drift-focused and arithmetically honest:
+ *
+ *   • Deduped against the LAST recorded event for each submission. Ingest runs
+ *     on every `next-step`, so a host still working through its workload would
+ *     otherwise append the same "missing" line every poll, burying the state
+ *     CHANGES the ledger exists to preserve. A changed classification still
+ *     appends, in arrival order.
+ *   • An acceptance is recorded ONLY where a refusal precedes it. A work item
+ *     the host got right first try says nothing (the ledger is not an inventory
+ *     of work), but one that was refused and later accepted must close its own
+ *     story — otherwise a run where every failure was repaired reports its
+ *     refusals with no matching repairs, and the report reads as a run that
+ *     never recovered.
+ */
+export async function recordHostResultOutcomes(artifactsDir, runId, outcomes) {
+    if (outcomes.issues.length === 0 && outcomes.acceptedIds.length === 0)
+        return;
+    const last = new Map();
+    for (const event of await readSubmissionLedger(artifactsDir)) {
+        last.set(event.submission_id, eventSignature(event.kind, event.issue_code, event.message));
+    }
+    const append = async (submissionId, event) => {
+        const signature = eventSignature(event.kind, event.issue_code, event.message);
+        if (last.get(submissionId) === signature)
+            return;
+        last.set(submissionId, signature);
+        await appendSubmissionEvent(artifactsDir, {
+            contract_version: SUBMISSION_LEDGER_EVENT_CONTRACT_VERSION,
+            run_id: runId,
+            submission_id: submissionId,
+            // A host work item's id IS its submission identity: the bound path is
+            // derived from it through the same rule the gate lanes use.
+            lane: submissionId,
+            ...event,
+            recorded_at: new Date().toISOString(),
+        });
+    };
+    for (const submissionId of outcomes.acceptedIds) {
+        // Nothing on the record for this item means it was clean on the first try.
+        if (!last.has(submissionId))
+            continue;
+        await append(submissionId, { kind: "accepted" });
+    }
+    for (const issue of outcomes.issues) {
+        const submissionId = issue.work_item_id ?? issue.submission_id;
+        if (submissionId === undefined)
+            continue;
+        await append(submissionId, {
+            kind: "rejected",
+            issue_code: issue.code,
+            message: issue.message,
+        });
+    }
+}
+//# sourceMappingURL=laneSubmissions.js.map

package/dist/audit/cli/laneSubmissions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"laneSubmissions.js","sourceRoot":"","sources":["../../../src/audit/cli/laneSubmissions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EACL,iBAAiB,EACjB,sBAAsB,EACtB,0BAA0B,EAC1B,eAAe,EACf,8BAA8B,EAC9B,uBAAuB,EACvB,WAAW,EACX,iBAAiB,EACjB,gBAAgB,EAChB,YAAY,EACZ,oBAAoB,EACpB,sBAAsB,EACtB,oBAAoB,EACpB,cAAc,EACd,0BAA0B,EAC1B,aAAa,EACb,6BAA6B,EAC7B,wCAAwC,EACxC,qBAAqB,GAStB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB,gBAAgB,EAAE,kBAAkB;IACpC,kBAAkB,EAAE,oBAAoB;IACxC,cAAc,EAAE,gBAAgB;IAChC,oBAAoB,EAAE,sBAAsB;IAC5C,sBAAsB,EAAE,wBAAwB;IAChD,wBAAwB,EAAE,0BAA0B;IACpD,sBAAsB,EAAE,wBAAwB;IAChD,kBAAkB,EAAE,oBAAoB;IACxC,mBAAmB,EAAE,qBAAqB;IAC1C,aAAa,EAAE,eAAe;IAC9B,qBAAqB,EAAE,uBAAuB;IAC9C,kBAAkB,EAAE,oBAAoB;CAChC,CAAC;AAEX,oEAAoE;AACpE,MAAM,UAAU,qBAAqB,CAAC,IAAiB;IACrD,OAAO,sBAAsB,IAAI,EAAE,CAAC;AACtC,CAAC;AAED,yEAAyE;AACzE,MAAM,UAAU,kBAAkB,CAAC,IAAY;IAC7C,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,8BAA8B,CAAC;QAAE,OAAO,SAAS,CAAC;IACvE,MAAM,MAAM,GAAG,iBAAiB,CAAC,SAAS,CACxC,IAAI,CAAC,KAAK,CAAC,8BAA8B,CAAC,MAAM,CAAC,CAClD,CAAC;IACF,OAAO,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;AAClD,CAAC;AAED,MAAM,8BAA8B,GAAG,qBAAqB,CAAC;AAE7D,MAAM,CAAC,MAAM,kCAAkC,GAAG,4BAA4B,CAAC;AAE/E;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,yBAAyB,CACvC,KAAa,EACb,UAAkB;IAElB,OAAO,GAAG,kCAAkC,GAAG,KAAK,IAAI,UAAU,EAAE,CAAC;AACvE,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,oBAAoB,CAAC,MAAyB;IAC5D,OAAO,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,CAAC;AACxD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,+BAA+B,CAAC,IAAiB;IAC/D,OAAO,sBAAsB,IAAI,YAAY,CAAC;AAChD,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,kCAAkC,GAAG,gCAAgC,CAAC;AAEnF;;;;GAIG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,iBAAiB,CAAC;AAE5D,0EAA0E;AAC1E,MAAM,CAAC,MAAM,2BAA2B,GAAG,kBAAkB,CAAC;AAE9D;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CAAC,YAAoB;IACtD,OAAO;QACL,IAAI,EAAE,YAAY,CAAC,YAAY,CAAC;QAChC,aAAa,EAAE,cAAc,CAAC,YAAY,CAAC;KAC5C,CAAC;AACJ,CAAC;AAED,2EAA2E;AAC3E,MAAM,UAAU,gBAAgB,CAC9B,IAAY,EACZ,QAAgB,2BAA2B;IAE3C,OAAO,gBAAgB,CAAC,EAAE,IAAI,EAAE,0BAA0B,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;AAC7E,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,kBAAkB,CAChC,YAAoB,EACpB,IAAY,EACZ,QAAgB,2BAA2B;IAE3C,OAAO,sBAAsB,CAC3B,mBAAmB,CAAC,YAAY,CAAC,EACjC,gBAAgB,CAAC,IAAI,EAAE,KAAK,CAAC,CAC9B,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,KAAK,UAAU,eAAe,CAC5B,YAAoB;IAEpB,IAAI,CAAC;QACH,OAAO,8BAA8B,CACnC,MAAM,oBAAoB,CACxB,uBAAuB,CAAC,YAAY,CAAC,CACtC,EACD,6BAA6B,CAC9B,CAAC;IACJ,CAAC;IAAC,MAAM,CAAC;QACP,wEAAwE;QACxE,0CAA0C;QAC1C,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC;AAQD;;;;;;GAMG;AACH,MAAM,+BAA+B,GAAG,CAAC;KACtC,MAAM,CAAC;IACN,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE;IACzB;;;;;;;;;OASG;IACH,eAAe,EAAE,CAAC,CAAC,MAAM,EAAE;IAC3B,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;IACtB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;CACpB,CAAC;KACD,MAAM,EAAE,CAAC;AAEZ,MAAM,CAAC,MAAM,6BAA6B,GAAG,CAAC;KAC3C,MAAM,CAAC;IACN,yEAAyE;IACzE,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE;IAC1B,wEAAwE;IACxE,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE;IAC1B,WAAW,EAAE,CAAC,CAAC,KAAK,CAAC,+BAA+B,CAAC;CACtD,CAAC;KACD,MAAM,EAAE,CAAC;AAIZ,MAAM,YAAY,GAA4B;IAC5C,QAAQ,EAAE,CAAC;IACX,QAAQ,EAAE,CAAC;IACX,WAAW,EAAE,EAAE;CAChB,CAAC;AAEF,uEAAuE;AACvE,KAAK,UAAU,YAAY,CACzB,YAAoB,EACpB,OAAsC;IAEtC,MAAM,KAAK,GAAG,mBAAmB,CAAC,YAAY,CAAC,CAAC;IAChD,OAAO,IAAI,GAAG,CACZ,MAAM,OAAO,CAAC,GAAG,CACf,OAAO,CAAC,GAAG,CACT,KAAK,EAAE,KAAK,EAAE,EAAE,CACd;QACE,KAAK,CAAC,aAAa;QACnB,MAAM,sBAAsB,CAC1B,sBAAsB,CAAC,KAAK,EAAE,KAAK,CAAC,aAAa,CAAC,CACnD;KACO,CACb,CACF,CACF,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACvC,YAAoB,EACpB,KAAa,EACb,KAA8B;IAE9B,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,YAAY,CAAC;IAC5C,MAAM,QAAQ,GAAG,0BAA0B,CAAC;QAC1C,KAAK;QACL,KAAK,EAAE,mBAAmB,CAAC,YAAY,CAAC;QACxC,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;YAC1B,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,YAAY,EAAE,gBAAgB,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC;YAChD,YAAY,EAAE,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC;SAC3C,CAAC,CAAC;KACJ,CAAC,CAAC;IACH,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,iBAAiB,CACzC,MAAM,eAAe,CAAC,YAAY,CAAC,EACnC,QAAQ,CACT,CAAC;IACF,MAAM,aAAa,CAAC,uBAAuB,CAAC,YAAY,CAAC,EAAE,GAAG,CAAC,CAAC;IAChE,MAAM,KAAK,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,CAAC;IAChC,KAAK,MAAM,KAAK,IAAI,GAAG,CAAC,OAAO,EAAE,CAAC;QAChC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,aAAa,CAAC;YAAE,SAAS;QAC9C,MAAM,qBAAqB,CAAC,YAAY,EAAE;YACxC,gBAAgB,EAAE,wCAAwC;YAC1D,MAAM,EAAE,KAAK;YACb,aAAa,EAAE,KAAK,CAAC,aAAa;YAClC,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,IAAI,EAAE,UAAU;YAChB,WAAW,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;SACtC,CAAC,CAAC;IACL,CAAC;IAED,MAAM,OAAO,GAA0B;QACrC,GAAG,QAAQ;QACX,OAAO,EAAE,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;KAC7E,CAAC;IACF,IAAI,OAAO,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,YAAY,CAAC;IACtD,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;IACnF,MAAM,IAAI,GAAG,eAAe,CAC1B,OAAO,EACP,MAAM,YAAY,CAAC,YAAY,EAAE,OAAO,CAAC,OAAO,CAAC,CAClD,CAAC;IACF,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE,CAClD,MAAM,CAAC,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,CAC1C,CAAC;IACF,2EAA2E;IAC3E,4EAA4E;IAC5E,2EAA2E;IAC3E,6EAA6E;IAC7E,oDAAoD;IACpD,MAAM,QAAQ,GACZ,WAAW,CAAC,MAAM,GAAG,CAAC;QACpB,CAAC,CAAC,MAAM,YAAY,CAChB,YAAY,EACZ,WAAW,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,aAAa,CAAC,CAClD;QACH,CAAC,CAAC,IAAI,GAAG,EAAiC,CAAC;IAC/C,MAAM,KAAK,GAAG,mBAAmB,CAAC,YAAY,CAAC,CAAC;IAChD,OAAO;QACL,QAAQ,EAAE,IAAI,CAAC,QAAQ;QACvB,QAAQ,EAAE,IAAI,CAAC,QAAQ;QACvB,WAAW,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE;YACtC,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;YAC7C,MAAM,IAAI,GAAG,KAAK,EAAE,IAAI,IAAI,MAAM,CAAC,aAAa,CAAC;YACjD,MAAM,OAAO,GAAG,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;YACnD,OAAO;gBACL,IAAI;gBACJ,aAAa,EAAE,MAAM,CAAC,aAAa;gBACnC,sEAAsE;gBACtE,sEAAsE;gBACtE,eAAe,EAAE,sBAAsB,CAAC,KAAK,EAAE,MAAM,CAAC,aAAa,CAAC;gBACpE,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC,qBAAqB,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI;gBAC/D,OAAO,EAAE,OAAO;oBACd,CAAC,CAAC,SAAS,IAAI,6CAA6C;wBAC1D,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE;wBAClD,0CAA0C;oBAC5C,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO;aACzB,CAAC;QACJ,CAAC,CAAC;KACH,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,KAAK,UAAU,YAAY,CACzB,YAAoB,EACpB,aAAgC;IAEhC,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,aAAa,CAAC,CAAC;IACtC,MAAM,IAAI,GAAG,IAAI,GAAG,EAAiC,CAAC;IACtD,KAAK,MAAM,KAAK,IAAI,MAAM,oBAAoB,CAAC,YAAY,CAAC,EAAE,CAAC;QAC7D,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,aAAa,CAAC;YAAE,SAAS;QAC/C,IAAI,KAAK,CAAC,IAAI,KAAK,UAAU;YAAE,SAAS;QACxC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC;IACvC,CAAC;IACD,KAAK,MAAM,CAAC,EAAE,EAAE,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC;QAC9C,IAAI,KAAK,CAAC,IAAI,KAAK,UAAU;YAAE,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;IACjD,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED,4EAA4E;AAC5E,MAAM,UAAU,mBAAmB,CACjC,UAA8C;IAE9C,OAAO;QACL,QAAQ,EAAE,UAAU,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,CAAC,KAAK,GAAG,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAC;QACpE,QAAQ,EAAE,UAAU,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,CAAC,KAAK,GAAG,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAC;QACpE,WAAW,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,WAAW,CAAC;KAC1D,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,wBAAwB,CACtC,SAAkC;IAElC,IAAI,SAAS,CAAC,WAAW,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IAClD,OAAO;QACL,kCAAkC;QAClC,EAAE;QACF,iCAAiC,SAAS,CAAC,QAAQ,wBAAwB,SAAS,CAAC,QAAQ,YAAY;YACvG,mHAAmH;QACrH,EAAE;QACF,GAAG,SAAS,CAAC,WAAW,CAAC,GAAG,CAC1B,CAAC,KAAK,EAAE,EAAE,CAAC,YAAY,KAAK,CAAC,IAAI,OAAO,KAAK,CAAC,UAAU,MAAM,KAAK,CAAC,OAAO,EAAE,CAC9E;QACD,EAAE;KACH,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,YAAoB,EACpB,IAAY,EACZ,OAMK;IAEL,6EAA6E;IAC7E,mEAAmE;IACnE,MAAM,KAAK,GAAG,2BAA2B,CAAC;IAC1C,MAAM,YAAY,GAAG,gBAAgB,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACnD,MAAM,qBAAqB,CAAC,YAAY,EAAE;QACxC,gBAAgB,EAAE,wCAAwC;QAC1D,MAAM,EAAE,KAAK;QACb,aAAa,EAAE,YAAY;QAC3B,IAAI;QACJ,IAAI,EAAE,OAAO,CAAC,IAAI;QAClB,GAAG,CAAC,OAAO,CAAC,IAAI,KAAK,UAAU;YAC7B,CAAC,CAAC,EAAE,UAAU,EAAE,OAAO,CAAC,SAAS,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE;YAC7D,CAAC,CAAC,EAAE,CAAC;QACP,GAAG,CAAC,OAAO,CAAC,IAAI,KAAK,UAAU,IAAI,OAAO,CAAC,OAAO;YAChD,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE;YAC9B,CAAC,CAAC,EAAE,CAAC;QACP,WAAW,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;KACtC,CAAC,CAAC;IACH,IAAI,OAAO,CAAC,IAAI,KAAK,UAAU;QAAE,OAAO;IACxC,MAAM,GAAG,GAAG,MAAM,eAAe,CAAC,YAAY,CAAC,CAAC;IAChD,IAAI,CAAC,GAAG;QAAE,OAAO;IACjB,MAAM,aAAa,CACjB,uBAAuB,CAAC,YAAY,CAAC,EACrC,0BAA0B,CAAC,GAAG,EAAE,CAAC,YAAY,CAAC,CAAC,CAChD,CAAC;AACJ,CAAC;AAED,6EAA6E;AAC7E,SAAS,cAAc,CACrB,IAAY,EACZ,SAA6B,EAC7B,OAA2B;IAE3B,OAAO,CAAC,IAAI,EAAE,SAAS,IAAI,EAAE,EAAE,OAAO,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAC1D,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,KAAK,UAAU,wBAAwB,CAC5C,YAAoB,EACpB,KAAa,EACb,QAIC;IAED,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC,IAAI,QAAQ,CAAC,WAAW,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO;IAC9E,MAAM,IAAI,GAAG,IAAI,GAAG,EAAkB,CAAC;IACvC,KAAK,MAAM,KAAK,IAAI,MAAM,oBAAoB,CAAC,YAAY,CAAC,EAAE,CAAC;QAC7D,IAAI,CAAC,GAAG,CACN,KAAK,CAAC,aAAa,EACnB,cAAc,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,OAAO,CAAC,CAC5D,CAAC;IACJ,CAAC;IACD,MAAM,MAAM,GAAG,KAAK,EAClB,YAAoB,EACpB,KAGC,EACc,EAAE;QACjB,MAAM,SAAS,GAAG,cAAc,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;QAC9E,IAAI,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,KAAK,SAAS;YAAE,OAAO;QACjD,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,SAAS,CAAC,CAAC;QAClC,MAAM,qBAAqB,CAAC,YAAY,EAAE;YACxC,gBAAgB,EAAE,wCAAwC;YAC1D,MAAM,EAAE,KAAK;YACb,aAAa,EAAE,YAAY;YAC3B,sEAAsE;YACtE,4DAA4D;YAC5D,IAAI,EAAE,YAAY;YAClB,GAAG,KAAK;YACR,WAAW,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;SACtC,CAAC,CAAC;IACL,CAAC,CAAC;IAEF,KAAK,MAAM,YAAY,IAAI,QAAQ,CAAC,WAAW,EAAE,CAAC;QAChD,2EAA2E;QAC3E,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC;YAAE,SAAS;QACtC,MAAM,MAAM,CAAC,YAAY,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC,CAAC;IACnD,CAAC;IACD,KAAK,MAAM,KAAK,IAAI,QAAQ,CAAC,MAAM,EAAE,CAAC;QACpC,MAAM,YAAY,GAAG,KAAK,CAAC,YAAY,IAAI,KAAK,CAAC,aAAa,CAAC;QAC/D,IAAI,YAAY,KAAK,SAAS;YAAE,SAAS;QACzC,MAAM,MAAM,CAAC,YAAY,EAAE;YACzB,IAAI,EAAE,UAAU;YAChB,UAAU,EAAE,KAAK,CAAC,IAAI;YACtB,OAAO,EAAE,KAAK,CAAC,OAAO;SACvB,CAAC,CAAC;IACL,CAAC;AACH,CAAC"}

package/dist/audit/cli/laneValidators.d.ts

@@ -0,0 +1,65 @@
+/**
+ * The ONE registry of what a lane's submission must satisfy.
+ *
+ * Every gate validated its submission inline, which was fine while the only
+ * reader was the gate itself. The hand-recovery verb is a SECOND reader of the
+ * same contract, and a second reader is exactly where a weaker copy grows: an
+ * operator rescue that skipped the schema would be a door into the tool the
+ * normal lane does not have. So the rule lives here once, and both the gate and
+ * `recover-submission` resolve it from this table.
+ *
+ * Two shapes of rule, because two shapes of lane exist: those whose contract IS
+ * a zod schema, and those whose contract is a tolerated JSON shape (an array of
+ * findings, a decisions map). Both are expressed as the same
+ * `SubmissionIssue | null` validator so a caller never has to know which.
+ */
+import type { ZodTypeAny } from "zod";
+import { type CharterKind, type SubmissionIssue } from "audit-tools/shared";
+/** Human-readable description of why a submission is neither an array nor a single-array-wrapped object. */
+export declare function describeSubmissionShapeMismatch(value: unknown): string;
+/**
+ * The single tolerant-unwrap rule: a bare array is accepted as-is; a top-level
+ * object wrapping exactly one array-valued property is unambiguous and is
+ * accepted as that array. Anything else fails with a shape description.
+ * Single-sourced so the design-review gate, the edge-reasoning gate, and the
+ * recovery verb cannot drift on what shapes are accepted.
+ */
+export declare function unwrapSubmissionArray(value: unknown): {
+    ok: true;
+    array: unknown[];
+} | {
+    ok: false;
+    reason: string;
+};
+/** True for a plain top-level key → value map (the decisions-file shape). */
+export declare function isSubmissionObjectMap(value: unknown): value is Record<string, unknown>;
+/**
+ * The charter lane schema: the submission shape PLUS the two refinements that
+ * make a blind lane trustworthy — kind purity (a lane may only carry its own
+ * kind; anything else is a mis-routed submission) and scope grounding (a
+ * teleology node citing files the repo does not contain is refused whole,
+ * naming them, never silently narrowed).
+ *
+ * `repoFiles` is the manifest's path set. It is a parameter rather than a
+ * capture so the gate and the recovery verb apply the identical refinement
+ * against the identical universe.
+ */
+export declare function charterLaneSchema(kind: CharterKind, repoFiles: ReadonlySet<string>): ZodTypeAny;
+/**
+ * Lanes whose contract is a zod schema, keyed by lane id. The gate descriptors
+ * read this table; so does the recovery verb.
+ */
+export declare const LANE_SUBMISSION_SCHEMAS: Readonly<Record<string, ZodTypeAny>>;
+/** What the recovery verb needs in order to apply the FULL lane contract. */
+export interface LaneValidationContext {
+    /** The repo manifest's path set — the charter lanes' scope grounding. */
+    readonly repoFiles: ReadonlySet<string>;
+}
+/**
+ * The validator the normal lane applies to `lane`, or `null` when the lane id
+ * is not one this tool knows. Callers that cannot supply a validator must
+ * REFUSE rather than accept — an unknown lane has no contract to check against,
+ * and "no contract" must never read as "passes".
+ */
+export declare function laneSubmissionValidator(lane: string, context: LaneValidationContext): ((value: unknown) => SubmissionIssue | null) | null;
+//# sourceMappingURL=laneValidators.d.ts.map

package/dist/audit/cli/laneValidators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"laneValidators.d.ts","sourceRoot":"","sources":["../../../src/audit/cli/laneValidators.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,KAAK,CAAC;AAEtC,OAAO,EAOL,KAAK,WAAW,EAChB,KAAK,eAAe,EACrB,MAAM,oBAAoB,CAAC;AAQ5B,4GAA4G;AAC5G,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAiBtE;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,OAAO,GACb;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,OAAO,EAAE,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAShE;AAED,6EAA6E;AAC7E,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAElC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,WAAW,EACjB,SAAS,EAAE,WAAW,CAAC,MAAM,CAAC,GAC7B,UAAU,CAsBZ;AAED;;;GAGG;AACH,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAOxE,CAAC;AA6BF,6EAA6E;AAC7E,MAAM,WAAW,qBAAqB;IACpC,yEAAyE;IACzE,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACzC;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,qBAAqB,GAC7B,CAAC,CAAC,KAAK,EAAE,OAAO,KAAK,eAAe,GAAG,IAAI,CAAC,GAAG,IAAI,CA4BrD"}