@mergesignal/shared 0.12.3 → 0.14.0

package/dist/assessment/authoredCommunication.d.ts

@@ -0,0 +1,30 @@
+import type { Assessment } from "./types.js";
+/**
+ * Canonical authored-communication accessors for Presentation Bundle transport.
+ *
+ * Both engine OutcomePresentationBundle and public ScanPresentationBundle carry
+ * these fields verbatim from Expression-authored Assessment fields.
+ */
+export type AuthoredCommunicationAccessors = {
+    /** Q6 — assessment.confidenceRationale verbatim; always present. */
+    readonly trustLine: string;
+    /** Q7 — assessment.reviewFocalPoint.electionSummary verbatim; null when uncontested. */
+    readonly whyThisPackageLine: string | null;
+    /** Q8 — assessment.notAffectedLine verbatim; null when nothing was proven unused. */
+    readonly notAffectedLine: string | null;
+    /** Q9 — assessment.resolutionLine verbatim; null for cleared/proven_broken. */
+    readonly resolutionLine: string | null;
+    /** Q1–Q5 — assessment.reasoning[] verbatim, in order. */
+    readonly reasoningLines: readonly string[];
+    /** Q4 — assessment.verificationScope.guidance[] verbatim; empty when absent. */
+    readonly guidanceLines: readonly string[];
+    /** Quantified concern context — concerns[].context values, in concern order. */
+    readonly concernContextLines: readonly string[];
+};
+/**
+ * Extract authored communication from a parsed Assessment for bundle transport.
+ *
+ * Copy-only: no wording logic, no markdown assembly, no intelligence derivation.
+ */
+export declare function extractAuthoredCommunication(assessment: Assessment): AuthoredCommunicationAccessors;
+//# sourceMappingURL=authoredCommunication.d.ts.map

package/dist/assessment/authoredCommunication.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authoredCommunication.d.ts","sourceRoot":"","sources":["../../src/assessment/authoredCommunication.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C;;;;;GAKG;AACH,MAAM,MAAM,8BAA8B,GAAG;IAC3C,oEAAoE;IACpE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,wFAAwF;IACxF,QAAQ,CAAC,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3C,qFAAqF;IACrF,QAAQ,CAAC,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IACxC,+EAA+E;IAC/E,QAAQ,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IACvC,yDAAyD;IACzD,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,gFAAgF;IAChF,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C,gFAAgF;IAChF,QAAQ,CAAC,mBAAmB,EAAE,SAAS,MAAM,EAAE,CAAC;CACjD,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,UAAU,GACrB,8BAA8B,CAehC"}

package/dist/assessment/authoredCommunication.js

@@ -0,0 +1,18 @@
+/**
+ * Extract authored communication from a parsed Assessment for bundle transport.
+ *
+ * Copy-only: no wording logic, no markdown assembly, no intelligence derivation.
+ */
+export function extractAuthoredCommunication(assessment) {
+    return {
+        trustLine: assessment.confidenceRationale,
+        whyThisPackageLine: assessment.reviewFocalPoint.electionSummary ?? null,
+        notAffectedLine: assessment.notAffectedLine ?? null,
+        resolutionLine: assessment.resolutionLine ?? null,
+        reasoningLines: assessment.reasoning,
+        guidanceLines: assessment.verificationScope.guidance ?? [],
+        concernContextLines: assessment.concerns
+            .map((concern) => concern.context)
+            .filter((context) => context !== undefined && context.length > 0),
+    };
+}

package/dist/assessment/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./literals.js";
+export * from "./types.js";
+export { assessmentSchema, parseAssessmentOrThrow, safeParseAssessment, type SafeParseAssessmentResult, } from "./schema.js";
+export { ASSESSMENT_ABI, type AssessmentAbi } from "./version.js";
+export { extractAuthoredCommunication, type AuthoredCommunicationAccessors, } from "./authoredCommunication.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/assessment/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,OAAO,EACL,gBAAgB,EAChB,sBAAsB,EACtB,mBAAmB,EACnB,KAAK,yBAAyB,GAC/B,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,cAAc,EAAE,KAAK,aAAa,EAAE,MAAM,cAAc,CAAC;AAClE,OAAO,EACL,4BAA4B,EAC5B,KAAK,8BAA8B,GACpC,MAAM,4BAA4B,CAAC"}

package/dist/assessment/index.js

@@ -0,0 +1,5 @@
+export * from "./literals.js";
+export * from "./types.js";
+export { assessmentSchema, parseAssessmentOrThrow, safeParseAssessment, } from "./schema.js";
+export { ASSESSMENT_ABI } from "./version.js";
+export { extractAuthoredCommunication, } from "./authoredCommunication.js";

package/dist/assessment/literals.d.ts

@@ -0,0 +1,44 @@
+/** Assessment posture on the wire. */
+export declare const ASSESSMENT_POSTURES: readonly ["safe", "needs_review", "risky"];
+/** Engine confidence in the Assessment. */
+export declare const ASSESSMENT_CONFIDENCES: readonly ["low", "medium", "high"];
+/** Per-package change classification tokens. */
+export declare const CHANGE_CLASSES: readonly ["tooling_maintenance", "test_infra", "runtime_patch", "runtime_upgrade", "security_advisory", "breaking_change", "ecosystem_unknown", "bulk_mixed", "removal"];
+/** Structured merge concern kinds. */
+export declare const MERGE_CONCERN_KINDS: readonly ["unresolved_runtime_exposure", "security_finding", "breaking_or_major", "behavioral_change", "ecosystem_risk", "insufficient_evidence", "graph_baseline_only"];
+/** Presentation narrative intensity. */
+export declare const NARRATIVE_INTENSITIES: readonly ["minimal", "standard", "elevated"];
+/** Presentation reach visibility. */
+export declare const REACH_VISIBILITIES: readonly ["hidden", "contextual", "prominent"];
+/** Presentation verification intensity. */
+export declare const VERIFICATION_INTENSITIES: readonly ["none", "advisory", "required"];
+/** Presentation insight emission floor. */
+export declare const INSIGHT_EMISSION_FLOORS: readonly ["none", "explain_only", "full"];
+/** Report presentation mode on wire. */
+export declare const ASSESSMENT_REPORT_MODES: readonly ["lightweight_pr_graph_baseline", "high_signal_pr"];
+/** Review episode shape literals (Focal Point ABI 2). */
+export declare const REVIEW_EPISODE_SHAPES: readonly ["single_anchor", "multi_anchor", "parent_supporting", "coupled_pair", "tooling_bundle", "structural"];
+/** Focal election dimension literals. */
+export declare const FOCAL_ELECTION_DIMENSIONS: readonly ["concern", "reach", "changeSeverity", "repository_importance", "role_salience_tiebreak"];
+/** Reach bucket literals for {@link ReachScope.maxBucket}. */
+export declare const REACH_BUCKETS: readonly ["very_low", "low", "moderate", "high"];
+/**
+ * Delta dimension kinds on the public Assessment clearance-envelope wire.
+ * Minimal literal set required by assessmentSchema clearance validation.
+ */
+export declare const DELTA_DIMENSION_KINDS: readonly ["manifest", "exports", "entrypoint", "peer_dependency", "engine_constraint", "type_surface", "artifact_layout", "documented_breaking"];
+/** The four deterministic outcomes produced by Assessment (ABI 4). */
+export declare const ASSESSMENT_OUTCOMES: readonly ["cleared", "proven_broken", "bounded_verify", "abstain"];
+/** Reasons for an Abstain outcome. */
+export declare const ABSTAIN_REASON_KINDS: readonly ["private_package", "opaque_mutation", "unsupported_ecosystem", "partial_monorepo_scan", "no_honest_bounded_target", "insufficient_collection"];
+/** Blocker kinds for EvidenceSufficiencyVerdict. */
+export declare const SUFFICIENCY_BLOCKER_KINDS: readonly ["repository_coverage_insufficient", "package_facts_missing", "opaque_mutation", "private_package", "correlation_abstained", "proof_coverage_insufficient", "proof_execution_failed", "unsupported_ecosystem", "partial_monorepo_scan", "hypothesized_breaking_unresolved", "advisory_blocking", "conflicting_proof_results"];
+/** Target kinds for BoundedVerifyTarget. */
+export declare const BOUNDED_VERIFY_TARGET_KINDS: readonly ["file_location", "config_path", "behavioral_scenario"];
+/** Basis for a cleared delta dimension in ClearanceEnvelope. */
+export declare const CLEARANCE_BASES: readonly ["proof_pass", "no_impact_proven"];
+/** Reasons a delta dimension is uncleared in ClearanceEnvelope. */
+export declare const UNCLEARED_REASONS: readonly ["proof_failed", "proof_inconclusive", "no_producer_available", "representative_precision_only", "architectural_precision_only", "opaque_delta", "hypothesized_breaking"];
+/** Coverage class for ClearanceEnvelope. */
+export declare const COVERAGE_CLASSES: readonly ["full", "representative", "none"];
+//# sourceMappingURL=literals.d.ts.map

package/dist/assessment/literals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"literals.d.ts","sourceRoot":"","sources":["../../src/assessment/literals.ts"],"names":[],"mappings":"AAAA,sCAAsC;AACtC,eAAO,MAAM,mBAAmB,4CAA6C,CAAC;AAE9E,2CAA2C;AAC3C,eAAO,MAAM,sBAAsB,oCAAqC,CAAC;AAEzE,gDAAgD;AAChD,eAAO,MAAM,cAAc,0KAUjB,CAAC;AAEX,sCAAsC;AACtC,eAAO,MAAM,mBAAmB,0KAQtB,CAAC;AAEX,wCAAwC;AACxC,eAAO,MAAM,qBAAqB,8CAIxB,CAAC;AAEX,qCAAqC;AACrC,eAAO,MAAM,kBAAkB,gDAIrB,CAAC;AAEX,2CAA2C;AAC3C,eAAO,MAAM,wBAAwB,2CAI3B,CAAC;AAEX,2CAA2C;AAC3C,eAAO,MAAM,uBAAuB,2CAI1B,CAAC;AAEX,wCAAwC;AACxC,eAAO,MAAM,uBAAuB,8DAG1B,CAAC;AAEX,yDAAyD;AACzD,eAAO,MAAM,qBAAqB,iHAOxB,CAAC;AAEX,yCAAyC;AACzC,eAAO,MAAM,yBAAyB,oGAM5B,CAAC;AAEX,8DAA8D;AAC9D,eAAO,MAAM,aAAa,kDAAmD,CAAC;AAE9E;;;GAGG;AACH,eAAO,MAAM,qBAAqB,kJASxB,CAAC;AAIX,sEAAsE;AACtE,eAAO,MAAM,mBAAmB,oEAKtB,CAAC;AAEX,sCAAsC;AACtC,eAAO,MAAM,oBAAoB,0JAOvB,CAAC;AAEX,oDAAoD;AACpD,eAAO,MAAM,yBAAyB,wUAa5B,CAAC;AAEX,4CAA4C;AAC5C,eAAO,MAAM,2BAA2B,kEAI9B,CAAC;AAEX,gEAAgE;AAChE,eAAO,MAAM,eAAe,6CAA8C,CAAC;AAE3E,mEAAmE;AACnE,eAAO,MAAM,iBAAiB,oLAQpB,CAAC;AAEX,4CAA4C;AAC5C,eAAO,MAAM,gBAAgB,6CAA8C,CAAC"}

package/dist/assessment/literals.js

@@ -0,0 +1,140 @@
+/** Assessment posture on the wire. */
+export const ASSESSMENT_POSTURES = ["safe", "needs_review", "risky"];
+/** Engine confidence in the Assessment. */
+export const ASSESSMENT_CONFIDENCES = ["low", "medium", "high"];
+/** Per-package change classification tokens. */
+export const CHANGE_CLASSES = [
+    "tooling_maintenance",
+    "test_infra",
+    "runtime_patch",
+    "runtime_upgrade",
+    "security_advisory",
+    "breaking_change",
+    "ecosystem_unknown",
+    "bulk_mixed",
+    "removal",
+];
+/** Structured merge concern kinds. */
+export const MERGE_CONCERN_KINDS = [
+    "unresolved_runtime_exposure",
+    "security_finding",
+    "breaking_or_major",
+    "behavioral_change",
+    "ecosystem_risk",
+    "insufficient_evidence",
+    "graph_baseline_only",
+];
+/** Presentation narrative intensity. */
+export const NARRATIVE_INTENSITIES = [
+    "minimal",
+    "standard",
+    "elevated",
+];
+/** Presentation reach visibility. */
+export const REACH_VISIBILITIES = [
+    "hidden",
+    "contextual",
+    "prominent",
+];
+/** Presentation verification intensity. */
+export const VERIFICATION_INTENSITIES = [
+    "none",
+    "advisory",
+    "required",
+];
+/** Presentation insight emission floor. */
+export const INSIGHT_EMISSION_FLOORS = [
+    "none",
+    "explain_only",
+    "full",
+];
+/** Report presentation mode on wire. */
+export const ASSESSMENT_REPORT_MODES = [
+    "lightweight_pr_graph_baseline",
+    "high_signal_pr",
+];
+/** Review episode shape literals (Focal Point ABI 2). */
+export const REVIEW_EPISODE_SHAPES = [
+    "single_anchor",
+    "multi_anchor",
+    "parent_supporting",
+    "coupled_pair",
+    "tooling_bundle",
+    "structural",
+];
+/** Focal election dimension literals. */
+export const FOCAL_ELECTION_DIMENSIONS = [
+    "concern",
+    "reach",
+    "changeSeverity",
+    "repository_importance",
+    "role_salience_tiebreak",
+];
+/** Reach bucket literals for {@link ReachScope.maxBucket}. */
+export const REACH_BUCKETS = ["very_low", "low", "moderate", "high"];
+/**
+ * Delta dimension kinds on the public Assessment clearance-envelope wire.
+ * Minimal literal set required by assessmentSchema clearance validation.
+ */
+export const DELTA_DIMENSION_KINDS = [
+    "manifest",
+    "exports",
+    "entrypoint",
+    "peer_dependency",
+    "engine_constraint",
+    "type_surface",
+    "artifact_layout",
+    "documented_breaking",
+];
+// --- ABI 4 outcome model literals ---
+/** The four deterministic outcomes produced by Assessment (ABI 4). */
+export const ASSESSMENT_OUTCOMES = [
+    "cleared",
+    "proven_broken",
+    "bounded_verify",
+    "abstain",
+];
+/** Reasons for an Abstain outcome. */
+export const ABSTAIN_REASON_KINDS = [
+    "private_package",
+    "opaque_mutation",
+    "unsupported_ecosystem",
+    "partial_monorepo_scan",
+    "no_honest_bounded_target",
+    "insufficient_collection",
+];
+/** Blocker kinds for EvidenceSufficiencyVerdict. */
+export const SUFFICIENCY_BLOCKER_KINDS = [
+    "repository_coverage_insufficient",
+    "package_facts_missing",
+    "opaque_mutation",
+    "private_package",
+    "correlation_abstained",
+    "proof_coverage_insufficient",
+    "proof_execution_failed",
+    "unsupported_ecosystem",
+    "partial_monorepo_scan",
+    "hypothesized_breaking_unresolved",
+    "advisory_blocking",
+    "conflicting_proof_results",
+];
+/** Target kinds for BoundedVerifyTarget. */
+export const BOUNDED_VERIFY_TARGET_KINDS = [
+    "file_location",
+    "config_path",
+    "behavioral_scenario",
+];
+/** Basis for a cleared delta dimension in ClearanceEnvelope. */
+export const CLEARANCE_BASES = ["proof_pass", "no_impact_proven"];
+/** Reasons a delta dimension is uncleared in ClearanceEnvelope. */
+export const UNCLEARED_REASONS = [
+    "proof_failed",
+    "proof_inconclusive",
+    "no_producer_available",
+    "representative_precision_only",
+    "architectural_precision_only",
+    "opaque_delta",
+    "hypothesized_breaking",
+];
+/** Coverage class for ClearanceEnvelope. */
+export const COVERAGE_CLASSES = ["full", "representative", "none"];

package/dist/assessment/schema.d.ts

@@ -0,0 +1,311 @@
+import { z } from "zod";
+import type { Assessment } from "./types.js";
+/** Root Assessment wire schema (ABI 4).
+ *
+ * All ABI 3 required fields are preserved. ABI 4 outcome model fields are optional,
+ * so ABI 3 payloads continue to parse successfully. Parsers must tolerate absent ABI 4
+ * fields and treat them as "shadow mode not yet active."
+ */
+export declare const assessmentSchema: z.ZodObject<{
+    reviewFocalPoint: z.ZodObject<{
+        episodeShape: z.ZodEnum<{
+            single_anchor: "single_anchor";
+            multi_anchor: "multi_anchor";
+            parent_supporting: "parent_supporting";
+            coupled_pair: "coupled_pair";
+            tooling_bundle: "tooling_bundle";
+            structural: "structural";
+        }>;
+        anchors: z.ZodArray<z.ZodString>;
+        supportingPackages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        election: z.ZodObject<{
+            grounding: z.ZodArray<z.ZodObject<{
+                packageName: z.ZodString;
+                reason: z.ZodString;
+                decidedBy: z.ZodEnum<{
+                    concern: "concern";
+                    reach: "reach";
+                    changeSeverity: "changeSeverity";
+                    repository_importance: "repository_importance";
+                    role_salience_tiebreak: "role_salience_tiebreak";
+                }>;
+                evidenceRefs: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>>;
+            exclusions: z.ZodArray<z.ZodObject<{
+                packageName: z.ZodString;
+                reason: z.ZodString;
+                lostOn: z.ZodEnum<{
+                    concern: "concern";
+                    reach: "reach";
+                    changeSeverity: "changeSeverity";
+                    repository_importance: "repository_importance";
+                    role_salience_tiebreak: "role_salience_tiebreak";
+                }>;
+                evidenceRefs: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        electionSummary: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    reachScope: z.ZodObject<{
+        packages: z.ZodArray<z.ZodString>;
+        maxBucket: z.ZodEnum<{
+            low: "low";
+            high: "high";
+            very_low: "very_low";
+            moderate: "moderate";
+        }>;
+        entryPointFiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    verificationScope: z.ZodObject<{
+        packages: z.ZodArray<z.ZodString>;
+        focus: z.ZodArray<z.ZodString>;
+        guidance: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        artifactGrounded: z.ZodOptional<z.ZodObject<{
+            packages: z.ZodArray<z.ZodString>;
+            focus: z.ZodArray<z.ZodString>;
+            artifactPaths: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    posture: z.ZodEnum<{
+        safe: "safe";
+        needs_review: "needs_review";
+        risky: "risky";
+    }>;
+    confidence: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>;
+    primaryConcern: z.ZodNullable<z.ZodEnum<{
+        unresolved_runtime_exposure: "unresolved_runtime_exposure";
+        security_finding: "security_finding";
+        breaking_or_major: "breaking_or_major";
+        behavioral_change: "behavioral_change";
+        ecosystem_risk: "ecosystem_risk";
+        insufficient_evidence: "insufficient_evidence";
+        graph_baseline_only: "graph_baseline_only";
+    }>>;
+    concerns: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            unresolved_runtime_exposure: "unresolved_runtime_exposure";
+            security_finding: "security_finding";
+            breaking_or_major: "breaking_or_major";
+            behavioral_change: "behavioral_change";
+            ecosystem_risk: "ecosystem_risk";
+            insufficient_evidence: "insufficient_evidence";
+            graph_baseline_only: "graph_baseline_only";
+        }>;
+        rank: z.ZodNumber;
+        packages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        evidenceRefs: z.ZodArray<z.ZodString>;
+        context: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    factors: z.ZodArray<z.ZodString>;
+    changeClasses: z.ZodArray<z.ZodEnum<{
+        tooling_maintenance: "tooling_maintenance";
+        test_infra: "test_infra";
+        runtime_patch: "runtime_patch";
+        runtime_upgrade: "runtime_upgrade";
+        security_advisory: "security_advisory";
+        breaking_change: "breaking_change";
+        ecosystem_unknown: "ecosystem_unknown";
+        bulk_mixed: "bulk_mixed";
+        removal: "removal";
+    }>>;
+    presentation: z.ZodObject<{
+        narrativeIntensity: z.ZodEnum<{
+            minimal: "minimal";
+            standard: "standard";
+            elevated: "elevated";
+        }>;
+        reachVisibility: z.ZodEnum<{
+            hidden: "hidden";
+            contextual: "contextual";
+            prominent: "prominent";
+        }>;
+        verificationIntensity: z.ZodEnum<{
+            none: "none";
+            advisory: "advisory";
+            required: "required";
+        }>;
+        insightEmissionFloor: z.ZodEnum<{
+            none: "none";
+            explain_only: "explain_only";
+            full: "full";
+        }>;
+        reportMode: z.ZodEnum<{
+            lightweight_pr_graph_baseline: "lightweight_pr_graph_baseline";
+            high_signal_pr: "high_signal_pr";
+        }>;
+    }, 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<{
+                manifest: "manifest";
+                exports: "exports";
+                entrypoint: "entrypoint";
+                peer_dependency: "peer_dependency";
+                engine_constraint: "engine_constraint";
+                type_surface: "type_surface";
+                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<{
+                manifest: "manifest";
+                exports: "exports";
+                entrypoint: "entrypoint";
+                peer_dependency: "peer_dependency";
+                engine_constraint: "engine_constraint";
+                type_surface: "type_surface";
+                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>;
+export type SafeParseAssessmentResult = {
+    ok: true;
+    value: Assessment;
+} | {
+    ok: false;
+    issues: string[];
+};
+export declare function parseAssessmentOrThrow(data: unknown): Assessment;
+export declare function safeParseAssessment(data: unknown): SafeParseAssessmentResult;
+//# sourceMappingURL=schema.d.ts.map

package/dist/assessment/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/assessment/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAwBxB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAqI7C;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsB3B,CAAC;AAEH,MAAM,MAAM,yBAAyB,GACjC;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,UAAU,CAAA;CAAE,GAC/B;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAEpC,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,OAAO,GAAG,UAAU,CAShE;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,GAAG,yBAAyB,CAW5E"}