@mergesignal/shared 0.2.2 → 0.2.4

package/dist/deriveScanDetailRecommendations.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=deriveScanDetailRecommendations.test.d.ts.map

package/dist/deriveScanDetailRecommendations.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deriveScanDetailRecommendations.test.d.ts","sourceRoot":"","sources":["../src/deriveScanDetailRecommendations.test.ts"],"names":[],"mappings":""}

package/dist/deriveScanDetailRecommendations.test.js

@@ -0,0 +1,181 @@
+import { describe, expect, it } from "vitest";
+import { primaryPrExample } from "./productMessaging.js";
+import { deriveScanDetailRecommendations, RECOMMENDATION_MAX_ITEMS, } from "./deriveScanDetailRecommendations.js";
+import { deriveScanDetailViewModel } from "./scanDetailViewModel.js";
+const baseResult = {
+    totalScore: 10,
+    layerScores: {
+        security: 1,
+        maintainability: 2,
+        ecosystem: 3,
+        upgradeImpact: 4,
+    },
+    findings: [],
+    generatedAt: "2026-01-01T00:00:00.000Z",
+};
+function minimalResult(overrides = {}) {
+    return {
+        totalScore: 42,
+        layerScores: {
+            security: 10,
+            maintainability: 20,
+            ecosystem: 30,
+            upgradeImpact: 15,
+        },
+        findings: [],
+        generatedAt: new Date().toISOString(),
+        decision: {
+            recommendation: "needs_review",
+            confidence: "medium",
+            reasoning: ["Lockfile adds transitive depth on shared utilities."],
+        },
+        ...overrides,
+    };
+}
+describe("deriveScanDetailRecommendations", () => {
+    it("always returns 1–3 enriched items with detail fields", () => {
+        const archetypes = [
+            {
+                ...baseResult,
+                decision: { recommendation: "safe", confidence: "high", reasoning: [] },
+            },
+            minimalResult(),
+            {
+                ...minimalResult(),
+                decision: {
+                    recommendation: "risky",
+                    confidence: "high",
+                    reasoning: [],
+                },
+                findings: [
+                    {
+                        id: "f1",
+                        severity: "critical",
+                        title: "Critical vulnerability",
+                        description: "Transitive CVE",
+                        packageName: "lodash",
+                        recommendation: "Upgrade lodash",
+                    },
+                ],
+            },
+        ];
+        for (const result of archetypes) {
+            const center = deriveScanDetailRecommendations(result);
+            expect(center.items.length).toBeGreaterThanOrEqual(1);
+            expect(center.items.length).toBeLessThanOrEqual(RECOMMENDATION_MAX_ITEMS);
+            expect(center.defaultSelectedId).toBe(center.items[0]?.id);
+            for (const item of center.items) {
+                expect(item.detail.why.length).toBeGreaterThan(0);
+                expect(item.detail.whyNow.length).toBeGreaterThan(0);
+                expect(item.detail.expectedBenefit.length).toBeGreaterThan(0);
+                expect(item.detail.why).not.toMatch(/CVE-\d|@\d|\d+\.\d+\.\d+/);
+            }
+        }
+    });
+    it("quiet safe scan uses posture playbook with scan context", () => {
+        const center = deriveScanDetailRecommendations({
+            ...baseResult,
+            decision: { recommendation: "safe", confidence: "high", reasoning: [] },
+        });
+        expect(center.posture).toBe("safe");
+        expect(center.scanContext).toBeTruthy();
+        expect(center.items[0]?.priority).toBe("low");
+        expect(center.items[0]?.title).toBe("Merge normally");
+    });
+    it("duplicate recommendation includes whyNow and signals with packages", () => {
+        const center = deriveScanDetailRecommendations({
+            ...minimalResult(),
+            recommendations: [
+                {
+                    id: "r1",
+                    title: "Reduce duplicate dependency versions",
+                    rationale: "semver overlap",
+                    impact: "high",
+                    packages: ["semver", "string-width", "@opentelemetry/api-logs"],
+                },
+            ],
+        });
+        const dup = center.items.find((i) => i.title.toLowerCase().includes("duplicate"));
+        expect(dup?.detail.whyNow.toLowerCase()).toContain("semver");
+        expect(dup?.detail.signals.length).toBeGreaterThan(0);
+        expect(dup?.detail.affectedPackages?.names).toContain("semver");
+    });
+    it("insight-rich scan has high priority and scan-specific whyNow", () => {
+        const center = deriveScanDetailRecommendations({
+            ...minimalResult(),
+            insights: [
+                {
+                    type: "behavioral_change",
+                    priority: "high",
+                    confidence: "confirmed",
+                    scope: "changed",
+                    message: primaryPrExample.message,
+                    context: primaryPrExample.where[0],
+                    remediation: "Confirm auth guards still run before protected handlers",
+                    affectedFiles: [...primaryPrExample.where],
+                },
+            ],
+        });
+        expect(center.items[0]?.source).toBe("insight");
+        expect(center.items[0]?.priority).toBe("high");
+        expect(center.items[0]?.detail.whyNow).toContain("middleware");
+    });
+    it("risky scan with critical findings leads with resolve guidance", () => {
+        const center = deriveScanDetailRecommendations({
+            ...minimalResult(),
+            decision: { recommendation: "risky", confidence: "high", reasoning: [] },
+            findings: [
+                {
+                    id: "f1",
+                    severity: "critical",
+                    title: "Critical vulnerability",
+                    description: "Transitive CVE",
+                    packageName: "lodash",
+                    recommendation: "Upgrade lodash",
+                },
+            ],
+        });
+        expect(center.items[0]?.title).toContain("Resolve critical findings");
+        expect(center.items[0]?.priority).toBe("high");
+        expect(center.items[0]?.proofRefs?.findingIds).toContain("f1");
+    });
+});
+describe("recommendedActions on scan detail view model", () => {
+    it("includes recommendedActions slice on done scans", () => {
+        const vm = deriveScanDetailViewModel(minimalResult(), {
+            scanId: "s1",
+            status: "done",
+        });
+        expect(vm?.recommendedActions.items.length).toBeGreaterThanOrEqual(1);
+    });
+    it("strips duplicate finding recommendations covered by recommended actions", () => {
+        const vm = deriveScanDetailViewModel({
+            ...minimalResult(),
+            decision: {
+                recommendation: "risky",
+                confidence: "high",
+                reasoning: [],
+            },
+            findings: [
+                {
+                    id: "f1",
+                    severity: "critical",
+                    title: "Critical vulnerability",
+                    description: "Transitive CVE",
+                    packageName: "lodash",
+                    recommendation: "Upgrade lodash",
+                },
+            ],
+        }, { scanId: "dedupe", status: "done" });
+        const finding = vm?.evidence?.findings.find((f) => f.id === "f1");
+        expect(finding?.recommendation).toBeUndefined();
+        expect(finding?.coveredByRecommendationRank).toBeGreaterThan(0);
+    });
+    it("does not expose Act 4 next steps", () => {
+        const vm = deriveScanDetailViewModel(minimalResult(), {
+            scanId: "s1",
+            status: "done",
+        });
+        expect(vm).not.toHaveProperty("next");
+    });
+});

package/dist/formatCardAreaLabels.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Filter and rank area labels for dashboard cards (max 2).
+ * Longer specific labels win; generic taxonomy is dropped.
+ */
+export declare function formatCardAreaLabels(areas: string[] | null | undefined, max?: number): string[];
+/** Join formatted areas for evidence row display. */
+export declare function joinCardAreaLabels(areas: string[]): string | null;
+//# sourceMappingURL=formatCardAreaLabels.d.ts.map

package/dist/formatCardAreaLabels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatCardAreaLabels.d.ts","sourceRoot":"","sources":["../src/formatCardAreaLabels.ts"],"names":[],"mappings":"AAmCA;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,GAAG,SAAS,EAClC,GAAG,SAAI,GACN,MAAM,EAAE,CAmBV;AAED,qDAAqD;AACrD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,IAAI,CAIjE"}

package/dist/formatCardAreaLabels.js

@@ -0,0 +1,65 @@
+import { GENERIC_CARD_AREA_PHRASES } from "./cardSummaryCopy.js";
+const PATH_LIKE = /[/\\]|^packages\/|\.tsx?$|\.jsx?$|^src\//i;
+const KEBAB_SNAKE = /^[a-z0-9]+[-_][a-z0-9_-]+$/;
+function normalizeKey(label) {
+    return label.trim().toLowerCase();
+}
+function isTechnicalLabel(label) {
+    const t = label.trim();
+    if (!t)
+        return true;
+    if (PATH_LIKE.test(t))
+        return true;
+    if (KEBAB_SNAKE.test(t) && !/\s/.test(t))
+        return true;
+    return false;
+}
+function isGenericArea(label) {
+    const key = normalizeKey(label);
+    return GENERIC_CARD_AREA_PHRASES.some((g) => key === g || key.startsWith(`${g} `) || key.endsWith(` ${g}`));
+}
+function humanizeLabel(label) {
+    const clean = label.replace(/^(Finding:\s*|Area:\s*)/i, "").trim();
+    if (!clean)
+        return "";
+    if (/\s/.test(clean) || /^[A-Z]/.test(clean))
+        return clean;
+    return clean
+        .split(/[-_]/)
+        .filter(Boolean)
+        .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
+        .join(" ");
+}
+/**
+ * Filter and rank area labels for dashboard cards (max 2).
+ * Longer specific labels win; generic taxonomy is dropped.
+ */
+export function formatCardAreaLabels(areas, max = 2) {
+    if (!Array.isArray(areas) || areas.length === 0)
+        return [];
+    const seen = new Set();
+    const candidates = [];
+    for (const raw of areas) {
+        if (isTechnicalLabel(raw))
+            continue;
+        const label = humanizeLabel(raw);
+        if (!label || label.length < 4)
+            continue;
+        if (isGenericArea(label))
+            continue;
+        const key = normalizeKey(label);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        candidates.push(label);
+    }
+    candidates.sort((a, b) => b.length - a.length);
+    return candidates.slice(0, max);
+}
+/** Join formatted areas for evidence row display. */
+export function joinCardAreaLabels(areas) {
+    const formatted = formatCardAreaLabels(areas);
+    if (formatted.length === 0)
+        return null;
+    return formatted.join(" · ");
+}

package/dist/formatCardEvidenceCounts.d.ts

@@ -0,0 +1,7 @@
+import type { FindingCountSummary } from "./scanCardSummary.js";
+import type { MergePosture } from "./riskVocabulary.js";
+/**
+ * One soft evidence phrase for dashboard cards (not scanner-style metrics).
+ */
+export declare function formatCardEvidenceCounts(counts: FindingCountSummary | null | undefined, posture: MergePosture | null): string | null;
+//# sourceMappingURL=formatCardEvidenceCounts.d.ts.map

package/dist/formatCardEvidenceCounts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatCardEvidenceCounts.d.ts","sourceRoot":"","sources":["../src/formatCardEvidenceCounts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,mBAAmB,GAAG,IAAI,GAAG,SAAS,EAC9C,OAAO,EAAE,YAAY,GAAG,IAAI,GAC3B,MAAM,GAAG,IAAI,CAaf"}

package/dist/formatCardEvidenceCounts.js

@@ -0,0 +1,19 @@
+/**
+ * One soft evidence phrase for dashboard cards (not scanner-style metrics).
+ */
+export function formatCardEvidenceCounts(counts, posture) {
+    if (!counts || !posture || posture === "safe")
+        return null;
+    const { critical, high } = counts;
+    if (critical > 0 && posture === "risky") {
+        if (critical === 1)
+            return "1 critical finding";
+        return "Critical findings present";
+    }
+    if (high > 0 && (posture === "risky" || posture === "needs_review")) {
+        if (high === 1)
+            return "1 high-severity finding";
+        return `${high} high-severity findings`;
+    }
+    return null;
+}

package/dist/formatCardExposureDisplay.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Dashboard card exposure semantics — display-only interpretation of totalScore.
+ * Not persisted; not an engine output; complements merge posture (Safe / Review / Risky).
+ */
+export type CardExposureCategory = "minimal" | "limited" | "moderate" | "elevated" | "broad";
+export type CardExposureDisplay = {
+    category: CardExposureCategory;
+    /** User-facing label, e.g. "Moderate exposure". */
+    label: string;
+    value: number;
+};
+/** User-facing exposure labels for docs and UI copy (low → high). */
+export declare const CARD_EXPOSURE_CATEGORY_LABELS: readonly string[];
+/** Map numeric totalScore to a fixed exposure category (card UX only). */
+export declare function deriveCardExposureDisplay(score: number | null | undefined): CardExposureDisplay | null;
+/** Compact card line: exposure category label only. */
+export declare function formatCardExposureLine(score: number | null | undefined): string | null;
+/** Fragment for composite aria labels on PR cards. */
+export declare function exposureAriaFragment(score: number | null | undefined): string | null;
+/** Detail-page reach chip labels (not "exposure" jargon). */
+export declare const DETAIL_REACH_CHIP_LABEL: Record<CardExposureCategory, string>;
+/** Reach chip for scan detail page — maps score band to reviewer-facing scope label. */
+export declare function deriveDetailReachChip(score: number | null | undefined): string | null;
+//# sourceMappingURL=formatCardExposureDisplay.d.ts.map

package/dist/formatCardExposureDisplay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatCardExposureDisplay.d.ts","sourceRoot":"","sources":["../src/formatCardExposureDisplay.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,MAAM,oBAAoB,GAC5B,SAAS,GACT,SAAS,GACT,UAAU,GACV,UAAU,GACV,OAAO,CAAC;AAEZ,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,EAAE,oBAAoB,CAAC;IAC/B,mDAAmD;IACnD,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAUF,qEAAqE;AACrE,eAAO,MAAM,6BAA6B,EAAE,SAAS,MAAM,EAM1D,CAAC;AAkBF,0EAA0E;AAC1E,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAC/B,mBAAmB,GAAG,IAAI,CAM5B;AAED,uDAAuD;AACvD,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAC/B,MAAM,GAAG,IAAI,CAIf;AAED,sDAAsD;AACtD,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAC/B,MAAM,GAAG,IAAI,CAIf;AAED,6DAA6D;AAC7D,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,oBAAoB,EAAE,MAAM,CAMxE,CAAC;AAEF,wFAAwF;AACxF,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAC/B,MAAM,GAAG,IAAI,CAIf"}

package/dist/formatCardExposureDisplay.js

@@ -0,0 +1,71 @@
+/**
+ * Dashboard card exposure semantics — display-only interpretation of totalScore.
+ * Not persisted; not an engine output; complements merge posture (Safe / Review / Risky).
+ */
+const EXPOSURE_LABEL = {
+    minimal: "Minimal exposure",
+    limited: "Limited exposure",
+    moderate: "Moderate exposure",
+    elevated: "Elevated exposure",
+    broad: "Broad exposure",
+};
+/** User-facing exposure labels for docs and UI copy (low → high). */
+export const CARD_EXPOSURE_CATEGORY_LABELS = [
+    EXPOSURE_LABEL.minimal,
+    EXPOSURE_LABEL.limited,
+    EXPOSURE_LABEL.moderate,
+    EXPOSURE_LABEL.elevated,
+    EXPOSURE_LABEL.broad,
+];
+/** Inclusive upper bounds (0–100). Five stable buckets only. */
+const EXPOSURE_UPPER_BOUND = [24, 44, 74, 89, 100];
+const EXPOSURE_ORDER = [
+    "minimal",
+    "limited",
+    "moderate",
+    "elevated",
+    "broad",
+];
+function clampScore(score) {
+    if (!Number.isFinite(score))
+        return 0;
+    return Math.min(100, Math.max(0, Math.round(score)));
+}
+/** Map numeric totalScore to a fixed exposure category (card UX only). */
+export function deriveCardExposureDisplay(score) {
+    if (score == null || !Number.isFinite(score))
+        return null;
+    const value = clampScore(score);
+    const idx = EXPOSURE_UPPER_BOUND.findIndex((bound) => value <= bound);
+    const category = EXPOSURE_ORDER[idx >= 0 ? idx : EXPOSURE_ORDER.length - 1];
+    return { category, label: EXPOSURE_LABEL[category], value };
+}
+/** Compact card line: exposure category label only. */
+export function formatCardExposureLine(score) {
+    const display = deriveCardExposureDisplay(score);
+    if (!display)
+        return null;
+    return display.label;
+}
+/** Fragment for composite aria labels on PR cards. */
+export function exposureAriaFragment(score) {
+    const display = deriveCardExposureDisplay(score);
+    if (!display)
+        return null;
+    return display.label;
+}
+/** Detail-page reach chip labels (not "exposure" jargon). */
+export const DETAIL_REACH_CHIP_LABEL = {
+    minimal: "Focused reach",
+    limited: "Limited reach",
+    moderate: "Moderate reach",
+    elevated: "Wide reach",
+    broad: "Wide reach",
+};
+/** Reach chip for scan detail page — maps score band to reviewer-facing scope label. */
+export function deriveDetailReachChip(score) {
+    const display = deriveCardExposureDisplay(score);
+    if (!display)
+        return null;
+    return DETAIL_REACH_CHIP_LABEL[display.category];
+}

package/dist/formatCardExposureDisplay.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=formatCardExposureDisplay.test.d.ts.map

package/dist/formatCardExposureDisplay.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatCardExposureDisplay.test.d.ts","sourceRoot":"","sources":["../src/formatCardExposureDisplay.test.ts"],"names":[],"mappings":""}

package/dist/formatCardExposureDisplay.test.js

@@ -0,0 +1,36 @@
+import { describe, expect, it } from "vitest";
+import { deriveCardExposureDisplay, exposureAriaFragment, formatCardExposureLine, } from "./formatCardExposureDisplay.js";
+describe("deriveCardExposureDisplay", () => {
+    it("maps score to five fixed exposure buckets", () => {
+        expect(deriveCardExposureDisplay(0)?.category).toBe("minimal");
+        expect(deriveCardExposureDisplay(24)?.category).toBe("minimal");
+        expect(deriveCardExposureDisplay(25)?.category).toBe("limited");
+        expect(deriveCardExposureDisplay(44)?.category).toBe("limited");
+        expect(deriveCardExposureDisplay(45)?.category).toBe("moderate");
+        expect(deriveCardExposureDisplay(71)?.category).toBe("moderate");
+        expect(deriveCardExposureDisplay(74)?.category).toBe("moderate");
+        expect(deriveCardExposureDisplay(75)?.category).toBe("elevated");
+        expect(deriveCardExposureDisplay(89)?.category).toBe("elevated");
+        expect(deriveCardExposureDisplay(90)?.category).toBe("broad");
+        expect(deriveCardExposureDisplay(100)?.category).toBe("broad");
+    });
+    it("clamps and rounds non-finite input away", () => {
+        expect(deriveCardExposureDisplay(null)).toBeNull();
+        expect(deriveCardExposureDisplay(NaN)).toBeNull();
+        expect(deriveCardExposureDisplay(71.6)?.value).toBe(72);
+        expect(deriveCardExposureDisplay(150)?.value).toBe(100);
+    });
+});
+describe("formatCardExposureLine", () => {
+    it("returns exposure label only", () => {
+        expect(formatCardExposureLine(71)).toBe("Moderate exposure");
+        expect(formatCardExposureLine(12)).toBe("Minimal exposure");
+        expect(formatCardExposureLine(80)).toBe("Elevated exposure");
+    });
+});
+describe("exposureAriaFragment", () => {
+    it("returns exposure label only", () => {
+        expect(exposureAriaFragment(45)).toBe("Moderate exposure");
+        expect(exposureAriaFragment(80)).toBe("Elevated exposure");
+    });
+});

package/dist/index.d.ts

@@ -3,10 +3,22 @@ export * from "./formatInsight.js";
 export * from "./riskVocabulary.js";
 export * from "./selectTopAffectedAreas.js";
 export * from "./deriveScanSummaryText.js";
+export * from "./cardSummaryCopy.js";
+export * from "./truncateCardSummary.js";
+export * from "./formatCardAreaLabels.js";
+export * from "./formatCardEvidenceCounts.js";
+export * from "./formatCardExposureDisplay.js";
+export * from "./cardObservationCatalog.js";
+export * from "./deriveCardOperationalObservations.js";
+export * from "./deriveCardDisplaySummary.js";
 export * from "./scanCardSummary.js";
+export * from "./deriveScanDetailRecommendations.js";
+export * from "./deriveRiskScoreSummary.js";
+export * from "./scanDetailViewModel.js";
 export * from "./scanResultSchema.js";
 export * from "./scanSurfaceCopy.js";
 export * from "./trustedScanGuards.js";
 export * from "./actionsStepSummary.js";
 export * from "./prCheckRunPresentation.js";
+export * from "./productMessaging.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wCAAwC,CAAC;AACvD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,sBAAsB,CAAC;AACrC,cAAc,sCAAsC,CAAC;AACrD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC;AACzC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,uBAAuB,CAAC"}

package/dist/index.js

@@ -3,9 +3,21 @@ export * from "./formatInsight.js";
 export * from "./riskVocabulary.js";
 export * from "./selectTopAffectedAreas.js";
 export * from "./deriveScanSummaryText.js";
+export * from "./cardSummaryCopy.js";
+export * from "./truncateCardSummary.js";
+export * from "./formatCardAreaLabels.js";
+export * from "./formatCardEvidenceCounts.js";
+export * from "./formatCardExposureDisplay.js";
+export * from "./cardObservationCatalog.js";
+export * from "./deriveCardOperationalObservations.js";
+export * from "./deriveCardDisplaySummary.js";
 export * from "./scanCardSummary.js";
+export * from "./deriveScanDetailRecommendations.js";
+export * from "./deriveRiskScoreSummary.js";
+export * from "./scanDetailViewModel.js";
 export * from "./scanResultSchema.js";
 export * from "./scanSurfaceCopy.js";
 export * from "./trustedScanGuards.js";
 export * from "./actionsStepSummary.js";
 export * from "./prCheckRunPresentation.js";
+export * from "./productMessaging.js";

package/dist/productMessaging.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Canonical marketing / category copy. Operational scan strings stay in scanSurfaceCopy.
+ */
+export declare const productMessaging: {
+    readonly formalDefinition: "MergeSignal analyzes dependency upgrades, identifies affected application flows, and provides reviewer guidance before merge.";
+    readonly hero: {
+        readonly kicker: "Merge-decision intelligence for dependency upgrades";
+        readonly h1: "See what a dependency upgrade can break.";
+        readonly lead: "Dependency upgrade analysis that shows where runtime behavior may affect critical application flows.";
+    };
+    readonly seo: {
+        readonly title: "MergeSignal - know what an upgrade may break before merge";
+        readonly description: "Know what a dependency upgrade may affect in your app before merge. Affected flows, reviewer checks, and merge guidance for this PR.";
+    };
+    readonly finalCta: {
+        readonly headline: "Try it on your next upgrade PR";
+        readonly lead: "Run a local scan or add GitHub Actions to your workflow.";
+        readonly button: "Get started for free";
+    };
+    readonly homepageSections: {
+        readonly pain: {
+            readonly title: "Why dependency upgrades are hard to review";
+            readonly subhead: "Upgrading is easy. Knowing what it affects is not.";
+            readonly rows: readonly [{
+                readonly title: "Changelogs don't show real impact";
+                readonly body: "Release notes describe package changes, not how they affect your code paths and critical application flows.";
+            }, {
+                readonly title: "Too much noise, not enough clarity";
+                readonly body: "Security alerts rarely show what actually matters for this specific upgrade PR.";
+            }, {
+                readonly title: "Runtime impact is hard to reason about";
+                readonly body: "Understanding how a dependency change affects critical application flows requires deeper application context.";
+            }];
+        };
+        readonly focus: {
+            readonly title: "What MergeSignal focuses on";
+            readonly subhead: "Clearer upgrade decisions with fewer merge surprises";
+            readonly rows: readonly [{
+                readonly title: "What this upgrade affects";
+                readonly body: "Potential failure modes based on how your code uses the updated dependencies.";
+            }, {
+                readonly title: "Where it shows up";
+                readonly body: "The application flows, routes, and entrypoints affected by this upgrade.";
+            }, {
+                readonly title: "What to verify before merge";
+                readonly body: "Concrete reviewer checks for this specific upgrade.";
+            }];
+        };
+        readonly value: {
+            readonly title: "What changes when you use MergeSignal";
+            readonly subhead: "More focused reviews and targeted validation.";
+            readonly rows: readonly [{
+                readonly title: "Reviews move faster";
+                readonly body: "Start with affected flows instead of reconstructing impact from changelogs.";
+            }, {
+                readonly title: "Testing stays targeted";
+                readonly body: "Focus validation on the flows this upgrade affects.";
+            }, {
+                readonly title: "Fewer merge surprises";
+                readonly body: "Catch upgrade impact while the PR is still small.";
+            }, {
+                readonly title: "High-signal only";
+                readonly body: "MergeSignal only interrupts you when an upgrade deserves attention.";
+            }];
+        };
+    };
+    /** Repository dashboard PR cards — reviewer-oriented semantics (not engine/scoring docs). */
+    readonly dashboardPrCard: {
+        readonly intro: "The repository dashboard is a runtime-aware review surface for open upgrade pull requests: triage by merge recommendation, then read operational context on each card.";
+        readonly posture: `Posture indicates the merge recommendation (${string}, ${string}, ${string}).`;
+        readonly exposure: "Exposure indicates how broadly the upgrade touches runtime-relevant application areas.";
+        readonly exposureCategoriesLead: "On each scanned card, exposure reads as one of:";
+        readonly exposureCategories: readonly string[];
+        readonly cardBody: "Below the verdict, scanned cards surface up to three compact operational observations (transitive volume, blast radius, duplicate versions, and related topology signals) when the engine finds mappable structure.";
+    };
+};
+/** Illustrative scan-card example for homepage proof band and getting-started. */
+export declare const primaryPrExample: {
+    readonly package: "express";
+    readonly message: "This upgrade affects middleware ordering used in auth routes.";
+    readonly where: readonly ["apps/api/src/middleware/auth.ts - auth guard depends on middleware order", "apps/api/src/routes/account.ts - protected handlers assume validation ran first"];
+};
+/** All homepage section row bodies for word-count validation. */
+export declare function homepageSectionRowBodies(): string[];
+//# sourceMappingURL=productMessaging.d.ts.map

package/dist/productMessaging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"productMessaging.d.ts","sourceRoot":"","sources":["../src/productMessaging.ts"],"names":[],"mappings":"AAGA;;GAEG;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAmF3B,6FAA6F;;;;;;;;;CAYrF,CAAC;AAEX,kFAAkF;AAClF,eAAO,MAAM,gBAAgB;;;;CAOnB,CAAC;AAEX,iEAAiE;AACjE,wBAAgB,wBAAwB,IAAI,MAAM,EAAE,CAOnD"}