audit-tools 0.52.4 → 0.53.0

package/dist/remediate/contractPipeline/counterexampleFingerprint.js

@@ -1,37 +0,0 @@
-/**
- * Content fingerprint for a counterexample.
- *
- * The judge↔repair convergence gate ({@link evaluateJudgeGate} in
- * `../steps/contractPipeline.js`) must detect genuine re-occurrence of the
- * same unrepaired defect across independent adversarial rounds. The
- * reviewer-supplied counterexample `id` is free text (see
- * `Counterexample.id` in `audit-tools/shared`'s obligations types) and is NOT
- * a stable cross-round identity: two independent critic rounds each commonly
- * label their genuinely-distinct top counterexample "CE-001" (the prompt
- * schema's own example value). Keying convergence on the raw id string then
- * misreads "two different CEs that happen to share a label" as "the same CE
- * re-accepted after a repair" and falsely escalates a stall while a real new
- * defect is being correctly repaired.
- *
- * This fingerprint keys on CONTENT instead: the tool-constrained
- * `violated_obligation_ids` vocabulary (sorted, normalized) paired with the
- * normalized `claim` prose, falling back to the normalized claim alone when
- * no obligations are cited. Mirrors the derivation style of
- * `src/shared/findingIdentitySignature.ts` (tiered stable fields, aggressive
- * title normalization, truncated content hash) rather than introducing a
- * second identity convention.
- */
-import { hashContent, normalizeTitle } from "audit-tools/shared";
-/** Deterministic, content-derived identity for a counterexample. */
-export function counterexampleFingerprint(ce) {
-    const obligations = (ce.violated_obligation_ids ?? [])
-        .map((id) => id.trim().toLowerCase())
-        .filter((id) => id.length > 0)
-        .sort();
-    const claim = normalizeTitle(ce.claim);
-    const key = obligations.length > 0
-        ? `obligations|${obligations.join(",")}|${claim}`
-        : `claim|${claim}`;
-    return hashContent(key, { length: 8 });
-}
-//# sourceMappingURL=counterexampleFingerprint.js.map

package/dist/remediate/contractPipeline/counterexampleFingerprint.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"counterexampleFingerprint.js","sourceRoot":"","sources":["../../../src/remediate/contractPipeline/counterexampleFingerprint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,EAAE,WAAW,EAAE,cAAc,EAAuB,MAAM,oBAAoB,CAAC;AAEtF,oEAAoE;AACpE,MAAM,UAAU,yBAAyB,CAAC,EAAkB;IAC1D,MAAM,WAAW,GAAG,CAAC,EAAE,CAAC,uBAAuB,IAAI,EAAE,CAAC;SACnD,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;SACpC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC;SAC7B,IAAI,EAAE,CAAC;IACV,MAAM,KAAK,GAAG,cAAc,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;IACvC,MAAM,GAAG,GACP,WAAW,CAAC,MAAM,GAAG,CAAC;QACpB,CAAC,CAAC,eAAe,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,KAAK,EAAE;QACjD,CAAC,CAAC,SAAS,KAAK,EAAE,CAAC;IACvB,OAAO,WAAW,CAAC,GAAG,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC;AACzC,CAAC"}

package/dist/remediate/contractPipeline/cyclicSeamResolution.d.ts

@@ -1,131 +0,0 @@
-/**
- * Cyclic-seam resolution: deterministic cycle detection over module seam
- * obligations, plus a re-check helper that validates a proposed cycle-break
- * does not re-introduce a cycle.
- *
- * A "seam obligation" is any module that declares an interface obligation
- * (via neighbor_needs / inputs / outputs) that depends on a type or interface
- * owned by another module.  For the purposes of this detector, a module M
- * is said to need module N when M lists N in its `needs` array.
- *
- * Detection is the shared directed-cycle core's exact strongly-connected-
- * component membership (`audit-tools/shared` → `findCyclicComponents`).  Each
- * cyclic component is reported as one detected cycle.
- */
-/** A module node in the seam-obligation graph. */
-export interface SeamObligationNode {
-    /** Unique module identifier. */
-    id: string;
-    /** IDs of modules this module declares an interface obligation toward. */
-    needs: string[];
-}
-/**
- * One detected cycle (N ≥ 1 nodes — a module that needs ITSELF is a 1-member
- * cycle; every other cycle has 2 or more members).
- */
-export interface DetectedCycle {
-    /** Module IDs that form the cycle, in input order (not in cycle order). */
-    members: string[];
-}
-/** A proposed mediator module that breaks a cycle. */
-export interface ProposedMediator {
-    /** Module ID for the new mediator. */
-    id: string;
-    /** Modules the mediator itself needs (must not form a new cycle). */
-    needs: string[];
-}
-/** Result of a cycle-break re-check. */
-export interface CycleBreakValidation {
-    accepted: boolean;
-    /** Present only when accepted === false. */
-    reason?: string;
-}
-/**
- * The break a worker ACTUALLY authored, read off the `cyclic_seam_resolution`
- * record rather than fabricated by the re-checker.
- *
- * Both sanctioned strategies designate a REAL node: `mediator` names a third
- * obligation that now owns the shared primitive, `single_authority` names the
- * one cycle member that keeps the interface. A record that designates nothing
- * cannot be validated against the real graph at all — see
- * {@link validateAuthoredCycleBreak}, which refuses it rather than inventing a
- * placeholder.
- */
-export interface AuthoredCycleBreak {
-    /** `break_strategy` from the resolution record. */
-    strategy: "mediator" | "single_authority";
-    /** The obligation id the record designates, when it named one. */
-    designatedId?: string;
-}
-/**
- * Detect cyclic seam obligations in a module graph.
- *
- * Membership is EXACT: each reported cycle is one strongly connected component
- * of the (module → modules it needs) graph. Two properties follow, and both
- * differ from the Kahn drain this replaced:
- *
- *  - a module DOWNSTREAM of a cycle (it needs a member, no member needs it) is
- *    not a member and is not reported — the drain reported every node it could
- *    not drain, tails included;
- *  - two cycles CHAINED by an edge between them are two cycles, not one — the
- *    drain's weakly-connected grouping fused them.
- *
- * A module that needs ITSELF is reported as a 1-member cycle.
- *
- * Returns an empty array when no cycle is found.
- */
-export declare function detectCyclicSeamObligations(nodes: SeamObligationNode[]): DetectedCycle[];
-/**
- * Validate a proposed cycle-break by re-running cycle detection on the
- * graph after the break is applied.
- *
- * The break modifies the original graph as follows:
- * - Remove every `needs` edge between original cycle members that crossed the
- *   cycle (both sides still appear in the graph with their original non-cycle
- *   needs intact).
- * - Add the `proposedMediator` as a new node.
- * - For each original cycle member, replace any needs-edge that pointed to
- *   another cycle member with a needs-edge to the mediator.
- *
- * If the resulting graph still contains a cycle, the proposed break is
- * rejected.
- *
- * The mediator appears EXACTLY ONCE in the patched graph. When it is already a
- * node of `allNodes` — which is the live feed from
- * {@link validateAuthoredCycleBreak}, where the mediator is a real obligation —
- * its own entry carries the proposed needs instead of a second entry with the
- * same id being appended.
- */
-export declare function validateCycleBreak(originalCycle: DetectedCycle, allNodes: SeamObligationNode[], proposedMediator: ProposedMediator): CycleBreakValidation;
-/**
- * Re-check a cycle-break AS AUTHORED, against the REAL obligation graph.
- *
- * The distinction from {@link validateCycleBreak} is the whole point: that
- * function asks a HYPOTHETICAL — "if the intra-cycle edges were redirected to
- * this proposed node, would the graph be acyclic?" — and its caller used to
- * answer it with a node it had fabricated itself (`{ id: "_mediator_A_B",
- * needs: [] }`) against the UNMODIFIED ledger. An edge-free sink absorbs every
- * redirected edge, so for a single detected cycle that question is acyclic BY
- * CONSTRUCTION and the re-check could never reject — a worker could claim
- * `status: "resolved"` while leaving the ledger's cycle edges exactly as they
- * were, and the pipeline advanced.
- *
- * This function asks the REAL question instead: does the graph the pipeline
- * will actually consume still carry the cycle? The break is accepted only when
- *
- *   1. the record designates a node (a break with no designated owner is not a
- *      break, it is a claim), and that node EXISTS in the live graph;
- *   2. the strategy and the designated node agree — a mediator is a THIRD node
- *      outside the cycle, a single authority is one of the cycle's own members;
- *   3. the live graph no longer contains a cycle touching the original members
- *      — i.e. the break is reflected in the edges, not just asserted in prose;
- *   4. and, for the mediator strategy, redirecting the cycle's edges at the
- *      mediator's REAL `needs` (never a fabricated empty set) stays acyclic, so
- *      a mediator that itself depends back into the cycle is refused.
- *
- * `currentNodes` must be built from the obligation ledger as it stands NOW, on
- * this invocation, after ingestion and the staleness-archive pass — a stale
- * snapshot would reintroduce exactly the vacuity this closes.
- */
-export declare function validateAuthoredCycleBreak(originalCycle: DetectedCycle, currentNodes: SeamObligationNode[], authored: AuthoredCycleBreak): CycleBreakValidation;
-//# sourceMappingURL=cyclicSeamResolution.d.ts.map

package/dist/remediate/contractPipeline/cyclicSeamResolution.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cyclicSeamResolution.d.ts","sourceRoot":"","sources":["../../../src/remediate/contractPipeline/cyclicSeamResolution.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAMH,kDAAkD;AAClD,MAAM,WAAW,kBAAkB;IACjC,gCAAgC;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,0EAA0E;IAC1E,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,2EAA2E;IAC3E,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,sDAAsD;AACtD,MAAM,WAAW,gBAAgB;IAC/B,sCAAsC;IACtC,EAAE,EAAE,MAAM,CAAC;IACX,qEAAqE;IACrE,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,wCAAwC;AACxC,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,OAAO,CAAC;IAClB,4CAA4C;IAC5C,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,kBAAkB;IACjC,mDAAmD;IACnD,QAAQ,EAAE,UAAU,GAAG,kBAAkB,CAAC;IAC1C,kEAAkE;IAClE,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAID;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,kBAAkB,EAAE,GAC1B,aAAa,EAAE,CAMjB;AAID;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,kBAAkB,CAChC,aAAa,EAAE,aAAa,EAC5B,QAAQ,EAAE,kBAAkB,EAAE,EAC9B,gBAAgB,EAAE,gBAAgB,GACjC,oBAAoB,CA6CtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,0BAA0B,CACxC,aAAa,EAAE,aAAa,EAC5B,YAAY,EAAE,kBAAkB,EAAE,EAClC,QAAQ,EAAE,kBAAkB,GAC3B,oBAAoB,CAoJtB"}

package/dist/remediate/contractPipeline/cyclicSeamResolution.js

@@ -1,257 +0,0 @@
-/**
- * Cyclic-seam resolution: deterministic cycle detection over module seam
- * obligations, plus a re-check helper that validates a proposed cycle-break
- * does not re-introduce a cycle.
- *
- * A "seam obligation" is any module that declares an interface obligation
- * (via neighbor_needs / inputs / outputs) that depends on a type or interface
- * owned by another module.  For the purposes of this detector, a module M
- * is said to need module N when M lists N in its `needs` array.
- *
- * Detection is the shared directed-cycle core's exact strongly-connected-
- * component membership (`audit-tools/shared` → `findCyclicComponents`).  Each
- * cyclic component is reported as one detected cycle.
- */
-import { findCyclicComponents } from "audit-tools/shared";
-// ── Cycle detection ───────────────────────────────────────────────────────────
-/**
- * Detect cyclic seam obligations in a module graph.
- *
- * Membership is EXACT: each reported cycle is one strongly connected component
- * of the (module → modules it needs) graph. Two properties follow, and both
- * differ from the Kahn drain this replaced:
- *
- *  - a module DOWNSTREAM of a cycle (it needs a member, no member needs it) is
- *    not a member and is not reported — the drain reported every node it could
- *    not drain, tails included;
- *  - two cycles CHAINED by an edge between them are two cycles, not one — the
- *    drain's weakly-connected grouping fused them.
- *
- * A module that needs ITSELF is reported as a 1-member cycle.
- *
- * Returns an empty array when no cycle is found.
- */
-export function detectCyclicSeamObligations(nodes) {
-    const components = findCyclicComponents(nodes.map((node) => ({ id: node.id, depends_on: node.needs })), { includeSelfLoops: true });
-    return components.map((members) => ({ members }));
-}
-// ── Cycle-break re-check ──────────────────────────────────────────────────────
-/**
- * Validate a proposed cycle-break by re-running cycle detection on the
- * graph after the break is applied.
- *
- * The break modifies the original graph as follows:
- * - Remove every `needs` edge between original cycle members that crossed the
- *   cycle (both sides still appear in the graph with their original non-cycle
- *   needs intact).
- * - Add the `proposedMediator` as a new node.
- * - For each original cycle member, replace any needs-edge that pointed to
- *   another cycle member with a needs-edge to the mediator.
- *
- * If the resulting graph still contains a cycle, the proposed break is
- * rejected.
- *
- * The mediator appears EXACTLY ONCE in the patched graph. When it is already a
- * node of `allNodes` — which is the live feed from
- * {@link validateAuthoredCycleBreak}, where the mediator is a real obligation —
- * its own entry carries the proposed needs instead of a second entry with the
- * same id being appended.
- */
-export function validateCycleBreak(originalCycle, allNodes, proposedMediator) {
-    const cycleSet = new Set(originalCycle.members);
-    // Build the patched node list:
-    // - For each cycle member: replace needs-edges to other cycle members with
-    //   a needs-edge to the mediator.
-    // - For non-cycle members: unchanged.
-    // - Add the mediator, unless the graph already carries a node with its id.
-    const patched = [];
-    const mediatorAlreadyPresent = allNodes.some((node) => node.id === proposedMediator.id);
-    for (const node of allNodes) {
-        if (node.id === proposedMediator.id) {
-            // The mediator's own entry — carry the proposed needs here rather than
-            // appending a second node with the same id below.
-            patched.push({ id: node.id, needs: [...proposedMediator.needs] });
-        }
-        else if (cycleSet.has(node.id)) {
-            const newNeeds = node.needs.map((dep) => cycleSet.has(dep) ? proposedMediator.id : dep);
-            // Deduplicate mediator references.
-            patched.push({ id: node.id, needs: [...new Set(newNeeds)] });
-        }
-        else {
-            patched.push(node);
-        }
-    }
-    // Add the mediator itself, unless the live graph already carries it.
-    if (!mediatorAlreadyPresent) {
-        patched.push({ id: proposedMediator.id, needs: proposedMediator.needs });
-    }
-    const remaining = detectCyclicSeamObligations(patched);
-    if (remaining.length > 0) {
-        const affectedIds = remaining.flatMap((c) => c.members).join(", ");
-        return {
-            accepted: false,
-            reason: `Proposed mediator "${proposedMediator.id}" still leaves cycle(s) involving: [${affectedIds}].`,
-        };
-    }
-    return { accepted: true };
-}
-/**
- * Re-check a cycle-break AS AUTHORED, against the REAL obligation graph.
- *
- * The distinction from {@link validateCycleBreak} is the whole point: that
- * function asks a HYPOTHETICAL — "if the intra-cycle edges were redirected to
- * this proposed node, would the graph be acyclic?" — and its caller used to
- * answer it with a node it had fabricated itself (`{ id: "_mediator_A_B",
- * needs: [] }`) against the UNMODIFIED ledger. An edge-free sink absorbs every
- * redirected edge, so for a single detected cycle that question is acyclic BY
- * CONSTRUCTION and the re-check could never reject — a worker could claim
- * `status: "resolved"` while leaving the ledger's cycle edges exactly as they
- * were, and the pipeline advanced.
- *
- * This function asks the REAL question instead: does the graph the pipeline
- * will actually consume still carry the cycle? The break is accepted only when
- *
- *   1. the record designates a node (a break with no designated owner is not a
- *      break, it is a claim), and that node EXISTS in the live graph;
- *   2. the strategy and the designated node agree — a mediator is a THIRD node
- *      outside the cycle, a single authority is one of the cycle's own members;
- *   3. the live graph no longer contains a cycle touching the original members
- *      — i.e. the break is reflected in the edges, not just asserted in prose;
- *   4. and, for the mediator strategy, redirecting the cycle's edges at the
- *      mediator's REAL `needs` (never a fabricated empty set) stays acyclic, so
- *      a mediator that itself depends back into the cycle is refused.
- *
- * `currentNodes` must be built from the obligation ledger as it stands NOW, on
- * this invocation, after ingestion and the staleness-archive pass — a stale
- * snapshot would reintroduce exactly the vacuity this closes.
- */
-export function validateAuthoredCycleBreak(originalCycle, currentNodes, authored) {
-    const members = originalCycle.members;
-    const cycleSet = new Set(members);
-    const designatedId = authored.designatedId?.trim();
-    if (!designatedId) {
-        return {
-            accepted: false,
-            reason: `The ${authored.strategy} break for cycle [${members.join(", ")}] names no obligation. ` +
-                `A mediator break must name the mediating obligation and a single_authority break must ` +
-                `name the owning obligation, or there is nothing to re-check against the ledger.`,
-        };
-    }
-    const designated = currentNodes.find((node) => node.id === designatedId);
-    if (!designated) {
-        return {
-            accepted: false,
-            reason: `The ${authored.strategy} break for cycle [${members.join(", ")}] names "${designatedId}", ` +
-                `which is not an obligation in the ledger. The break must be recorded in the ledger the ` +
-                `pipeline reads, not only in the resolution record.`,
-        };
-    }
-    if (authored.strategy === "mediator" && cycleSet.has(designatedId)) {
-        return {
-            accepted: false,
-            reason: `Mediator "${designatedId}" is itself a member of cycle [${members.join(", ")}]. A mediator ` +
-                `is a THIRD obligation that both sides depend on; designating a participant is a ` +
-                `single_authority break, not a mediator break.`,
-        };
-    }
-    if (authored.strategy === "single_authority" && !cycleSet.has(designatedId)) {
-        return {
-            accepted: false,
-            reason: `Single authority "${designatedId}" is not a member of cycle [${members.join(", ")}]. The ` +
-                `authority must be one of the co-defining obligations; the others become consumers.`,
-        };
-    }
-    // (3) The designated obligation must be a member of THE BROKEN CYCLE'S OWN
-    // node set — the cycle members plus what they now need. Existing in the
-    // ledger is not enough: a mediator that no cycle member depends on mediates
-    // nothing, so an arbitrary unrelated obligation could otherwise be named and
-    // the break would pass on the strength of a graph that is acyclic for
-    // reasons having nothing to do with the claim.
-    const brokenCycleNodeSet = new Set(members);
-    for (const node of currentNodes) {
-        if (!cycleSet.has(node.id))
-            continue;
-        for (const dep of node.needs)
-            brokenCycleNodeSet.add(dep);
-    }
-    if (!brokenCycleNodeSet.has(designatedId)) {
-        return {
-            accepted: false,
-            reason: `The ${authored.strategy} break names "${designatedId}", which no member of cycle ` +
-                `[${members.join(", ")}] depends on. The designated obligation must be part of the broken ` +
-                `cycle's own node set — a mediator no cycle member needs is not mediating the cycle.`,
-        };
-    }
-    // (3b) BOTH SIDES, for the mediator strategy. Step (3) above accepts a
-    // designated node that ANY single member needs, but the prompt this record
-    // answers states the stronger requirement: "a THIRD obligation that both sides
-    // depend on". A cycle of A ← B ← C (a two-sided cycle: A needs B, B needs C, C
-    // needs A) designating C as the mediator passes (3) on A's single edge while
-    // leaving B — one of the two sides the break is supposed to route through C —
-    // still pointing at the cycle. The break would then be recorded as a mediated
-    // resolution over a ledger whose edges the designated node does not mediate.
-    //
-    // The cycle is a real cycle, so "both sides" is answerable without guessing
-    // WHICH two members are the sides: the requirement enforced here is that at
-    // least TWO distinct cycle members depend on the designated node. For a
-    // two-member cycle that is exactly both; for a longer cycle it is the
-    // structural form of the same claim (a mediator one member uses is not shared,
-    // which is the defect). `single_authority` is deliberately NOT held to this:
-    // its own branch above already requires the designated node to BE a member,
-    // and the prompt asks the others to become its consumers, not to share it.
-    if (authored.strategy === "mediator") {
-        const dependingMembers = currentNodes.filter((node) => cycleSet.has(node.id) && node.needs.includes(designatedId));
-        if (dependingMembers.length < 2) {
-            const named = dependingMembers.map((node) => node.id);
-            return {
-                accepted: false,
-                reason: `Mediator "${designatedId}" is depended on by ` +
-                    `${named.length === 0 ? "no member" : `only [${named.join(", ")}]`} of cycle ` +
-                    `[${members.join(", ")}]. A mediator is a THIRD obligation that BOTH sides depend on; ` +
-                    `one member routing through it does not mediate the cycle, it re-points one edge. ` +
-                    `Rewrite the ledger so every side of the cycle depends on "${designatedId}".`,
-            };
-        }
-    }
-    // (4) The live edges, not the claim: any remaining cycle that still touches
-    // the original members means the ledger was never actually rewritten.
-    const allRemaining = detectCyclicSeamObligations(currentNodes);
-    const remaining = allRemaining.filter((cycle) => cycle.members.some((id) => cycleSet.has(id)));
-    if (remaining.length > 0) {
-        const affectedIds = [...new Set(remaining.flatMap((c) => c.members))].join(", ");
-        return {
-            accepted: false,
-            reason: `Cycle [${members.join(", ")}] is still present in the obligation ledger after the claimed ` +
-                `${authored.strategy} break via "${designatedId}" — the depends_on edges involving ` +
-                `[${affectedIds}] were not changed. Rewrite the ledger so the cycle's edges actually route ` +
-                `through the designated obligation.`,
-        };
-    }
-    // (5) SYMMETRIC across both strategies: the break must not have introduced a
-    // cycle ELSEWHERE either. Step (4) only looks at cycles touching the original
-    // members, so a brand-new cycle among untouched obligations would pass it —
-    // and a single_authority break used to reach the accept with no whole-graph
-    // check at all.
-    if (allRemaining.length > 0) {
-        const affectedIds = [...new Set(allRemaining.flatMap((c) => c.members))].join(", ");
-        return {
-            accepted: false,
-            reason: `The ${authored.strategy} break via "${designatedId}" leaves the obligation graph cyclic ` +
-                `elsewhere: [${affectedIds}]. Breaking one cycle may not introduce another.`,
-        };
-    }
-    // (6) The mediator's REAL needs — the check the fabricated `needs: []` node
-    // could never fail. Deliberately NOT run for single_authority: that strategy
-    // designates a cycle MEMBER, and `validateCycleBreak` redirects a member's
-    // intra-cycle edges at the designated node, which for the authority itself
-    // would manufacture a self-edge and reject a sound break. Step (5) is the
-    // whole-graph guarantee both strategies share.
-    if (authored.strategy === "mediator") {
-        return validateCycleBreak(originalCycle, currentNodes, {
-            id: designated.id,
-            needs: designated.needs,
-        });
-    }
-    return { accepted: true };
-}
-//# sourceMappingURL=cyclicSeamResolution.js.map

package/dist/remediate/contractPipeline/cyclicSeamResolution.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"cyclicSeamResolution.js","sourceRoot":"","sources":["../../../src/remediate/contractPipeline/cyclicSeamResolution.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAsD1D,iFAAiF;AAEjF;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,2BAA2B,CACzC,KAA2B;IAE3B,MAAM,UAAU,GAAG,oBAAoB,CACrC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,UAAU,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,EAC9D,EAAE,gBAAgB,EAAE,IAAI,EAAE,CAC3B,CAAC;IACF,OAAO,UAAU,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC;AACpD,CAAC;AAED,iFAAiF;AAEjF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,kBAAkB,CAChC,aAA4B,EAC5B,QAA8B,EAC9B,gBAAkC;IAElC,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;IAEhD,+BAA+B;IAC/B,2EAA2E;IAC3E,kCAAkC;IAClC,sCAAsC;IACtC,2EAA2E;IAC3E,MAAM,OAAO,GAAyB,EAAE,CAAC;IACzC,MAAM,sBAAsB,GAAG,QAAQ,CAAC,IAAI,CAC1C,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,KAAK,gBAAgB,CAAC,EAAE,CAC1C,CAAC;IAEF,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAC5B,IAAI,IAAI,CAAC,EAAE,KAAK,gBAAgB,CAAC,EAAE,EAAE,CAAC;YACpC,uEAAuE;YACvE,kDAAkD;YAClD,OAAO,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,GAAG,gBAAgB,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QACpE,CAAC;aAAM,IAAI,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC;YACjC,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CACtC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAC9C,CAAC;YACF,mCAAmC;YACnC,OAAO,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC;QAC/D,CAAC;aAAM,CAAC;YACN,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACrB,CAAC;IACH,CAAC;IAED,qEAAqE;IACrE,IAAI,CAAC,sBAAsB,EAAE,CAAC;QAC5B,OAAO,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,gBAAgB,CAAC,EAAE,EAAE,KAAK,EAAE,gBAAgB,CAAC,KAAK,EAAE,CAAC,CAAC;IAC3E,CAAC;IAED,MAAM,SAAS,GAAG,2BAA2B,CAAC,OAAO,CAAC,CAAC;IAEvD,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACzB,MAAM,WAAW,GAAG,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACnE,OAAO;YACL,QAAQ,EAAE,KAAK;YACf,MAAM,EAAE,sBAAsB,gBAAgB,CAAC,EAAE,uCAAuC,WAAW,IAAI;SACxG,CAAC;IACJ,CAAC;IAED,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;AAC5B,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,UAAU,0BAA0B,CACxC,aAA4B,EAC5B,YAAkC,EAClC,QAA4B;IAE5B,MAAM,OAAO,GAAG,aAAa,CAAC,OAAO,CAAC;IACtC,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,CAAC;IAClC,MAAM,YAAY,GAAG,QAAQ,CAAC,YAAY,EAAE,IAAI,EAAE,CAAC;IAEnD,IAAI,CAAC,YAAY,EAAE,CAAC;QAClB,OAAO;YACL,QAAQ,EAAE,KAAK;YACf,MAAM,EACJ,OAAO,QAAQ,CAAC,QAAQ,qBAAqB,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,yBAAyB;gBACxF,wFAAwF;gBACxF,iFAAiF;SACpF,CAAC;IACJ,CAAC;IAED,MAAM,UAAU,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,KAAK,YAAY,CAAC,CAAC;IACzE,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,OAAO;YACL,QAAQ,EAAE,KAAK;YACf,MAAM,EACJ,OAAO,QAAQ,CAAC,QAAQ,qBAAqB,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,YAAY,KAAK;gBAC5F,yFAAyF;gBACzF,oDAAoD;SACvD,CAAC;IACJ,CAAC;IAED,IAAI,QAAQ,CAAC,QAAQ,KAAK,UAAU,IAAI,QAAQ,CAAC,GAAG,CAAC,YAAY,CAAC,EAAE,CAAC;QACnE,OAAO;YACL,QAAQ,EAAE,KAAK;YACf,MAAM,EACJ,aAAa,YAAY,kCAAkC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,gBAAgB;gBAC7F,kFAAkF;gBAClF,+CAA+C;SAClD,CAAC;IACJ,CAAC;IAED,IAAI,QAAQ,CAAC,QAAQ,KAAK,kBAAkB,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,YAAY,CAAC,EAAE,CAAC;QAC5E,OAAO;YACL,QAAQ,EAAE,KAAK;YACf,MAAM,EACJ,qBAAqB,YAAY,+BAA+B,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS;gBAC3F,oFAAoF;SACvF,CAAC;IACJ,CAAC;IAED,2EAA2E;IAC3E,wEAAwE;IACxE,4EAA4E;IAC5E,6EAA6E;IAC7E,sEAAsE;IACtE,+CAA+C;IAC/C,MAAM,kBAAkB,GAAG,IAAI,GAAG,CAAS,OAAO,CAAC,CAAC;IACpD,KAAK,MAAM,IAAI,IAAI,YAAY,EAAE,CAAC;QAChC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;YAAE,SAAS;QACrC,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,KAAK;YAAE,kBAAkB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC5D,CAAC;IACD,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,YAAY,CAAC,EAAE,CAAC;QAC1C,OAAO;YACL,QAAQ,EAAE,KAAK;YACf,MAAM,EACJ,OAAO,QAAQ,CAAC,QAAQ,iBAAiB,YAAY,8BAA8B;gBACnF,IAAI,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,qEAAqE;gBAC3F,qFAAqF;SACxF,CAAC;IACJ,CAAC;IAED,uEAAuE;IACvE,2EAA2E;IAC3E,+EAA+E;IAC/E,+EAA+E;IAC/E,6EAA6E;IAC7E,8EAA8E;IAC9E,8EAA8E;IAC9E,6EAA6E;IAC7E,EAAE;IACF,4EAA4E;IAC5E,4EAA4E;IAC5E,wEAAwE;IACxE,sEAAsE;IACtE,+EAA+E;IAC/E,6EAA6E;IAC7E,4EAA4E;IAC5E,2EAA2E;IAC3E,IAAI,QAAQ,CAAC,QAAQ,KAAK,UAAU,EAAE,CAAC;QACrC,MAAM,gBAAgB,GAAG,YAAY,CAAC,MAAM,CAC1C,CAAC,IAAI,EAAE,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,YAAY,CAAC,CACrE,CAAC;QACF,IAAI,gBAAgB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAChC,MAAM,KAAK,GAAG,gBAAgB,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YACtD,OAAO;gBACL,QAAQ,EAAE,KAAK;gBACf,MAAM,EACJ,aAAa,YAAY,sBAAsB;oBAC/C,GAAG,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,YAAY;oBAC9E,IAAI,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,iEAAiE;oBACvF,mFAAmF;oBACnF,6DAA6D,YAAY,IAAI;aAChF,CAAC;QACJ,CAAC;IACH,CAAC;IAED,4EAA4E;IAC5E,sEAAsE;IACtE,MAAM,YAAY,GAAG,2BAA2B,CAAC,YAAY,CAAC,CAAC;IAC/D,MAAM,SAAS,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAC9C,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAC7C,CAAC;IACF,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACzB,MAAM,WAAW,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACjF,OAAO;YACL,QAAQ,EAAE,KAAK;YACf,MAAM,EACJ,UAAU,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,gEAAgE;gBAC5F,GAAG,QAAQ,CAAC,QAAQ,eAAe,YAAY,qCAAqC;gBACpF,IAAI,WAAW,6EAA6E;gBAC5F,oCAAoC;SACvC,CAAC;IACJ,CAAC;IAED,6EAA6E;IAC7E,8EAA8E;IAC9E,4EAA4E;IAC5E,4EAA4E;IAC5E,gBAAgB;IAChB,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC5B,MAAM,WAAW,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACpF,OAAO;YACL,QAAQ,EAAE,KAAK;YACf,MAAM,EACJ,OAAO,QAAQ,CAAC,QAAQ,eAAe,YAAY,uCAAuC;gBAC1F,eAAe,WAAW,kDAAkD;SAC/E,CAAC;IACJ,CAAC;IAED,4EAA4E;IAC5E,6EAA6E;IAC7E,2EAA2E;IAC3E,2EAA2E;IAC3E,0EAA0E;IAC1E,+CAA+C;IAC/C,IAAI,QAAQ,CAAC,QAAQ,KAAK,UAAU,EAAE,CAAC;QACrC,OAAO,kBAAkB,CAAC,aAAa,EAAE,YAAY,EAAE;YACrD,EAAE,EAAE,UAAU,CAAC,EAAE;YACjB,KAAK,EAAE,UAAU,CAAC,KAAK;SACxB,CAAC,CAAC;IACL,CAAC;IAED,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;AAC5B,CAAC"}

package/dist/remediate/contractPipeline/derive.d.ts

@@ -1,173 +0,0 @@
-/**
- * Deterministic derivers for contract-pipeline artifacts.
- *
- * S1 of the contract-authoring determinism design
- * (`spec/contract-authoring-determinism-design.md`): the contract pipeline
- * historically had the LLM author every structured artifact and the backend
- * only validate it afterward. For the artifacts whose *structure* is a pure
- * function of an upstream artifact, that is wasted generation and a weak-model
- * failure surface ("emit a large, schema-conforming, internally-consistent JSON
- * artifact from scratch with correct ids and cross-refs"). This module owns
- * those derivations so the tool produces the structure and the model is left
- * only the irreducible judgment.
- *
- * `deriveObligationLedger` is the flagship: the obligation ledger is a 1:1
- * restructuring of the finalized module contracts — every module invariant and
- * failure mode becomes an obligation, and every module gets a
- * contract-conformance obligation — so no judgment is lost by generating it in
- * code. Construction goes through the shared `buildObligationLedger` so the
- * cycle check, version stamp, and envelope stay single-sourced with the rest of
- * the codebase (the non-negotiable "derivers and validators share one source —
- * no parallel logic").
- */
-import { type ObligationLedger } from "audit-tools/shared";
-import { isTestablePhaseObligation } from "../validation/contractPipelineGates.js";
-/** Options accepted by the derivers (created_at injected for deterministic tests). */
-export interface DeriveOptions {
-    /** Overrides the generated ISO-8601 timestamp (for deterministic snapshots). */
-    created_at?: string;
-}
-/**
- * Derive the obligation ledger deterministically from the finalized module
- * contracts. Pure function of its input (modulo the `created_at` stamp): the
- * same contracts always yield the same obligations in the same order, so the
- * artifact hash / staleness DAG stays well-behaved.
- *
- * Mapping (the inverse of the obligation-ledger consumers' expectations):
- *  - one **structural** obligation per module ("implement this module per its
- *    finalized contract") — guarantees the ledger is never empty and every
- *    module has something the implementation DAG must cover, without inventing
- *    a paired-test burden (structural is not a testable kind);
- *  - one **invariant** obligation per declared module invariant (testable);
- *  - one **behavioral** obligation per declared module failure mode (testable).
- *
- * `depends_on` is left empty: the validated module-contract shape declares no
- * inter-obligation ordering, so an honest derivation asserts none (and the
- * ledger is acyclic by construction — `buildObligationLedger` cannot throw).
- */
-export declare function deriveObligationLedger(finalizedModuleContracts: unknown, options?: DeriveOptions): ObligationLedger;
-export declare function deriveFinalizedModuleContracts(draftedModuleContracts: unknown, seamReconciliationReport: unknown, options?: DeriveOptions): {
-    contract_version: string;
-    goal_id: string;
-    module_contracts: unknown[];
-    created_at: string;
-};
-/**
- * Shared obligation-membership predicates — the single source for which
- * obligations each downstream scaffold covers.
- *
- * `isTestablePhaseObligation` (imported above) is now single-sourced in
- * `../validation/contractPipelineGates.ts` (MNT-e10b9d9b: this file's former
- * local TESTABLE_KINDS set and that file's TESTABLE_OBLIGATION_KINDS were
- * "kept in parity by hand" and had already diverged — fail-open here,
- * fail-closed there, on an identical unrecognized-kind input). Re-exported
- * here so every existing importer of derive.js keeps working unchanged.
- *
- * `isDagPhaseObligation`: every obligation is covered by the implementation DAG,
- * so this is always true. It exists so both scaffolds derive their membership
- * from a named predicate rather than an inline ad-hoc filter.
- */
-export { isTestablePhaseObligation };
-export declare function isDagPhaseObligation(_kind: string): boolean;
-export interface TestValidatorPlanScaffold {
-    test_specs: Array<{
-        obligation_id: string;
-        name: string;
-        kind: string;
-        /**
-         * The change's scope anchors (touched symbols / file) the negative assertion
-         * must name to pass the CE-006 negative-scoping gate. Derived here so the
-         * host sees them IN the skeleton instead of discovering them only after a
-         * write is rejected (D1). Advisory context — the host reads them, the gate
-         * enforces them; an empty array means no change-scope constraint applies.
-         */
-        scope_anchors: string[];
-        assertions: string[];
-    }>;
-}
-/**
- * A prior round's authored test spec, keyed by obligation_id, used to diff-carry
- * unchanged assertions across a re-emit (C3). Carries the identity signals
- * (`name` + `scope_anchors`) the carry decision is gated on plus the assertions.
- */
-export interface PriorTestSpec {
-    name: string;
-    scope_anchors: string[];
-    assertions: string[];
-}
-/**
- * Build the test-plan skeleton: one spec per *testable* (invariant/behavioral)
- * obligation, with `obligation_id`/`name`/`kind`/`scope_anchors` filled and
- * `assertions` left blank for the model. The model fills only the assertions
- * (each spec needs a paired positive + negative assertion per the OBL-CO-01
- * gate, and the negative must name one of `scope_anchors` per CE-006).
- *
- * C3 diff-carry: when `priorByObligation` carries a prior round's authored spec
- * for an obligation whose premise is UNCHANGED (same `name` + same
- * `scope_anchors`), its assertions are pre-filled instead of left blank, so an
- * unchanged obligation is not re-authored from scratch every repair round. A
- * changed premise (renamed/re-scoped obligation) carries nothing — the host
- * re-authors it (fail-safe toward re-author, never toward stale carry).
- */
-export declare function buildTestValidatorPlanScaffold(ledger: ObligationLedger | undefined, priorByObligation?: Record<string, PriorTestSpec>): TestValidatorPlanScaffold;
-export interface ImplementationDagScaffoldNode {
-    id: string;
-    title: string;
-    description: string;
-    satisfies_obligations: string[];
-    addresses_counterexamples: string[];
-    /**
-     * Advisory conceptual-critique item ids this node addresses (B3). The
-     * conceptual-design critique's `advisory`-severity items have no obligation or
-     * counterexample to attach to, so without a structural slot the host smuggles
-     * them into prose or test assertions. This carrier gives each one a first-class
-     * home: the host records which advisory items a node's implementation honours.
-     * Blank in the skeleton (the host fills it); advisory, so it is not gated.
-     */
-    addressed_critique_items: string[];
-    depends_on: string[];
-    verification_obligation_ids: string[];
-    targeted_commands: string[];
-    status: string;
-}
-/** An advisory conceptual-critique item the host should account for in the DAG. */
-export interface AdvisoryCritiqueItem {
-    id: string;
-    description: string;
-}
-/**
- * Advisory-severity items from a conceptual_design_critique payload (defensive
- * read). Blocking items drive the design-repair loop and are consumed there;
- * advisory items survive past the critique gate and need a structural home in
- * the implementation DAG — this surfaces them so the skeleton can list them (B3).
- */
-export declare function advisoryCritiqueItems(critique: unknown): AdvisoryCritiqueItem[];
-export interface ImplementationDagScaffold {
-    nodes: ImplementationDagScaffoldNode[];
-    edges: never[];
-}
-/** Accepted counterexample ids from a judge_report payload (defensive read). */
-export declare function acceptedCounterexampleIds(judgeReport: unknown): string[];
-/**
- * Build the implementation-DAG skeleton: ONE node per finalized *module*
- * (grouping all that module's obligations), blank title/description/
- * targeted_commands for the model, and accepted counterexamples attached so
- * coverage holds by construction. Grouping by module means a 1-module change
- * derives 1 node instead of N obligation-nodes the host then has to merge (B2);
- * obligations with no module home (counterexample/critique-sourced) fall back
- * to one node each. Advisory: the model fills the blanks and may further
- * merge/split nodes as long as coverage is preserved.
- *
- * `depends_on` is DERIVED, not left for the host: when `finalizedContracts` is
- * supplied, each module node depends on the nodes of the modules it needs first
- * (producer/consumer `artifact:<name>` matching over `inputs`/`outputs` — the
- * same module-dependency DAG `phase_cut` uses). This
- * makes cross-node ordering tool-enforced instead of a thing the host must
- * remember to hand-add. Edges are oriented by phase ordinal so the result is
- * acyclic by construction: only an edge to a strictly-earlier-phase module is
- * kept, which drops the back-edge of any dependency cycle (fail-toward-later,
- * mirroring `derivePhaseCut`). The `edges` array stays empty — node `depends_on`
- * is the ordering the block promotion reads.
- */
-export declare function buildImplementationDagScaffold(ledger: ObligationLedger | undefined, acceptedCeIds: string[], finalizedContracts?: unknown): ImplementationDagScaffold;
-//# sourceMappingURL=derive.d.ts.map

package/dist/remediate/contractPipeline/derive.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"derive.d.ts","sourceRoot":"","sources":["../../../src/remediate/contractPipeline/derive.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,EAKL,KAAK,gBAAgB,EACtB,MAAM,oBAAoB,CAAC;AAe5B,OAAO,EAAE,yBAAyB,EAAE,MAAM,wCAAwC,CAAC;AAOnF,sFAAsF;AACtF,MAAM,WAAW,aAAa;IAC5B,gFAAgF;IAChF,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,sBAAsB,CACpC,wBAAwB,EAAE,OAAO,EACjC,OAAO,GAAE,aAAkB,GAC1B,gBAAgB,CA6DlB;AAiFD,wBAAgB,8BAA8B,CAC5C,sBAAsB,EAAE,OAAO,EAC/B,wBAAwB,EAAE,OAAO,EACjC,OAAO,GAAE,aAAkB,GAC1B;IACD,gBAAgB,EAAE,MAAM,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,gBAAgB,EAAE,OAAO,EAAE,CAAC;IAC5B,UAAU,EAAE,MAAM,CAAC;CACpB,CAsCA;AAaD;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAAE,yBAAyB,EAAE,CAAC;AAErC,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAE3D;AASD,MAAM,WAAW,yBAAyB;IACxC,UAAU,EAAE,KAAK,CAAC;QAChB,aAAa,EAAE,MAAM,CAAC;QACtB,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb;;;;;;WAMG;QACH,aAAa,EAAE,MAAM,EAAE,CAAC;QACxB,UAAU,EAAE,MAAM,EAAE,CAAC;KACtB,CAAC,CAAC;CACJ;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAQD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,8BAA8B,CAC5C,MAAM,EAAE,gBAAgB,GAAG,SAAS,EACpC,iBAAiB,GAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAM,GACpD,yBAAyB,CA6B3B;AAED,MAAM,WAAW,6BAA6B;IAC5C,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,qBAAqB,EAAE,MAAM,EAAE,CAAC;IAChC,yBAAyB,EAAE,MAAM,EAAE,CAAC;IACpC;;;;;;;OAOG;IACH,wBAAwB,EAAE,MAAM,EAAE,CAAC;IACnC,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,2BAA2B,EAAE,MAAM,EAAE,CAAC;IACtC,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,mFAAmF;AACnF,MAAM,WAAW,oBAAoB;IACnC,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,OAAO,GAAG,oBAAoB,EAAE,CAW/E;AAED,MAAM,WAAW,yBAAyB;IACxC,KAAK,EAAE,6BAA6B,EAAE,CAAC;IACvC,KAAK,EAAE,KAAK,EAAE,CAAC;CAChB;AAED,gFAAgF;AAChF,wBAAgB,yBAAyB,CAAC,WAAW,EAAE,OAAO,GAAG,MAAM,EAAE,CAgBxE;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,8BAA8B,CAC5C,MAAM,EAAE,gBAAgB,GAAG,SAAS,EACpC,aAAa,EAAE,MAAM,EAAE,EACvB,kBAAkB,CAAC,EAAE,OAAO,GAC3B,yBAAyB,CAwD3B"}