@vyuhlabs/dxkit 2.4.6 → 2.4.8

package/dist/scoring/format.js

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * Renderer helpers — turn a `ScoreResult`'s structured provenance
+ * into markdown the customer can act on.
+ *
+ * These functions don't know which dimension they're rendering; they
+ * read `topActions[]` + `capsApplied[]` from any spec output and
+ * produce consistent prose. Per-dimension renderers (the analyzer
+ * subdirs) call into here so the "Top Actions" surface looks the
+ * same across every dimension's report.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatTopActionLine = formatTopActionLine;
+exports.formatTopActionsBlock = formatTopActionsBlock;
+/** One-line top-action summary, suitable for table cells / CLI grids. */
+function formatTopActionLine(score) {
+    const top = score.topActions?.[0];
+    if (!top)
+        return '';
+    const uplift = `+${Math.round(top.upliftIfFixed)}`;
+    const transition = top.ratingTransition
+        ? ` (${top.ratingTransition.from} → ${top.ratingTransition.to})`
+        : '';
+    return `${top.reason} ${uplift}${transition}`;
+}
+/**
+ * Markdown block listing the top N actions for a dimension. Returns
+ * an empty array (no lines) when the dimension has no actionable
+ * items — caller decides whether to suppress the section header in
+ * that case.
+ */
+function formatTopActionsBlock(score, limit = 5) {
+    const actions = (score.topActions ?? []).slice(0, limit);
+    const lines = [];
+    // Severe-debt disclosure (closes D129): when the score floors at 0
+    // and the raw penalty went past it, say so. Distinguishes
+    // "barely bad" from "catastrophic" in the report itself.
+    if (score.score === 0 && typeof score.rawScore === 'number' && score.rawScore < 0) {
+        lines.push(`> **Severe:** raw penalty ${Math.round(score.rawScore)} (deductions exceed the floor).`);
+        lines.push('');
+    }
+    // Surface the binding cap separately when one fires — it's the
+    // bound on the rating, not just one of many penalties.
+    if (score.capsApplied && score.capsApplied.length > 0) {
+        const cap = score.capsApplied[0];
+        lines.push(`> **Rating cap:** ${cap.reason} — bounded at ${cap.ceiling}/100.`);
+        lines.push('');
+    }
+    if (actions.length === 0)
+        return lines;
+    lines.push('**Top actions (sorted by score uplift):**');
+    lines.push('');
+    for (const a of actions) {
+        const uplift = `+${Math.round(a.upliftIfFixed)}`;
+        const transition = a.ratingTransition
+            ? ` — would lift rating ${a.ratingTransition.from} → ${a.ratingTransition.to}`
+            : '';
+        lines.push(`- ${a.reason} \`${uplift}\`${transition}`);
+    }
+    lines.push('');
+    return lines;
+}
+//# sourceMappingURL=format.js.map

package/dist/scoring/format.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.js","sourceRoot":"","sources":["../../src/scoring/format.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;AAmBH,kDAQC;AAQD,sDAmCC;AApDD,yEAAyE;AACzE,SAAgB,mBAAmB,CAAC,KAAsB;IACxD,MAAM,GAAG,GAAG,KAAK,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,CAAC;IAClC,IAAI,CAAC,GAAG;QAAE,OAAO,EAAE,CAAC;IACpB,MAAM,MAAM,GAAG,IAAI,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,aAAa,CAAC,EAAE,CAAC;IACnD,MAAM,UAAU,GAAG,GAAG,CAAC,gBAAgB;QACrC,CAAC,CAAC,KAAK,GAAG,CAAC,gBAAgB,CAAC,IAAI,MAAM,GAAG,CAAC,gBAAgB,CAAC,EAAE,GAAG;QAChE,CAAC,CAAC,EAAE,CAAC;IACP,OAAO,GAAG,GAAG,CAAC,MAAM,IAAI,MAAM,GAAG,UAAU,EAAE,CAAC;AAChD,CAAC;AAED;;;;;GAKG;AACH,SAAgB,qBAAqB,CAAC,KAAsB,EAAE,KAAK,GAAG,CAAC;IACrE,MAAM,OAAO,GAAG,CAAC,KAAK,CAAC,UAAU,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;IACzD,MAAM,KAAK,GAAa,EAAE,CAAC;IAE3B,mEAAmE;IACnE,0DAA0D;IAC1D,yDAAyD;IACzD,IAAI,KAAK,CAAC,KAAK,KAAK,CAAC,IAAI,OAAO,KAAK,CAAC,QAAQ,KAAK,QAAQ,IAAI,KAAK,CAAC,QAAQ,GAAG,CAAC,EAAE,CAAC;QAClF,KAAK,CAAC,IAAI,CACR,6BAA6B,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,iCAAiC,CACzF,CAAC;QACF,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACjB,CAAC;IAED,+DAA+D;IAC/D,uDAAuD;IACvD,IAAI,KAAK,CAAC,WAAW,IAAI,KAAK,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACtD,MAAM,GAAG,GAAG,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;QACjC,KAAK,CAAC,IAAI,CAAC,qBAAqB,GAAG,CAAC,MAAM,iBAAiB,GAAG,CAAC,OAAO,OAAO,CAAC,CAAC;QAC/E,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACjB,CAAC;IAED,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IAEvC,KAAK,CAAC,IAAI,CAAC,2CAA2C,CAAC,CAAC;IACxD,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACf,KAAK,MAAM,CAAC,IAAI,OAAO,EAAE,CAAC;QACxB,MAAM,MAAM,GAAG,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,aAAa,CAAC,EAAE,CAAC;QACjD,MAAM,UAAU,GAAG,CAAC,CAAC,gBAAgB;YACnC,CAAC,CAAC,wBAAwB,CAAC,CAAC,gBAAgB,CAAC,IAAI,MAAM,CAAC,CAAC,gBAAgB,CAAC,EAAE,EAAE;YAC9E,CAAC,CAAC,EAAE,CAAC;QACP,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,MAAM,MAAM,KAAK,UAAU,EAAE,CAAC,CAAC;IACzD,CAAC;IACD,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACf,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/scoring/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Scoring module public surface.
+ *
+ * Consumers should import scoring primitives from this barrel rather
+ * than reaching into individual files. Per-dimension specs are
+ * registered in `dimensions/<name>.ts` (added in subsequent commits;
+ * the registry below grows as each dimension migrates).
+ */
+export type { Rating, CapTier, Deduction, CapApplied, TopAction, ScoreResult } from './result';
+export type { PenaltyRule, CapRule, DimensionScoringSpec } from './spec';
+export { RATING_THRESHOLDS, CAP_TIERS, ratingFromScore } from './thresholds';
+export { evaluateSpec } from './evaluator';
+export { formatTopActionLine, formatTopActionsBlock } from './format';
+export type { ScoreResultLike } from './format';
+export { computeOverall, DIMENSION_WEIGHTS, DIMENSION_LABEL } from './overall';
+export type { DimensionId, CrossDimensionAction, OverallResult } from './overall';
+import type { DimensionScoringSpec } from './spec';
+export { SECURITY_SCORING_SPEC } from './dimensions/security';
+export type { SecurityScoreInput } from './dimensions/security';
+export { QUALITY_SCORING_SPEC } from './dimensions/quality';
+export type { QualityScoreInput } from './dimensions/quality';
+export { TESTING_SCORING_SPEC } from './dimensions/testing';
+export type { TestingScoreInput } from './dimensions/testing';
+export { DOCUMENTATION_SCORING_SPEC } from './dimensions/documentation';
+export type { DocumentationScoreInput } from './dimensions/documentation';
+export { MAINTAINABILITY_SCORING_SPEC } from './dimensions/maintainability';
+export type { MaintainabilityScoreInput } from './dimensions/maintainability';
+export { DX_SCORING_SPEC } from './dimensions/dx';
+export type { DxScoreInput } from './dimensions/dx';
+/**
+ * Central index of all dimension scoring specs. Each per-dimension
+ * spec lands as it migrates from the legacy scorer; consumers
+ * iterating over this registry (recipe-playbook test, future
+ * cross-dimension renderers) pick up new specs automatically.
+ */
+export declare const SCORING_SPECS: readonly DimensionScoringSpec<unknown>[];
+//# sourceMappingURL=index.d.ts.map

package/dist/scoring/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/scoring/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE/F,YAAY,EAAE,WAAW,EAAE,OAAO,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AAEzE,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC7E,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AACtE,YAAY,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAC/E,YAAY,EAAE,WAAW,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAElF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AAQnD,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,YAAY,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC5D,YAAY,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC5D,YAAY,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,EAAE,0BAA0B,EAAE,MAAM,4BAA4B,CAAC;AACxE,YAAY,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AAC1E,OAAO,EAAE,4BAA4B,EAAE,MAAM,8BAA8B,CAAC;AAC5E,YAAY,EAAE,yBAAyB,EAAE,MAAM,8BAA8B,CAAC;AAC9E,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,YAAY,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD;;;;;GAKG;AACH,eAAO,MAAM,aAAa,EAAE,SAAS,oBAAoB,CAAC,OAAO,CAAC,EAOjE,CAAC"}

package/dist/scoring/index.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * Scoring module public surface.
+ *
+ * Consumers should import scoring primitives from this barrel rather
+ * than reaching into individual files. Per-dimension specs are
+ * registered in `dimensions/<name>.ts` (added in subsequent commits;
+ * the registry below grows as each dimension migrates).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCORING_SPECS = exports.DX_SCORING_SPEC = exports.MAINTAINABILITY_SCORING_SPEC = exports.DOCUMENTATION_SCORING_SPEC = exports.TESTING_SCORING_SPEC = exports.QUALITY_SCORING_SPEC = exports.SECURITY_SCORING_SPEC = exports.DIMENSION_LABEL = exports.DIMENSION_WEIGHTS = exports.computeOverall = exports.formatTopActionsBlock = exports.formatTopActionLine = exports.evaluateSpec = exports.ratingFromScore = exports.CAP_TIERS = exports.RATING_THRESHOLDS = void 0;
+var thresholds_1 = require("./thresholds");
+Object.defineProperty(exports, "RATING_THRESHOLDS", { enumerable: true, get: function () { return thresholds_1.RATING_THRESHOLDS; } });
+Object.defineProperty(exports, "CAP_TIERS", { enumerable: true, get: function () { return thresholds_1.CAP_TIERS; } });
+Object.defineProperty(exports, "ratingFromScore", { enumerable: true, get: function () { return thresholds_1.ratingFromScore; } });
+var evaluator_1 = require("./evaluator");
+Object.defineProperty(exports, "evaluateSpec", { enumerable: true, get: function () { return evaluator_1.evaluateSpec; } });
+var format_1 = require("./format");
+Object.defineProperty(exports, "formatTopActionLine", { enumerable: true, get: function () { return format_1.formatTopActionLine; } });
+Object.defineProperty(exports, "formatTopActionsBlock", { enumerable: true, get: function () { return format_1.formatTopActionsBlock; } });
+var overall_1 = require("./overall");
+Object.defineProperty(exports, "computeOverall", { enumerable: true, get: function () { return overall_1.computeOverall; } });
+Object.defineProperty(exports, "DIMENSION_WEIGHTS", { enumerable: true, get: function () { return overall_1.DIMENSION_WEIGHTS; } });
+Object.defineProperty(exports, "DIMENSION_LABEL", { enumerable: true, get: function () { return overall_1.DIMENSION_LABEL; } });
+const security_1 = require("./dimensions/security");
+const quality_1 = require("./dimensions/quality");
+const testing_1 = require("./dimensions/testing");
+const documentation_1 = require("./dimensions/documentation");
+const maintainability_1 = require("./dimensions/maintainability");
+const dx_1 = require("./dimensions/dx");
+var security_2 = require("./dimensions/security");
+Object.defineProperty(exports, "SECURITY_SCORING_SPEC", { enumerable: true, get: function () { return security_2.SECURITY_SCORING_SPEC; } });
+var quality_2 = require("./dimensions/quality");
+Object.defineProperty(exports, "QUALITY_SCORING_SPEC", { enumerable: true, get: function () { return quality_2.QUALITY_SCORING_SPEC; } });
+var testing_2 = require("./dimensions/testing");
+Object.defineProperty(exports, "TESTING_SCORING_SPEC", { enumerable: true, get: function () { return testing_2.TESTING_SCORING_SPEC; } });
+var documentation_2 = require("./dimensions/documentation");
+Object.defineProperty(exports, "DOCUMENTATION_SCORING_SPEC", { enumerable: true, get: function () { return documentation_2.DOCUMENTATION_SCORING_SPEC; } });
+var maintainability_2 = require("./dimensions/maintainability");
+Object.defineProperty(exports, "MAINTAINABILITY_SCORING_SPEC", { enumerable: true, get: function () { return maintainability_2.MAINTAINABILITY_SCORING_SPEC; } });
+var dx_2 = require("./dimensions/dx");
+Object.defineProperty(exports, "DX_SCORING_SPEC", { enumerable: true, get: function () { return dx_2.DX_SCORING_SPEC; } });
+/**
+ * Central index of all dimension scoring specs. Each per-dimension
+ * spec lands as it migrates from the legacy scorer; consumers
+ * iterating over this registry (recipe-playbook test, future
+ * cross-dimension renderers) pick up new specs automatically.
+ */
+exports.SCORING_SPECS = [
+    security_1.SECURITY_SCORING_SPEC,
+    quality_1.QUALITY_SCORING_SPEC,
+    testing_1.TESTING_SCORING_SPEC,
+    documentation_1.DOCUMENTATION_SCORING_SPEC,
+    maintainability_1.MAINTAINABILITY_SCORING_SPEC,
+    dx_1.DX_SCORING_SPEC,
+];
+//# sourceMappingURL=index.js.map

package/dist/scoring/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/scoring/index.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;;AAMH,2CAA6E;AAApE,+GAAA,iBAAiB,OAAA;AAAE,uGAAA,SAAS,OAAA;AAAE,6GAAA,eAAe,OAAA;AACtD,yCAA2C;AAAlC,yGAAA,YAAY,OAAA;AACrB,mCAAsE;AAA7D,6GAAA,mBAAmB,OAAA;AAAE,+GAAA,qBAAqB,OAAA;AAEnD,qCAA+E;AAAtE,yGAAA,cAAc,OAAA;AAAE,4GAAA,iBAAiB,OAAA;AAAE,0GAAA,eAAe,OAAA;AAI3D,oDAA8D;AAC9D,kDAA4D;AAC5D,kDAA4D;AAC5D,8DAAwE;AACxE,kEAA4E;AAC5E,wCAAkD;AAElD,kDAA8D;AAArD,iHAAA,qBAAqB,OAAA;AAE9B,gDAA4D;AAAnD,+GAAA,oBAAoB,OAAA;AAE7B,gDAA4D;AAAnD,+GAAA,oBAAoB,OAAA;AAE7B,4DAAwE;AAA/D,2HAAA,0BAA0B,OAAA;AAEnC,gEAA4E;AAAnE,+HAAA,4BAA4B,OAAA;AAErC,sCAAkD;AAAzC,qGAAA,eAAe,OAAA;AAGxB;;;;;GAKG;AACU,QAAA,aAAa,GAA6C;IACrE,gCAAsD;IACtD,8BAAqD;IACrD,8BAAqD;IACrD,0CAA2D;IAC3D,8CAA6D;IAC7D,oBAAgD;CACjD,CAAC"}

package/dist/scoring/overall.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Overall weighted rollup across the six dimension scores.
+ *
+ * Produces the headline number + letter the customer sees first
+ * (dashboard banner, CLI summary line), the rating-tier letter
+ * derived from that score via the uniform thresholds in
+ * `thresholds.ts`, and a cross-dimension `topActions[]` list
+ * sorted by weighted score-impact so the customer sees the
+ * single best move across all dimensions.
+ *
+ * Dimension weights (sum to 1.0):
+ *   Testing                25%
+ *   Quality                20%
+ *   Security               20%
+ *   Developer Experience   15%
+ *   Documentation          10%
+ *   Maintainability        10%
+ *
+ * Cross-dimension `topActions[]` ranks each dimension's
+ * top-action by its weighted contribution to the overall score
+ * (`upliftIfFixed * dimensionWeight`). Customers reading the
+ * health report's top-of-document recommendation see the single
+ * fix that lifts the overall number most — regardless of which
+ * dimension it lives in.
+ */
+import type { DimensionScore } from '../analyzers/types';
+import type { Rating, TopAction } from './result';
+export type DimensionId = 'testing' | 'quality' | 'documentation' | 'security' | 'maintainability' | 'developerExperience';
+export declare const DIMENSION_WEIGHTS: Record<DimensionId, number>;
+/** Human-readable label for renderers. */
+export declare const DIMENSION_LABEL: Record<DimensionId, string>;
+/** A top-action lifted across dimensions, retaining which dimension it
+ *  came from so the renderer can label the source. */
+export interface CrossDimensionAction extends TopAction {
+    readonly dimension: DimensionId;
+    readonly dimensionLabel: string;
+    /** Per-dimension uplift multiplied by the dimension's weight. The
+     *  cross-dimension list is sorted by this value descending. */
+    readonly weightedUplift: number;
+}
+export interface OverallResult {
+    readonly overallScore: number;
+    readonly rating: Rating;
+    /** Cross-dimension top-actions sorted by weighted score-impact. */
+    readonly topActions: readonly CrossDimensionAction[];
+}
+/**
+ * Compute the weighted overall score, rating letter, and cross-
+ * dimension top-actions list from the six per-dimension scores.
+ */
+export declare function computeOverall(dimensions: Record<DimensionId, DimensionScore>, options?: {
+    topActionsLimit?: number;
+}): OverallResult;
+//# sourceMappingURL=overall.d.ts.map

package/dist/scoring/overall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overall.d.ts","sourceRoot":"","sources":["../../src/scoring/overall.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAGlD,MAAM,MAAM,WAAW,GACnB,SAAS,GACT,SAAS,GACT,eAAe,GACf,UAAU,GACV,iBAAiB,GACjB,qBAAqB,CAAC;AAE1B,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,CAOzD,CAAC;AAEF,0CAA0C;AAC1C,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,CAOvD,CAAC;AAEF;sDACsD;AACtD,MAAM,WAAW,oBAAqB,SAAQ,SAAS;IACrD,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC;IAChC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC;mEAC+D;IAC/D,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CACjC;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,mEAAmE;IACnE,QAAQ,CAAC,UAAU,EAAE,SAAS,oBAAoB,EAAE,CAAC;CACtD;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,MAAM,CAAC,WAAW,EAAE,cAAc,CAAC,EAC/C,OAAO,GAAE;IAAE,eAAe,CAAC,EAAE,MAAM,CAAA;CAAO,GACzC,aAAa,CA6Bf"}

package/dist/scoring/overall.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * Overall weighted rollup across the six dimension scores.
+ *
+ * Produces the headline number + letter the customer sees first
+ * (dashboard banner, CLI summary line), the rating-tier letter
+ * derived from that score via the uniform thresholds in
+ * `thresholds.ts`, and a cross-dimension `topActions[]` list
+ * sorted by weighted score-impact so the customer sees the
+ * single best move across all dimensions.
+ *
+ * Dimension weights (sum to 1.0):
+ *   Testing                25%
+ *   Quality                20%
+ *   Security               20%
+ *   Developer Experience   15%
+ *   Documentation          10%
+ *   Maintainability        10%
+ *
+ * Cross-dimension `topActions[]` ranks each dimension's
+ * top-action by its weighted contribution to the overall score
+ * (`upliftIfFixed * dimensionWeight`). Customers reading the
+ * health report's top-of-document recommendation see the single
+ * fix that lifts the overall number most — regardless of which
+ * dimension it lives in.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DIMENSION_LABEL = exports.DIMENSION_WEIGHTS = void 0;
+exports.computeOverall = computeOverall;
+const thresholds_1 = require("./thresholds");
+exports.DIMENSION_WEIGHTS = {
+    testing: 0.25,
+    quality: 0.2,
+    security: 0.2,
+    developerExperience: 0.15,
+    documentation: 0.1,
+    maintainability: 0.1,
+};
+/** Human-readable label for renderers. */
+exports.DIMENSION_LABEL = {
+    testing: 'Testing',
+    quality: 'Code Quality',
+    security: 'Security',
+    developerExperience: 'Developer Experience',
+    documentation: 'Documentation',
+    maintainability: 'Maintainability',
+};
+/**
+ * Compute the weighted overall score, rating letter, and cross-
+ * dimension top-actions list from the six per-dimension scores.
+ */
+function computeOverall(dimensions, options = {}) {
+    const overallScore = Math.round(Object.entries(exports.DIMENSION_WEIGHTS).reduce((sum, [id, w]) => sum + dimensions[id].score * w, 0));
+    const crossActions = [];
+    for (const id of Object.keys(exports.DIMENSION_WEIGHTS)) {
+        const dim = dimensions[id];
+        if (!dim.topActions)
+            continue;
+        for (const action of dim.topActions) {
+            crossActions.push({
+                ...action,
+                dimension: id,
+                dimensionLabel: exports.DIMENSION_LABEL[id],
+                weightedUplift: action.upliftIfFixed * exports.DIMENSION_WEIGHTS[id],
+            });
+        }
+    }
+    crossActions.sort((a, b) => b.weightedUplift - a.weightedUplift);
+    const limit = options.topActionsLimit ?? 10;
+    return {
+        overallScore,
+        rating: (0, thresholds_1.ratingFromScore)(overallScore),
+        topActions: crossActions.slice(0, limit),
+    };
+}
+//# sourceMappingURL=overall.js.map

package/dist/scoring/overall.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"overall.js","sourceRoot":"","sources":["../../src/scoring/overall.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;;;AAsDH,wCAgCC;AAlFD,6CAA+C;AAUlC,QAAA,iBAAiB,GAAgC;IAC5D,OAAO,EAAE,IAAI;IACb,OAAO,EAAE,GAAG;IACZ,QAAQ,EAAE,GAAG;IACb,mBAAmB,EAAE,IAAI;IACzB,aAAa,EAAE,GAAG;IAClB,eAAe,EAAE,GAAG;CACrB,CAAC;AAEF,0CAA0C;AAC7B,QAAA,eAAe,GAAgC;IAC1D,OAAO,EAAE,SAAS;IAClB,OAAO,EAAE,cAAc;IACvB,QAAQ,EAAE,UAAU;IACpB,mBAAmB,EAAE,sBAAsB;IAC3C,aAAa,EAAE,eAAe;IAC9B,eAAe,EAAE,iBAAiB;CACnC,CAAC;AAmBF;;;GAGG;AACH,SAAgB,cAAc,CAC5B,UAA+C,EAC/C,UAAwC,EAAE;IAE1C,MAAM,YAAY,GAAG,IAAI,CAAC,KAAK,CAC5B,MAAM,CAAC,OAAO,CAAC,yBAAiB,CAAkC,CAAC,MAAM,CACxE,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,UAAU,CAAC,EAAE,CAAC,CAAC,KAAK,GAAG,CAAC,EAChD,CAAC,CACF,CACF,CAAC;IAEF,MAAM,YAAY,GAA2B,EAAE,CAAC;IAChD,KAAK,MAAM,EAAE,IAAI,MAAM,CAAC,IAAI,CAAC,yBAAiB,CAAkB,EAAE,CAAC;QACjE,MAAM,GAAG,GAAG,UAAU,CAAC,EAAE,CAAC,CAAC;QAC3B,IAAI,CAAC,GAAG,CAAC,UAAU;YAAE,SAAS;QAC9B,KAAK,MAAM,MAAM,IAAI,GAAG,CAAC,UAAU,EAAE,CAAC;YACpC,YAAY,CAAC,IAAI,CAAC;gBAChB,GAAG,MAAM;gBACT,SAAS,EAAE,EAAE;gBACb,cAAc,EAAE,uBAAe,CAAC,EAAE,CAAC;gBACnC,cAAc,EAAE,MAAM,CAAC,aAAa,GAAG,yBAAiB,CAAC,EAAE,CAAC;aAC7D,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IACD,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,cAAc,GAAG,CAAC,CAAC,cAAc,CAAC,CAAC;IACjE,MAAM,KAAK,GAAG,OAAO,CAAC,eAAe,IAAI,EAAE,CAAC;IAE5C,OAAO;QACL,YAAY;QACZ,MAAM,EAAE,IAAA,4BAAe,EAAC,YAAY,CAAC;QACrC,UAAU,EAAE,YAAY,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC;KACzC,CAAC;AACJ,CAAC"}

package/dist/scoring/result.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Canonical score-result envelope produced by `evaluateSpec`.
+ *
+ * Every dimension's scorer returns this shape. Carries the numeric score,
+ * the letter rating, and structured provenance: what was penalized, what
+ * caps fired, and the actionable next moves sorted by potential uplift.
+ *
+ * This shape is the contract between the spec engine and every renderer +
+ * agent that consumes scoring output. See STANDARDS.md for methodology
+ * citations and `spec.ts` for how dimensions declare penalties and caps.
+ */
+/**
+ * Uniform rating across all dimensions. Derived from the numeric score
+ * via the thresholds in `thresholds.ts` (A≥80, B≥60, C≥40, D≥20, E<20).
+ *
+ * The numeric 0-100 score is the customer-friendly surface; the letter
+ * rating is the industry-anchored claim. Both ship together.
+ */
+export type Rating = 'A' | 'B' | 'C' | 'D' | 'E';
+/**
+ * Named cap severity tiers. Each tier maps to a numeric ceiling in
+ * `thresholds.ts:CAP_TIERS`. Lower ceiling = more serious disclosure.
+ *
+ * Tiers express WHAT a cap means, not arbitrary numbers:
+ *   - `trust-broken`: definite catastrophic failure (committed secrets)
+ *   - `unmeasured`: no signal at all (testing-null, all quality tools off)
+ *   - `uncertainty`: key signal source unavailable (dep scanner)
+ *   - `partial-uncertainty`: some measurement tools didn't run
+ *   - `fixable-finding`: a concrete bounded finding is open (HIGH+ code)
+ */
+export type CapTier = 'trust-broken' | 'unmeasured' | 'uncertainty' | 'partial-uncertainty' | 'fixable-finding';
+/**
+ * A penalty that fired during evaluation. Surfaces the underlying input
+ * condition (`reason`), how much the score changed (`delta`), and how
+ * much the score WOULD lift if the condition were resolved.
+ *
+ * `upliftIfFixed` is bounded by any binding cap — when a cap holds the
+ * score below the rawScore ceiling, fixing a non-cap deduction yields no
+ * actual score change, so this value reads as 0 in that state.
+ */
+export interface Deduction {
+    readonly id: string;
+    readonly reason: string;
+    readonly delta: number;
+    readonly upliftIfFixed: number;
+}
+/**
+ * A cap that bound the score below its rawScore. Only the most-aggressive
+ * applicable cap binds; non-binding caps (higher ceilings whose conditions
+ * are also met) are not surfaced here — they would not constrain the
+ * rating until the binding cap clears.
+ *
+ * `upliftIfRemoved` = how much the score would rise if this cap were
+ * lifted. Equals (next-most-aggressive ceiling or unclamped post-penalty
+ * score, whichever is lower) minus current score.
+ */
+export interface CapApplied {
+    readonly id: string;
+    readonly tier: CapTier;
+    readonly ceiling: number;
+    readonly reason: string;
+    readonly upliftIfRemoved: number;
+}
+/**
+ * One actionable next-move, derived from either a deduction or a cap.
+ * Sorted across the result so the highest-uplift item is first.
+ *
+ * `ratingTransition` is populated when fixing the action would lift the
+ * dimension across a rating boundary (e.g., B → A). When undefined, the
+ * uplift stays within the current rating band.
+ */
+export interface TopAction {
+    readonly source: 'deduction' | 'cap';
+    readonly id: string;
+    readonly reason: string;
+    readonly upliftIfFixed: number;
+    readonly ratingTransition?: {
+        readonly from: Rating;
+        readonly to: Rating;
+    };
+}
+/**
+ * The full score-result envelope.
+ *
+ * Field roles:
+ *   - `score`: the final, post-cap, post-clamp 0-100 number the customer
+ *     sees on the dimension tile.
+ *   - `rawScore`: the pre-cap, pre-clamp score. Can be negative if
+ *     penalties exceeded the baseline. Surfaced so a 0/100 floor reads
+ *     as "severe — raw -85" rather than indistinguishable from a 0/100
+ *     where one penalty pushed past the boundary.
+ *   - `rawPenalty`: the sum of all penalty deltas applied. Equals
+ *     `rawScore - baseline` for subtractive specs.
+ *   - `rating`: derived from `score` via uniform thresholds.
+ *   - `deductions`: every penalty that fired, with structured reason.
+ *   - `capsApplied`: the binding cap (zero or one entry per result).
+ *   - `topActions`: union of deductions + caps, sorted by `upliftIfFixed`
+ *     descending. The renderer reads this for the "what to fix next" UI.
+ */
+export interface ScoreResult {
+    readonly dimension: string;
+    readonly methodology: string;
+    readonly rating: Rating;
+    readonly score: number;
+    readonly rawScore: number;
+    readonly rawPenalty: number;
+    readonly deductions: readonly Deduction[];
+    readonly capsApplied: readonly CapApplied[];
+    readonly topActions: readonly TopAction[];
+}
+//# sourceMappingURL=result.d.ts.map

package/dist/scoring/result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result.d.ts","sourceRoot":"","sources":["../../src/scoring/result.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;;;;;GAMG;AACH,MAAM,MAAM,MAAM,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AAEjD;;;;;;;;;;GAUG;AACH,MAAM,MAAM,OAAO,GACf,cAAc,GACd,YAAY,GACZ,aAAa,GACb,qBAAqB,GACrB,iBAAiB,CAAC;AAEtB;;;;;;;;GAQG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CAClC;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,MAAM,EAAE,WAAW,GAAG,KAAK,CAAC;IACrC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,gBAAgB,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC;CAC5E;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;IAC1C,QAAQ,CAAC,WAAW,EAAE,SAAS,UAAU,EAAE,CAAC;IAC5C,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;CAC3C"}

package/dist/scoring/result.js

@@ -0,0 +1,14 @@
+"use strict";
+/**
+ * Canonical score-result envelope produced by `evaluateSpec`.
+ *
+ * Every dimension's scorer returns this shape. Carries the numeric score,
+ * the letter rating, and structured provenance: what was penalized, what
+ * caps fired, and the actionable next moves sorted by potential uplift.
+ *
+ * This shape is the contract between the spec engine and every renderer +
+ * agent that consumes scoring output. See STANDARDS.md for methodology
+ * citations and `spec.ts` for how dimensions declare penalties and caps.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=result.js.map

package/dist/scoring/result.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"result.js","sourceRoot":"","sources":["../../src/scoring/result.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;GAUG"}

package/dist/scoring/spec.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Declarative scoring specification — one per dimension.
+ *
+ * A `DimensionScoringSpec<TInput>` is a self-contained artifact: the
+ * baseline score, the list of penalty rules, and the list of cap rules
+ * that enforce the dimension's Label Contract. The evaluator
+ * (`evaluator.ts`) consumes a spec + input and produces a `ScoreResult`.
+ *
+ * Specs are values, not functions — each rule is a small object with
+ * declarative predicates and reason-builders. This lets us:
+ *   - register specs in a central index
+ *   - generate documentation from specs (citations, penalty lists)
+ *   - test new dimensions by injecting synthetic specs
+ *   - keep the cross-dimension contract (return shape, rating mapping)
+ *     uniform regardless of per-dimension methodology
+ *
+ * Per-dimension specs live in `dimensions/<name>.ts` (one file per
+ * dimension, mirroring the LanguageSupport pattern in CLAUDE.md Rule 6).
+ */
+import type { CapTier } from './result';
+/**
+ * A single penalty rule. Fires when `applies(input)` returns true; its
+ * `delta` (typically negative for subtractive specs, positive for
+ * additive specs like Documentation) adjusts the running score.
+ *
+ * `describe(input)` produces the human-readable reason surfaced in the
+ * report ("3 hardcoded secrets detected"). `upliftIfFixed` is optional;
+ * when omitted, the evaluator defaults to `Math.abs(delta(input))`.
+ * Override when fixing the underlying condition would yield more (or
+ * less) than the raw delta — e.g., when fixing a single source also
+ * clears a related cap.
+ */
+export interface PenaltyRule<TInput> {
+    readonly id: string;
+    readonly describe: (input: TInput) => string;
+    readonly applies: (input: TInput) => boolean;
+    readonly delta: (input: TInput) => number;
+    readonly upliftIfFixed?: (input: TInput) => number;
+}
+/**
+ * A cap rule. Bounds the final score at the tier's ceiling when
+ * `applies(input)` returns true. Tier name is the contract; the
+ * numeric ceiling comes from `thresholds.ts:CAP_TIERS[tier]`.
+ *
+ * Caps express the Label Contract: "A grade means no blockers." Each
+ * cap names a specific blocker class. The evaluator applies the
+ * most-aggressive applicable cap (lowest ceiling); other applicable
+ * caps would not bind on the post-cap score and are not surfaced.
+ */
+export interface CapRule<TInput> {
+    readonly id: string;
+    readonly tier: CapTier;
+    readonly describe: (input: TInput) => string;
+    readonly applies: (input: TInput) => boolean;
+}
+/**
+ * The full dimension scoring specification.
+ *
+ * `baseline` is the starting score. Subtractive specs (Security,
+ * Quality, Maintainability) start at 100; additive checklist specs
+ * (Documentation, DevEx) start at 0.
+ *
+ * `methodology` is a citation key matching an entry in `STANDARDS.md` —
+ * e.g., `'iso-iec-5055-severity-dominant'` for the SonarQube-shape
+ * Security rating, `'sqale-debt-ratio'` for the Maintainability dim.
+ * The renderer surfaces this so customers can trace any score claim to
+ * its methodological source.
+ */
+export interface DimensionScoringSpec<TInput> {
+    readonly dimension: string;
+    readonly methodology: string;
+    readonly baseline: number;
+    readonly penalties: readonly PenaltyRule<TInput>[];
+    readonly caps: readonly CapRule<TInput>[];
+}
+//# sourceMappingURL=spec.d.ts.map

package/dist/scoring/spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spec.d.ts","sourceRoot":"","sources":["../../src/scoring/spec.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAExC;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,WAAW,CAAC,MAAM;IACjC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IAC7C,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;IAC7C,QAAQ,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IAC1C,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;CACpD;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,OAAO,CAAC,MAAM;IAC7B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IAC7C,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;CAC9C;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,oBAAoB,CAAC,MAAM;IAC1C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,SAAS,WAAW,CAAC,MAAM,CAAC,EAAE,CAAC;IACnD,QAAQ,CAAC,IAAI,EAAE,SAAS,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;CAC3C"}

package/dist/scoring/spec.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * Declarative scoring specification — one per dimension.
+ *
+ * A `DimensionScoringSpec<TInput>` is a self-contained artifact: the
+ * baseline score, the list of penalty rules, and the list of cap rules
+ * that enforce the dimension's Label Contract. The evaluator
+ * (`evaluator.ts`) consumes a spec + input and produces a `ScoreResult`.
+ *
+ * Specs are values, not functions — each rule is a small object with
+ * declarative predicates and reason-builders. This lets us:
+ *   - register specs in a central index
+ *   - generate documentation from specs (citations, penalty lists)
+ *   - test new dimensions by injecting synthetic specs
+ *   - keep the cross-dimension contract (return shape, rating mapping)
+ *     uniform regardless of per-dimension methodology
+ *
+ * Per-dimension specs live in `dimensions/<name>.ts` (one file per
+ * dimension, mirroring the LanguageSupport pattern in CLAUDE.md Rule 6).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=spec.js.map

package/dist/scoring/spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spec.js","sourceRoot":"","sources":["../../src/scoring/spec.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;GAkBG"}

package/dist/scoring/thresholds.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Single source of truth for rating thresholds and cap ceilings used by
+ * every dimension scorer.
+ *
+ * Uniform 0-100 scale with A/B/C/D/E ratings at 80/60/40/20 boundaries
+ * applies to every dimension. The per-dimension methodology determines
+ * HOW the numeric score is computed (penalty stacks for some, debt-ratio
+ * inversion for others); the score-to-rating mapping is uniform.
+ *
+ * Cap ceilings encode a severity taxonomy: lower ceiling = more serious
+ * disclosure. Each tier name says what it means, not just what it does.
+ * See `result.ts:CapTier` for the per-tier semantics.
+ */
+import type { CapTier, Rating } from './result';
+/**
+ * Uniform rating thresholds. A repo's letter rating is determined by
+ * which band its numeric score falls into.
+ *
+ * Boundaries chosen so each band spans 20 points (familiar academic
+ * grading shape), with the A boundary at 80 matching industry
+ * convention for "excellent / no blockers."
+ */
+export declare const RATING_THRESHOLDS: {
+    readonly A: 80;
+    readonly B: 60;
+    readonly C: 40;
+    readonly D: 20;
+};
+/**
+ * Derive the letter rating for a numeric 0-100 score. Pure function;
+ * the same score always maps to the same rating.
+ */
+export declare function ratingFromScore(score: number): Rating;
+/**
+ * Cap ceiling per tier. A cap whose condition fires bounds the score at
+ * its tier's ceiling, regardless of how clean other signals are.
+ *
+ * Tier values are derived from the rating boundaries (not picked
+ * arbitrarily):
+ *   - `trust-broken` (40): top of C — a definite catastrophic failure
+ *     (e.g., committed credentials) cannot leave the dimension above C.
+ *   - `unmeasured` (35): below C boundary — no signal at all means the
+ *     dimension can't claim even "Fair."
+ *   - `uncertainty` (65): middle of B — key signal source unavailable
+ *     reads as "we can't measure, can't claim A."
+ *   - `partial-uncertainty` (75): top of B — some tools didn't run;
+ *     can't claim A but signal exists for what was measured.
+ *   - `fixable-finding` (79): just-below-A — a concrete bounded finding
+ *     blocks A specifically. Smallest possible cap claim: "fix the
+ *     finding and you reach A."
+ *
+ * Lower number = more serious. The evaluator applies the lowest
+ * applicable cap (most aggressive) when multiple conditions hold.
+ */
+export declare const CAP_TIERS: Record<CapTier, number>;
+//# sourceMappingURL=thresholds.d.ts.map

package/dist/scoring/thresholds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thresholds.d.ts","sourceRoot":"","sources":["../../src/scoring/thresholds.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEhD;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB;;;;;CAKpB,CAAC;AAEX;;;GAGG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAMrD;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,SAAS,EAAE,MAAM,CAAC,OAAO,EAAE,MAAM,CAMpC,CAAC"}