@mergesignal/shared 0.12.1 → 0.12.2

package/dist/presentation/bundleAccessorParity.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * V1 public bundle transport — ScanPresentationBundle vs contracts extractor.
+ *
+ * Engine OutcomePresentationBundle uses the same `extractAuthoredCommunication()`
+ * from `@mergesignal/contracts`; engine-side accessor transport is covered in
+ * mergesignal-engine `packages/worker/src/outcome-presentation.test.ts`.
+ */
+export {};
+//# sourceMappingURL=bundleAccessorParity.test.d.ts.map

package/dist/presentation/bundleAccessorParity.test.d.ts.map

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

package/dist/presentation/bundleAccessorParity.test.js

@@ -0,0 +1,126 @@
+/**
+ * V1 public bundle transport — ScanPresentationBundle vs contracts extractor.
+ *
+ * Engine OutcomePresentationBundle uses the same `extractAuthoredCommunication()`
+ * from `@mergesignal/contracts`; engine-side accessor transport is covered in
+ * mergesignal-engine `packages/worker/src/outcome-presentation.test.ts`.
+ */
+import { extractAuthoredCommunication, parseAssessmentOrThrow, } from "@mergesignal/contracts";
+import { describe, expect, it } from "vitest";
+import { buildScanPresentationBundle } from "./orchestration/buildScanPresentationBundle.js";
+function scanResultWith(assessment) {
+    return {
+        totalScore: 70,
+        layerScores: {
+            security: 70,
+            maintainability: 70,
+            ecosystem: 70,
+            upgradeImpact: 70,
+        },
+        findings: [],
+        generatedAt: "2026-01-01T00:00:00Z",
+        changedPackages: assessment.reviewFocalPoint.anchors,
+        methodologyVersion: "mergesignal-engine/test",
+        assessment,
+        decision: {
+            recommendation: "needs_review",
+            confidence: "medium",
+            reasoning: [],
+        },
+        insights: [],
+    };
+}
+function baseAssessment() {
+    return {
+        reviewFocalPoint: {
+            episodeShape: "single_anchor",
+            anchors: ["pkg-a"],
+            election: { grounding: [], exclusions: [] },
+        },
+        reachScope: { packages: ["pkg-a"], maxBucket: "moderate" },
+        verificationScope: { packages: ["pkg-a"], focus: [] },
+        posture: "needs_review",
+        confidence: "medium",
+        primaryConcern: null,
+        concerns: [],
+        factors: [],
+        changeClasses: [],
+        presentation: {
+            narrativeIntensity: "standard",
+            reachVisibility: "contextual",
+            verificationIntensity: "advisory",
+            insightEmissionFloor: "full",
+            reportMode: "high_signal_pr",
+        },
+        reasoning: [],
+        confidenceRationale: "Confidence is medium.",
+    };
+}
+function pickAccessors(bundle) {
+    return {
+        trustLine: bundle.trustLine,
+        whyThisPackageLine: bundle.whyThisPackageLine,
+        notAffectedLine: bundle.notAffectedLine,
+        resolutionLine: bundle.resolutionLine,
+        reasoningLines: [...bundle.reasoningLines],
+        guidanceLines: [...bundle.guidanceLines],
+        concernContextLines: [...bundle.concernContextLines],
+    };
+}
+function assertPublicBundleMatchesContractsExtractor(assessment, label) {
+    const normalized = parseAssessmentOrThrow(assessment);
+    const expected = extractAuthoredCommunication(normalized);
+    const publicBundle = buildScanPresentationBundle({
+        result: scanResultWith(assessment),
+        pipelineStatus: "done",
+    });
+    expect(publicBundle, `${label}: public bundle`).not.toBeNull();
+    expect(pickAccessors(publicBundle), label).toEqual(pickAccessors(expected));
+}
+describe("V1 bundle transport: public bundle matches contracts extractor", () => {
+    it("cleared: identical AuthoredCommunicationAccessors", () => {
+        assertPublicBundleMatchesContractsExtractor({
+            ...baseAssessment(),
+            outcome: "cleared",
+            reasoning: ["Peer dependency constraints verified."],
+            notAffectedLine: "No repository code paths are affected by export compatibility — this dimension is outside the review scope.",
+            reviewFocalPoint: {
+                ...baseAssessment().reviewFocalPoint,
+                electionSummary: "`pkg-a` was selected as the primary review anchor because it has the highest repository reach.",
+            },
+        }, "cleared");
+    });
+    it("bounded_verify: identical AuthoredCommunicationAccessors", () => {
+        assertPublicBundleMatchesContractsExtractor({
+            ...baseAssessment(),
+            outcome: "bounded_verify",
+            reasoning: ["Automation stopped before all dimensions were verified."],
+            verificationScope: {
+                packages: ["pkg-a"],
+                focus: [],
+                guidance: ["Verify route handler at `src/server.ts:42`."],
+            },
+            resolutionLine: "A passing automated verification for this dimension would make this deterministic.",
+            concerns: [
+                {
+                    kind: "confirmed_runtime_usage",
+                    rank: 1,
+                    packages: ["pkg-a"],
+                    evidenceRefs: [],
+                    context: "Runtime usage: `pkg-a` — used in 3 files.",
+                },
+            ],
+        }, "bounded_verify");
+    });
+    it("abstain: identical AuthoredCommunicationAccessors", () => {
+        assertPublicBundleMatchesContractsExtractor({
+            ...baseAssessment(),
+            outcome: "abstain",
+            reasoning: [
+                "Cannot verify `pkg-a`: package artifacts are not publicly accessible.",
+            ],
+            resolutionLine: "Granting access to `pkg-a` artifacts or publishing them would allow deterministic verification.",
+            abstainReasons: [{ kind: "private_package", packageName: "pkg-a" }],
+        }, "abstain");
+    });
+});

package/dist/presentation/decisionSurface.test.d.ts

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

package/dist/presentation/decisionSurface.test.d.ts.map

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

package/dist/presentation/decisionSurface.test.js

@@ -0,0 +1,290 @@
+import { extractAuthoredCommunication } from "@mergesignal/contracts";
+import { describe, expect, it } from "vitest";
+import { minimalReviewFocalPoint, reachScopeFor, verificationScopeFor, withAssessmentScope, } from "../fixtures/assessmentScopeFixtures.js";
+import { buildScanPresentationBundle } from "./orchestration/buildScanPresentationBundle.js";
+// ─── Vocabulary firewall ──────────────────────────────────────────────────────
+/** Engine vocabulary that must never appear in any developer-facing authored string. */
+const ENGINE_VOCABULARY = [
+    "constraint_satisfiability",
+    "lockfile_integrity",
+    "type_surface_compatibility",
+    "export_resolution",
+    "peer_dependency",
+    "engine_constraint",
+    "no_impact_proven",
+    "proof_pass",
+    "bounded_verify",
+    "representative_precision_only",
+    "architectural_precision_only",
+    "clearanceEnvelope",
+    "coverageClass",
+    "precisionLevel",
+    "proofArtifact",
+    "packageOutcome",
+    "qualityClass",
+    "qualityBasis",
+    "proofFingerprint",
+    "observationId",
+    "dimension_verification",
+];
+// ─── Fixture helpers ──────────────────────────────────────────────────────────
+function scanResultWith(assessment) {
+    return {
+        totalScore: 70,
+        layerScores: {
+            security: 70,
+            maintainability: 70,
+            ecosystem: 70,
+            upgradeImpact: 70,
+        },
+        findings: [],
+        generatedAt: "2026-01-01T00:00:00Z",
+        changedPackages: assessment.reviewFocalPoint.anchors,
+        methodologyVersion: "mergesignal-engine/test",
+        assessment,
+        decision: {
+            recommendation: "needs_review",
+            confidence: "medium",
+            reasoning: [],
+        },
+        insights: [],
+    };
+}
+function assessmentWithTrustLine() {
+    return withAssessmentScope({
+        posture: "safe",
+        confidence: "high",
+        primaryConcern: null,
+        concerns: [],
+        factors: [],
+        changeClasses: [],
+        presentation: {
+            narrativeIntensity: "standard",
+            reachVisibility: "contextual",
+            verificationIntensity: "none",
+            insightEmissionFloor: "full",
+            reportMode: "high_signal_pr",
+        },
+        reasoning: [
+            "All peer dependency constraints verified — no runtime breakage confirmed.",
+            "Export compatibility proven unused in this repository.",
+        ],
+        confidenceRationale: "Confidence is high: all assessed dimensions were verified by deterministic proof.",
+    }, {
+        reviewFocalPoint: minimalReviewFocalPoint(["express"]),
+        reachScope: reachScopeFor(["express"]),
+        verificationScope: verificationScopeFor(["express"]),
+    });
+}
+function assessmentWithElectionSummary() {
+    return withAssessmentScope({
+        posture: "needs_review",
+        confidence: "medium",
+        primaryConcern: "confirmed_runtime_usage",
+        concerns: [
+            {
+                kind: "confirmed_runtime_usage",
+                rank: 1,
+                packages: ["fastify"],
+                evidenceRefs: [],
+                context: "Runtime usage: `fastify` — used in HTTP request handling.",
+            },
+        ],
+        factors: ["confirmed_runtime_usage"],
+        changeClasses: ["runtime_upgrade"],
+        presentation: {
+            narrativeIntensity: "standard",
+            reachVisibility: "contextual",
+            verificationIntensity: "required",
+            insightEmissionFloor: "full",
+            reportMode: "high_signal_pr",
+        },
+        reasoning: [
+            "fastify is used in HTTP request handling in this repository.",
+        ],
+        confidenceRationale: "Confidence is medium: runtime usage was observed but proof coverage is representative.",
+        notAffectedLine: null,
+        resolutionLine: null,
+    }, {
+        reviewFocalPoint: {
+            episodeShape: "single_anchor",
+            anchors: ["fastify"],
+            electionSummary: "`fastify` was selected as the review anchor over `fastify-plugin` due to higher runtime reach.",
+            election: {
+                grounding: [
+                    {
+                        packageName: "fastify",
+                        reason: "highest_runtime_reach",
+                        decidedBy: "reach",
+                        evidenceRefs: [],
+                    },
+                ],
+                exclusions: [
+                    {
+                        packageName: "fastify-plugin",
+                        reason: "lower_runtime_reach",
+                        lostOn: "reach",
+                        evidenceRefs: [],
+                    },
+                ],
+            },
+        },
+        reachScope: reachScopeFor(["fastify"]),
+        verificationScope: verificationScopeFor(["fastify"]),
+    });
+}
+function assessmentUncontestedElection() {
+    return withAssessmentScope({
+        posture: "needs_review",
+        confidence: "medium",
+        primaryConcern: "confirmed_runtime_usage",
+        concerns: [],
+        factors: ["confirmed_runtime_usage"],
+        changeClasses: ["runtime_upgrade"],
+        presentation: {
+            narrativeIntensity: "standard",
+            reachVisibility: "contextual",
+            verificationIntensity: "required",
+            insightEmissionFloor: "full",
+            reportMode: "high_signal_pr",
+        },
+        reasoning: ["express is used in HTTP request handling."],
+        confidenceRationale: "Confidence is high: runtime usage was directly observed.",
+    }, {
+        reviewFocalPoint: minimalReviewFocalPoint(["express"]),
+        reachScope: reachScopeFor(["express"]),
+        verificationScope: verificationScopeFor(["express"]),
+    });
+}
+function assessmentWithQ8Q9() {
+    return withAssessmentScope({
+        posture: "needs_review",
+        confidence: "medium",
+        primaryConcern: "confirmed_runtime_usage",
+        concerns: [],
+        factors: ["confirmed_runtime_usage"],
+        changeClasses: ["runtime_upgrade"],
+        outcome: "bounded_verify",
+        presentation: {
+            narrativeIntensity: "standard",
+            reachVisibility: "contextual",
+            verificationIntensity: "required",
+            insightEmissionFloor: "full",
+            reportMode: "high_signal_pr",
+        },
+        reasoning: ["Automation stopped before all dimensions were verified."],
+        confidenceRationale: "Confidence is medium: bounded verification is required.",
+        notAffectedLine: "No repository code paths are affected by export compatibility — this dimension is outside the review scope.",
+        resolutionLine: "A passing automated verification for this dimension would make this deterministic.",
+    }, {
+        reviewFocalPoint: minimalReviewFocalPoint(["express"]),
+        reachScope: reachScopeFor(["express"]),
+        verificationScope: {
+            packages: ["express"],
+            focus: [],
+            guidance: ["Verify route handler at `src/server.ts:42`."],
+        },
+    });
+}
+// ─── V1 bundle transport ──────────────────────────────────────────────────────
+describe("decision surface contract (V1) — bundle transport", () => {
+    it("trustLine carries confidenceRationale verbatim from assessment", () => {
+        const assessment = assessmentWithTrustLine();
+        const bundle = buildScanPresentationBundle({
+            result: scanResultWith(assessment),
+            pipelineStatus: "done",
+        });
+        expect(bundle).not.toBeNull();
+        expect(bundle.trustLine).toBe(assessment.confidenceRationale);
+    });
+    it("whyThisPackageLine carries electionSummary verbatim when present", () => {
+        const assessment = assessmentWithElectionSummary();
+        const bundle = buildScanPresentationBundle({
+            result: scanResultWith(assessment),
+            pipelineStatus: "done",
+        });
+        expect(bundle.whyThisPackageLine).toBe(assessment.reviewFocalPoint.electionSummary);
+    });
+    it("whyThisPackageLine is null when electionSummary is absent", () => {
+        const assessment = assessmentUncontestedElection();
+        const bundle = buildScanPresentationBundle({
+            result: scanResultWith(assessment),
+            pipelineStatus: "done",
+        });
+        expect(bundle.whyThisPackageLine).toBeNull();
+    });
+    it("reasoningLines and guidanceLines carry assessment arrays verbatim", () => {
+        const assessment = assessmentWithQ8Q9();
+        const bundle = buildScanPresentationBundle({
+            result: scanResultWith(assessment),
+            pipelineStatus: "done",
+        });
+        expect(bundle.reasoningLines).toEqual(assessment.reasoning);
+        expect(bundle.guidanceLines).toEqual(assessment.verificationScope.guidance ?? []);
+    });
+    it("notAffectedLine and resolutionLine survive parse and transport (Q8/Q9)", () => {
+        const assessment = assessmentWithQ8Q9();
+        const bundle = buildScanPresentationBundle({
+            result: scanResultWith(assessment),
+            pipelineStatus: "done",
+        });
+        expect(bundle.notAffectedLine).toBe(assessment.notAffectedLine);
+        expect(bundle.resolutionLine).toBe(assessment.resolutionLine);
+    });
+    it("concernContextLines carries concerns[].context verbatim", () => {
+        const assessment = assessmentWithElectionSummary();
+        const bundle = buildScanPresentationBundle({
+            result: scanResultWith(assessment),
+            pipelineStatus: "done",
+        });
+        expect(bundle.concernContextLines).toEqual([
+            "Runtime usage: `fastify` — used in HTTP request handling.",
+        ]);
+    });
+    it("public bundle accessors match extractAuthoredCommunication", () => {
+        const assessment = assessmentWithQ8Q9();
+        const normalized = assessment;
+        const expected = extractAuthoredCommunication(normalized);
+        const bundle = buildScanPresentationBundle({
+            result: scanResultWith(assessment),
+            pipelineStatus: "done",
+        });
+        expect(bundle.trustLine).toBe(expected.trustLine);
+        expect(bundle.whyThisPackageLine).toBe(expected.whyThisPackageLine);
+        expect(bundle.notAffectedLine).toBe(expected.notAffectedLine);
+        expect(bundle.resolutionLine).toBe(expected.resolutionLine);
+        expect(bundle.reasoningLines).toEqual(expected.reasoningLines);
+        expect(bundle.guidanceLines).toEqual(expected.guidanceLines);
+        expect(bundle.concernContextLines).toEqual(expected.concernContextLines);
+    });
+});
+// ─── Vocabulary firewall ──────────────────────────────────────────────────────
+describe("decision surface contract (V1) — vocabulary firewall on accessors", () => {
+    function assertNoEngineVocabulary(strings, context) {
+        for (const token of ENGINE_VOCABULARY) {
+            for (const str of strings) {
+                if (!str)
+                    continue;
+                expect(str, `${context}: must not contain engine token "${token}"`).not.toContain(token);
+            }
+        }
+    }
+    it("bundle accessors carry no engine vocabulary", () => {
+        const assessment = assessmentWithQ8Q9();
+        const bundle = buildScanPresentationBundle({
+            result: scanResultWith(assessment),
+            pipelineStatus: "done",
+        });
+        assertNoEngineVocabulary([
+            bundle.trustLine,
+            bundle.whyThisPackageLine,
+            bundle.notAffectedLine,
+            bundle.resolutionLine,
+            ...bundle.reasoningLines,
+            ...bundle.guidanceLines,
+            ...bundle.concernContextLines,
+        ], "bundle accessors");
+    });
+});
+// V3 surface delivery (Dashboard, Scan Details) is intentionally excluded from V1 graduation.
+// See presentDashboardCard / presentScanDetails adoption in V3 Surface Adoption roadmap.

package/dist/presentation/orchestration/buildScanPresentationBundle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buildScanPresentationBundle.d.ts","sourceRoot":"","sources":["../../../src/presentation/orchestration/buildScanPresentationBundle.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEtD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAE1E,MAAM,MAAM,gCAAgC,GAAG;IAC7C,MAAM,EAAE,UAAU,CAAC;IACnB,cAAc,EAAE,cAAc,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,gCAAgC,GACtC,sBAAsB,GAAG,IAAI,CA4B/B"}
+{"version":3,"file":"buildScanPresentationBundle.d.ts","sourceRoot":"","sources":["../../../src/presentation/orchestration/buildScanPresentationBundle.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEtD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAE1E,MAAM,MAAM,gCAAgC,GAAG;IAC7C,MAAM,EAAE,UAAU,CAAC;IACnB,cAAc,EAAE,cAAc,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,gCAAgC,GACtC,sBAAsB,GAAG,IAAI,CA8B/B"}

package/dist/presentation/orchestration/buildScanPresentationBundle.js

@@ -1,4 +1,4 @@
-import { parseAssessmentOrThrow } from "@mergesignal/contracts";
+import { extractAuthoredCommunication, parseAssessmentOrThrow, } from "@mergesignal/contracts";
 import { toPublicPresentation } from "../../assessmentPresentationUtils.js";
 import { deriveScanNarrative } from "../../deriveScanNarrative.js";
 import { buildProfileFromAssessment } from "../profile/buildProfileFromAssessment.js";
@@ -23,11 +23,13 @@ export function buildScanPresentationBundle(input) {
     const presentation = toPublicPresentation(normalized.presentation);
     const profile = buildProfileFromAssessment(normalized, presentation, input.result);
     const facts = deriveScanNarrative(input.result);
+    const authored = extractAuthoredCommunication(normalized);
     return {
         assessment: normalized,
         presentation,
         profile,
         facts,
         result: input.result,
+        ...authored,
     };
 }

package/dist/presentation/orchestration/scanPresentationBundle.d.ts

@@ -1,19 +1,19 @@
-import type { Assessment, AssessmentPresentationPublic } from "@mergesignal/contracts";
+import type { Assessment, AssessmentPresentationPublic, AuthoredCommunicationAccessors } from "@mergesignal/contracts";
 import type { ScanNarrativeFacts } from "../../scanNarrativeFacts.js";
 import type { ScanResult } from "../../types.js";
 import type { PresentationProfile } from "../profile/presentationProfile.js";
-export type ScanPresentationBundle = {
+export type ScanPresentationBundle = AuthoredCommunicationAccessors & {
     assessment: Assessment;
     presentation: AssessmentPresentationPublic;
     profile: PresentationProfile;
     /**
      * Evidence layout only — not an authority for posture, concern, or intensity.
-     * @deprecated Prefer assessment + repoIntelligence on result for new code.
+     * @deprecated Prefer bundle accessors for authored communication; V3 migration only.
      */
     facts: ScanNarrativeFacts;
     /**
      * Projection-only reference to the raw scan payload.
-     * Presenters may read fields for formatting but must NOT re-derive interpretation.
+     * @deprecated V3 migration only — surfaces must use accessors for decision meaning.
      */
     result: ScanResult;
 };

package/dist/presentation/orchestration/scanPresentationBundle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scanPresentationBundle.d.ts","sourceRoot":"","sources":["../../../src/presentation/orchestration/scanPresentationBundle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,4BAA4B,EAC7B,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AAE7E,MAAM,MAAM,sBAAsB,GAAG;IACnC,UAAU,EAAE,UAAU,CAAC;IACvB,YAAY,EAAE,4BAA4B,CAAC;IAC3C,OAAO,EAAE,mBAAmB,CAAC;IAC7B;;;OAGG;IACH,KAAK,EAAE,kBAAkB,CAAC;IAC1B;;;OAGG;IACH,MAAM,EAAE,UAAU,CAAC;CACpB,CAAC"}
+{"version":3,"file":"scanPresentationBundle.d.ts","sourceRoot":"","sources":["../../../src/presentation/orchestration/scanPresentationBundle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,4BAA4B,EAC5B,8BAA8B,EAC/B,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AAE7E,MAAM,MAAM,sBAAsB,GAAG,8BAA8B,GAAG;IACpE,UAAU,EAAE,UAAU,CAAC;IACvB,YAAY,EAAE,4BAA4B,CAAC;IAC3C,OAAO,EAAE,mBAAmB,CAAC;IAC7B;;;OAGG;IACH,KAAK,EAAE,kBAAkB,CAAC;IAC1B;;;OAGG;IACH,MAAM,EAAE,UAAU,CAAC;CACpB,CAAC"}

package/dist/scanResultSchema.d.ts

@@ -245,6 +245,164 @@ export declare const engineOutputScanResultSchema: z.ZodObject<{
         }, z.core.$strip>;
         reasoning: z.ZodArray<z.ZodString>;
         confidenceRationale: z.ZodString;
+        notAffectedLine: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        resolutionLine: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        outcome: z.ZodOptional<z.ZodEnum<{
+            cleared: "cleared";
+            proven_broken: "proven_broken";
+            bounded_verify: "bounded_verify";
+            abstain: "abstain";
+        }>>;
+        perPackageOutcome: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            packageName: z.ZodString;
+            outcome: z.ZodEnum<{
+                cleared: "cleared";
+                proven_broken: "proven_broken";
+                bounded_verify: "bounded_verify";
+                abstain: "abstain";
+            }>;
+            proofArtifactRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            clearanceEnvelopeRef: z.ZodOptional<z.ZodString>;
+            boundedVerifyTargetRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        clearanceEnvelopes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            packageName: z.ZodString;
+            clearedDimensions: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    type_surface: "type_surface";
+                    manifest: "manifest";
+                    exports: "exports";
+                    entrypoint: "entrypoint";
+                    peer_dependency: "peer_dependency";
+                    engine_constraint: "engine_constraint";
+                    artifact_layout: "artifact_layout";
+                    documented_breaking: "documented_breaking";
+                }>;
+                basis: z.ZodEnum<{
+                    proof_pass: "proof_pass";
+                    no_impact_proven: "no_impact_proven";
+                }>;
+                proofArtifactRef: z.ZodOptional<z.ZodString>;
+                noImpactProofRef: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            unclearedDimensions: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    type_surface: "type_surface";
+                    manifest: "manifest";
+                    exports: "exports";
+                    entrypoint: "entrypoint";
+                    peer_dependency: "peer_dependency";
+                    engine_constraint: "engine_constraint";
+                    artifact_layout: "artifact_layout";
+                    documented_breaking: "documented_breaking";
+                }>;
+                reason: z.ZodEnum<{
+                    proof_failed: "proof_failed";
+                    proof_inconclusive: "proof_inconclusive";
+                    no_producer_available: "no_producer_available";
+                    representative_precision_only: "representative_precision_only";
+                    architectural_precision_only: "architectural_precision_only";
+                    opaque_delta: "opaque_delta";
+                    hypothesized_breaking: "hypothesized_breaking";
+                }>;
+                boundedVerifyTarget: z.ZodOptional<z.ZodObject<{
+                    targetId: z.ZodString;
+                    packageName: z.ZodString;
+                    kind: z.ZodEnum<{
+                        file_location: "file_location";
+                        config_path: "config_path";
+                        behavioral_scenario: "behavioral_scenario";
+                    }>;
+                    file: z.ZodOptional<z.ZodString>;
+                    line: z.ZodOptional<z.ZodNumber>;
+                    configKey: z.ZodOptional<z.ZodString>;
+                    scenario: z.ZodOptional<z.ZodString>;
+                    whatToVerify: z.ZodString;
+                    whyAutomationStopped: z.ZodString;
+                    whatProofWouldResolveIt: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            coverageClass: z.ZodEnum<{
+                none: "none";
+                full: "full";
+                representative: "representative";
+            }>;
+        }, z.core.$strip>>>;
+        boundedVerifyTargets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            targetId: z.ZodString;
+            packageName: z.ZodString;
+            kind: z.ZodEnum<{
+                file_location: "file_location";
+                config_path: "config_path";
+                behavioral_scenario: "behavioral_scenario";
+            }>;
+            file: z.ZodOptional<z.ZodString>;
+            line: z.ZodOptional<z.ZodNumber>;
+            configKey: z.ZodOptional<z.ZodString>;
+            scenario: z.ZodOptional<z.ZodString>;
+            whatToVerify: z.ZodString;
+            whyAutomationStopped: z.ZodString;
+            whatProofWouldResolveIt: z.ZodString;
+        }, z.core.$strip>>>;
+        evidenceSufficiencyVerdict: z.ZodOptional<z.ZodObject<{
+            sufficient: z.ZodBoolean;
+            clearanceEligible: z.ZodBoolean;
+            provenBrokenEligible: z.ZodBoolean;
+            boundedVerifyEligible: z.ZodBoolean;
+            blockers: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    private_package: "private_package";
+                    opaque_mutation: "opaque_mutation";
+                    unsupported_ecosystem: "unsupported_ecosystem";
+                    partial_monorepo_scan: "partial_monorepo_scan";
+                    repository_coverage_insufficient: "repository_coverage_insufficient";
+                    package_facts_missing: "package_facts_missing";
+                    correlation_abstained: "correlation_abstained";
+                    proof_coverage_insufficient: "proof_coverage_insufficient";
+                    proof_execution_failed: "proof_execution_failed";
+                    hypothesized_breaking_unresolved: "hypothesized_breaking_unresolved";
+                    advisory_blocking: "advisory_blocking";
+                    conflicting_proof_results: "conflicting_proof_results";
+                }>;
+                packageName: z.ZodOptional<z.ZodString>;
+                detail: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            perPackage: z.ZodRecord<z.ZodString, z.ZodObject<{
+                packageName: z.ZodString;
+                clearanceEligible: z.ZodBoolean;
+                provenBrokenEligible: z.ZodBoolean;
+                blockers: z.ZodArray<z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        private_package: "private_package";
+                        opaque_mutation: "opaque_mutation";
+                        unsupported_ecosystem: "unsupported_ecosystem";
+                        partial_monorepo_scan: "partial_monorepo_scan";
+                        repository_coverage_insufficient: "repository_coverage_insufficient";
+                        package_facts_missing: "package_facts_missing";
+                        correlation_abstained: "correlation_abstained";
+                        proof_coverage_insufficient: "proof_coverage_insufficient";
+                        proof_execution_failed: "proof_execution_failed";
+                        hypothesized_breaking_unresolved: "hypothesized_breaking_unresolved";
+                        advisory_blocking: "advisory_blocking";
+                        conflicting_proof_results: "conflicting_proof_results";
+                    }>;
+                    packageName: z.ZodOptional<z.ZodString>;
+                    detail: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        abstainReasons: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                private_package: "private_package";
+                opaque_mutation: "opaque_mutation";
+                unsupported_ecosystem: "unsupported_ecosystem";
+                partial_monorepo_scan: "partial_monorepo_scan";
+                no_honest_bounded_target: "no_honest_bounded_target";
+                insufficient_collection: "insufficient_collection";
+            }>;
+            packageName: z.ZodOptional<z.ZodString>;
+            detail: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
     }, z.core.$strip>;
     prRisk: z.ZodObject<{
         score: z.ZodNumber;

package/dist/scanResultSchema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scanResultSchema.d.ts","sourceRoot":"","sources":["../src/scanResultSchema.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,uBAAuB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAEtE,wGAAwG;AACxG,eAAO,MAAM,eAAe,EAAG,GAAY,CAAC;AAE5C,+EAA+E;AAC/E,eAAO,MAAM,sBAAsB,EAAG,GAAY,CAAC;AAmBnD;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAc/D;AAED;;;;GAIG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8Bb,CAAC;AAUjB;;;GAGG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMvC,CAAC;AAEH,MAAM,MAAM,kCAAkC,GAAG;IAC/C,EAAE,EAAE,KAAK,CAAC;IACV,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,kCAAkC,GAAG;IAC/C,EAAE,EAAE,IAAI,CAAC;IACT,MAAM,EAAE,uBAAuB,CAAC;CACjC,CAAC;AAEF,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,OAAO,GACZ,kCAAkC,GAAG,kCAAkC,CAezE;AAED,uFAAuF;AACvF,wBAAgB,kCAAkC,CAChD,IAAI,EAAE,OAAO,GACZ,uBAAuB,CAMzB;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,EAAE,EAAE,KAAK,CAAC;IACV,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,EAAE,EAAE,IAAI,CAAC;IACT,MAAM,EAAE,UAAU,CAAC;CACpB,CAAC;AAEF,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,OAAO,GACZ,sBAAsB,GAAG,sBAAsB,CAajD;AAED,yEAAyE;AACzE,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,OAAO,GAAG,UAAU,CAMhE"}
+{"version":3,"file":"scanResultSchema.d.ts","sourceRoot":"","sources":["../src/scanResultSchema.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,uBAAuB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAEtE,wGAAwG;AACxG,eAAO,MAAM,eAAe,EAAG,GAAY,CAAC;AAE5C,+EAA+E;AAC/E,eAAO,MAAM,sBAAsB,EAAG,GAAY,CAAC;AAmBnD;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAc/D;AAED;;;;GAIG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8Bb,CAAC;AAUjB;;;GAGG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMvC,CAAC;AAEH,MAAM,MAAM,kCAAkC,GAAG;IAC/C,EAAE,EAAE,KAAK,CAAC;IACV,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,kCAAkC,GAAG;IAC/C,EAAE,EAAE,IAAI,CAAC;IACT,MAAM,EAAE,uBAAuB,CAAC;CACjC,CAAC;AAEF,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,OAAO,GACZ,kCAAkC,GAAG,kCAAkC,CAezE;AAED,uFAAuF;AACvF,wBAAgB,kCAAkC,CAChD,IAAI,EAAE,OAAO,GACZ,uBAAuB,CAMzB;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,EAAE,EAAE,KAAK,CAAC;IACV,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,EAAE,EAAE,IAAI,CAAC;IACT,MAAM,EAAE,UAAU,CAAC;CACpB,CAAC;AAEF,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,OAAO,GACZ,sBAAsB,GAAG,sBAAsB,CAajD;AAED,yEAAyE;AACzE,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,OAAO,GAAG,UAAU,CAMhE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mergesignal/shared",
-  "version": "0.12.1",
+  "version": "0.12.2",
   "description": "MergeSignal shared scan contract, presentation policy, and trusted validation",
   "type": "module",
   "main": "./dist/index.js",