@mergesignal/shared 0.12.2 → 0.13.0

package/dist/repoIntelligenceValidation.persist.test.js

@@ -1,44 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { deriveScanNarrative } from "./deriveScanNarrative.js";
-import { legacyEngineRepoIntelligenceJwt } from "./fixtures/legacyEngineRepoIntelligence.js";
-import { applyRepoIntelligenceValidation } from "./repoIntelligenceValidation.js";
-const baseScan = {
-    totalScore: 40,
-    layerScores: {
-        security: 10,
-        maintainability: 10,
-        ecosystem: 10,
-        upgradeImpact: 10,
-    },
-    findings: [],
-    generatedAt: "2026-01-01T00:00:00.000Z",
-    changedPackages: ["jsonwebtoken"],
-    analysisPreparation: {
-        codeIntelligenceAvailable: true,
-        warnings: [],
-    },
-};
-describe("applyRepoIntelligenceValidation (production persist model)", () => {
-    it("retains raw invalid repoIntelligence and marks status invalid", () => {
-        const { result, contractFailed, logPayload } = applyRepoIntelligenceValidation({
-            ...baseScan,
-            repoIntelligence: legacyEngineRepoIntelligenceJwt,
-        });
-        expect(contractFailed).toBe(true);
-        expect(logPayload?.issueCount).toBeGreaterThan(0);
-        expect(result.repoIntelligence).toEqual(legacyEngineRepoIntelligenceJwt);
-        expect(result.analysisPreparation?.repoIntelligenceValidation?.status).toBe("invalid");
-        expect(result.analysisPreparation?.warnings.some((w) => w.code === "repo_intelligence_contract_invalid")).toBe(true);
-    });
-    it("deriveScanNarrative ignores invalid wire (graph_fallback, untrusted parse status)", () => {
-        const { result } = applyRepoIntelligenceValidation({
-            ...baseScan,
-            repoIntelligence: legacyEngineRepoIntelligenceJwt,
-        });
-        const facts = deriveScanNarrative(result);
-        expect(facts.availability.repoIntelligenceParse).toBe("untrusted");
-        expect(facts.availability.tiersPresent.tier1).toBe(false);
-        expect(facts.availability.mode).not.toBe("pr_intelligence");
-        expect(facts.packageUsage).toHaveLength(0);
-    });
-});

package/dist/riskSignals.test.d.ts

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

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

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

package/dist/riskSignals.test.js

@@ -1,32 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { deriveRiskSignals } from "./riskSignals.js";
-import { resolveRepositoryHealthScore } from "./prRiskWire.js";
-function baseResult(overrides = {}) {
-    return {
-        totalScore: 63,
-        layerScores: {
-            security: 10,
-            maintainability: 20,
-            ecosystem: 30,
-            upgradeImpact: 15,
-        },
-        findings: [],
-        generatedAt: "2026-01-01T00:00:00.000Z",
-        ...overrides,
-    };
-}
-describe("deriveRiskSignals", () => {
-    it("prefers prRisk.score over totalScore and repositoryHealth", () => {
-        const result = baseResult({
-            prRisk: { score: 55 },
-            repositoryHealth: { totalScore: 63 },
-            totalScore: 63,
-        });
-        expect(deriveRiskSignals(result)?.riskIndex).toBe(55);
-        expect(resolveRepositoryHealthScore(result)).toBe(63);
-    });
-    it("falls back to totalScore when prRisk is missing (historical scans)", () => {
-        const result = baseResult({ totalScore: 48 });
-        expect(deriveRiskSignals(result)?.riskIndex).toBe(48);
-    });
-});

package/dist/riskVocabulary.test.d.ts

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

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

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

package/dist/riskVocabulary.test.js

@@ -1,14 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { mergePostureFromDecision } from "./riskVocabulary.js";
-describe("mergePostureFromDecision", () => {
-    it("accepts only canonical lowercase merge posture tokens", () => {
-        expect(mergePostureFromDecision("safe")).toBe("safe");
-        expect(mergePostureFromDecision("needs_review")).toBe("needs_review");
-        expect(mergePostureFromDecision("risky")).toBe("risky");
-    });
-    it("rejects alternate engine spellings (no silent normalization)", () => {
-        expect(mergePostureFromDecision("SAFE")).toBeNull();
-        expect(mergePostureFromDecision("RISKY")).toBeNull();
-        expect(mergePostureFromDecision("BLOCK")).toBeNull();
-    });
-});

package/dist/scanPresentationBundle.golden.test.d.ts

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

package/dist/scanPresentationBundle.golden.test.d.ts.map

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

package/dist/scanPresentationBundle.golden.test.js

@@ -1,78 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { scoreToBand } from "./prRiskBand.js";
-import { buildScanPresentationBundle } from "./presentation/orchestration/buildScanPresentationBundle.js";
-import { scanResultBullmq, scanResultEslint, scanResultFastifyRuntime, scanResultLimitedContext, scanResultMixedTypescriptFastify, scanResultPrettier, scanResultTypescriptPatch, scanResultVitest, } from "./presentation/fixtures/presentationPersonaFixtures.js";
-const validationPersonas = [
-    { id: "fastify-runtime", result: scanResultFastifyRuntime },
-    { id: "typescript-patch", result: scanResultTypescriptPatch },
-    { id: "mixed-ts-fastify", result: scanResultMixedTypescriptFastify },
-    { id: "prettier", result: scanResultPrettier },
-    { id: "bullmq", result: scanResultBullmq },
-    { id: "eslint", result: scanResultEslint },
-    { id: "vitest", result: scanResultVitest },
-    { id: "limited-context", result: scanResultLimitedContext },
-];
-function bundleFor(result) {
-    return buildScanPresentationBundle({
-        result,
-        pipelineStatus: "done",
-    });
-}
-describe("scanPresentationBundle golden — proof model", () => {
-    it.each(validationPersonas)("builds bundle for $id", ({ result }) => {
-        const bundle = bundleFor(result);
-        expect(bundle).not.toBeNull();
-        expect(bundle.facts.availability.corpusGateReason).toBeDefined();
-        expect(bundle.facts.confidence).toMatchObject({
-            limitedContext: expect.any(Boolean),
-        });
-        expect(bundle.facts.riskSignals).not.toBeNull();
-        expect(bundle.facts.riskSignals.layers).toHaveLength(4);
-    });
-    it("fastify-runtime — linkage and diagnostics", () => {
-        const bundle = bundleFor(scanResultFastifyRuntime);
-        const { facts } = bundle;
-        expect(facts.availability.corpusGateReason).toBe("ok");
-        expect(facts.confidence.limitedContext).toBe(false);
-        expect(facts.confidence.assessment).toBe("medium");
-        const apiArea = facts.affectedAreas.find((a) => a.id === "api");
-        expect(apiArea?.packages).toContain("fastify");
-        expect(apiArea?.findingIds).toContain("finding-fastify-runtime");
-        expect(apiArea?.paths.length).toBeGreaterThan(0);
-        expect(apiArea?.hotspotPackages).toContain("fastify");
-        expect(apiArea?.verificationFocus.length).toBeGreaterThan(0);
-        expect(facts.riskSignals?.riskIndex).toBe(55);
-        expect(facts.riskSignals?.band).toBe(scoreToBand(55));
-        expect(facts.riskIndex).toBe(facts.riskSignals?.riskIndex);
-    });
-    it("limited-context — diagnostics without synthetic confidence", () => {
-        const bundle = bundleFor(scanResultLimitedContext);
-        const { facts } = bundle;
-        expect(facts.availability.corpusGateReason).toBe("no_code_intelligence");
-        expect(facts.availability.preparationWarnings.some((w) => w.code === "base_lockfile_missing")).toBe(true);
-        expect(facts.confidence.assessment).toBe("low");
-        expect(facts.confidence.limitedContext).toBe(true);
-    });
-    it("typescript-patch — tooling semantics with risk signals", () => {
-        const bundle = bundleFor(scanResultTypescriptPatch);
-        const { facts } = bundle;
-        expect(facts.availability.corpusGateReason).toBe("ok");
-        expect(facts.packageSemantics?.dependencyClass).toBe("tooling");
-        expect(facts.riskSignals?.riskIndex).toBe(30);
-        expect(facts.riskSignals?.band).toBe(scoreToBand(30));
-    });
-    it("affected areas always carry linkage arrays (structure)", () => {
-        for (const { result } of validationPersonas) {
-            const bundle = bundleFor(result);
-            if (!bundle)
-                continue;
-            for (const area of bundle.facts.affectedAreas) {
-                expect(Array.isArray(area.packages)).toBe(true);
-                expect(Array.isArray(area.findingIds)).toBe(true);
-                expect(Array.isArray(area.paths)).toBe(true);
-                expect(Array.isArray(area.hotspotPackages)).toBe(true);
-                expect(Array.isArray(area.verificationFocus)).toBe(true);
-            }
-        }
-    });
-});

package/dist/scanResultSchema.test.d.ts

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

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

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

package/dist/scanResultSchema.test.js

@@ -1,162 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { safeParseScanResult, parseScanResultOrThrow, scanResultSchema, safeParseEngineOutputScanResult, parseEngineOutputScanResultOrThrow, } from "./scanResultSchema.js";
-import { emptyReachScope, emptyVerificationScope, minimalReviewFocalPoint, } from "./fixtures/assessmentScopeFixtures.js";
-import { withAbi4EngineScores } from "./fixtures/engineAbi4Fixtures.js";
-const minimalValid = {
-    totalScore: 42,
-    layerScores: {
-        security: 10,
-        maintainability: 20,
-        ecosystem: 30,
-        upgradeImpact: 40,
-    },
-    findings: [],
-    generatedAt: "2026-01-01T00:00:00.000Z",
-};
-describe("scanResultSchema", () => {
-    it("accepts a minimal valid payload", () => {
-        const r = safeParseScanResult(minimalValid);
-        expect(r.ok).toBe(true);
-        if (r.ok)
-            expect(r.result.totalScore).toBe(42);
-    });
-    it("preserves unknown top-level keys (passthrough)", () => {
-        const r = safeParseScanResult({
-            ...minimalValid,
-            futureEngineField: { x: 1 },
-        });
-        expect(r.ok).toBe(true);
-        if (r.ok)
-            expect(r.result.futureEngineField).toEqual({
-                x: 1,
-            });
-    });
-    it("rejects missing layerScores", () => {
-        const r = safeParseScanResult({
-            totalScore: 1,
-            findings: [],
-            generatedAt: "2026-01-01T00:00:00.000Z",
-        });
-        expect(r.ok).toBe(false);
-    });
-    it("rejects out-of-range totalScore", () => {
-        const r = safeParseScanResult({
-            ...minimalValid,
-            totalScore: 101,
-        });
-        expect(r.ok).toBe(false);
-    });
-    it("rejects invalid decision.recommendation", () => {
-        const r = safeParseScanResult({
-            ...minimalValid,
-            decision: { recommendation: "maybe", reasoning: [] },
-        });
-        expect(r.ok).toBe(false);
-    });
-    it("rejects non-canonical merge posture tokens (e.g. proprietary uppercase)", () => {
-        const r = safeParseScanResult({
-            ...minimalValid,
-            decision: { recommendation: "SAFE", reasoning: [] },
-        });
-        expect(r.ok).toBe(false);
-    });
-    it("rejects empty generatedAt", () => {
-        const r = safeParseScanResult({
-            ...minimalValid,
-            generatedAt: "",
-        });
-        expect(r.ok).toBe(false);
-    });
-    it("parseScanResultOrThrow returns on success", () => {
-        expect(parseScanResultOrThrow(minimalValid).totalScore).toBe(42);
-    });
-    it("parseScanResultOrThrow throws with validation prefix", () => {
-        expect(() => parseScanResultOrThrow({})).toThrow(/^validation:/);
-    });
-    it("scanResultSchema default empty findings when omitted", () => {
-        const { findings: _f, ...rest } = minimalValid;
-        const parsed = scanResultSchema.parse(rest);
-        expect(parsed.findings).toEqual([]);
-    });
-});
-const minimalAssessment = {
-    reviewFocalPoint: minimalReviewFocalPoint(["typescript"]),
-    reachScope: emptyReachScope(),
-    verificationScope: emptyVerificationScope(),
-    posture: "safe",
-    confidence: "high",
-    primaryConcern: null,
-    concerns: [],
-    factors: ["tooling_maintenance"],
-    changeClasses: ["tooling_maintenance"],
-    reasoning: [],
-    confidenceRationale: "",
-    presentation: {
-        narrativeIntensity: "minimal",
-        reachVisibility: "hidden",
-        verificationIntensity: "advisory",
-        insightEmissionFloor: "none",
-        reportMode: "high_signal_pr",
-    },
-};
-describe("engineOutputScanResultSchema (strict, fresh engine only)", () => {
-    const withMethodology = withAbi4EngineScores({
-        ...minimalValid,
-        methodologyVersion: "engine-test-fixture/v1",
-        assessment: minimalAssessment,
-    });
-    it("rejects payload that relaxed parser accepts when methodology is missing", () => {
-        const r = safeParseEngineOutputScanResult(minimalValid);
-        expect(r.ok).toBe(false);
-    });
-    it("accepts when methodology and parseable generatedAt are present", () => {
-        const r = safeParseEngineOutputScanResult(withMethodology);
-        expect(r.ok).toBe(true);
-        if (r.ok)
-            expect(r.result.methodologyVersion).toBe("engine-test-fixture/v1");
-    });
-    it("synthesizes prRisk/repositoryHealth from totalScore for legacy engines", () => {
-        const r = safeParseEngineOutputScanResult({
-            ...minimalValid,
-            methodologyVersion: "acme-prod/v1",
-            assessment: minimalAssessment,
-        });
-        expect(r.ok).toBe(true);
-        if (r.ok) {
-            expect(r.result.prRisk?.score).toBe(42);
-            expect(r.result.repositoryHealth?.totalScore).toBe(42);
-        }
-    });
-    it("parseEngineOutputScanResultOrThrow throws with validation prefix", () => {
-        expect(() => parseEngineOutputScanResultOrThrow(minimalValid)).toThrow(/^validation:/);
-    });
-    it("rejects unparseable generatedAt", () => {
-        const r = safeParseEngineOutputScanResult({
-            ...withMethodology,
-            generatedAt: "not-a-date",
-        });
-        expect(r.ok).toBe(false);
-    });
-    it("rejects ABI-1 assessment missing focal/scope fields on fresh engine path", () => {
-        const legacyAssessment = {
-            posture: "safe",
-            confidence: "high",
-            primaryConcern: null,
-            concerns: [],
-            factors: ["tooling_maintenance"],
-            changeClasses: ["tooling_maintenance"],
-            presentation: {
-                narrativeIntensity: "minimal",
-                reachVisibility: "hidden",
-                verificationIntensity: "advisory",
-                insightEmissionFloor: "none",
-                reportMode: "high_signal_pr",
-            },
-        };
-        const r = safeParseEngineOutputScanResult({
-            ...withMethodology,
-            assessment: legacyAssessment,
-        });
-        expect(r.ok).toBe(false);
-    });
-});

package/dist/scanSurfaceCopy.test.d.ts

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

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

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

package/dist/scanSurfaceCopy.test.js

@@ -1,14 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { dirname, join } from "node:path";
-import { scanSurfaceCopyFlat } from "./scanSurfaceCopy.js";
-describe("scanSurfaceCopy", () => {
-    it("matches generated CI JSON (no drift)", () => {
-        const root = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
-        const jsonPath = join(root, "scripts/ci/scan-surface-copy.generated.json");
-        const onDisk = JSON.parse(readFileSync(jsonPath, "utf8"));
-        const fromTs = scanSurfaceCopyFlat();
-        expect(fromTs).toEqual(onDisk);
-    });
-});

package/dist/selectTopAffectedAreas.test.d.ts

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

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

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

package/dist/selectTopAffectedAreas.test.js

@@ -1,179 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { selectTopAffectedAreas } from "./selectTopAffectedAreas.js";
-function makeScanResult(overrides = {}) {
-    return {
-        totalScore: 60,
-        layerScores: {
-            security: 70,
-            maintainability: 50,
-            ecosystem: 40,
-            upgradeImpact: 30,
-        },
-        findings: [],
-        generatedAt: "2026-01-01T00:00:00Z",
-        ...overrides,
-    };
-}
-describe("selectTopAffectedAreas", () => {
-    it("returns [] for null input", () => {
-        expect(selectTopAffectedAreas(null)).toEqual([]);
-    });
-    it("returns [] for undefined input", () => {
-        expect(selectTopAffectedAreas(undefined)).toEqual([]);
-    });
-    it("returns at most 3 results by default", () => {
-        const result = makeScanResult({
-            explain: {
-                reasons: [
-                    { id: "r1", layer: "security", title: "Auth flow", scoreImpact: -20 },
-                    {
-                        id: "r2",
-                        layer: "security",
-                        title: "State sync",
-                        scoreImpact: -15,
-                    },
-                    {
-                        id: "r3",
-                        layer: "ecosystem",
-                        title: "Middleware",
-                        scoreImpact: -10,
-                    },
-                    {
-                        id: "r4",
-                        layer: "maintainability",
-                        title: "Extra area",
-                        scoreImpact: -5,
-                    },
-                ],
-            },
-        });
-        const areas = selectTopAffectedAreas(result);
-        expect(areas.length).toBe(3);
-        expect(areas).toEqual(["Auth flow", "State sync", "Middleware"]);
-    });
-    it("respects custom max", () => {
-        const result = makeScanResult({
-            explain: {
-                reasons: [
-                    { id: "r1", layer: "security", title: "Area A", scoreImpact: -20 },
-                    { id: "r2", layer: "security", title: "Area B", scoreImpact: -15 },
-                ],
-            },
-        });
-        expect(selectTopAffectedAreas(result, { max: 1 })).toEqual(["Area A"]);
-    });
-    it("sorts explain reasons by absolute scoreImpact descending", () => {
-        const result = makeScanResult({
-            explain: {
-                reasons: [
-                    { id: "r1", layer: "security", title: "Minor", scoreImpact: -2 },
-                    { id: "r2", layer: "security", title: "Critical", scoreImpact: -30 },
-                    { id: "r3", layer: "ecosystem", title: "Medium", scoreImpact: -15 },
-                ],
-            },
-        });
-        const areas = selectTopAffectedAreas(result);
-        expect(areas[0]).toBe("Critical");
-        expect(areas[1]).toBe("Medium");
-    });
-    it("falls back to insights when explain is empty", () => {
-        const result = makeScanResult({
-            insights: [
-                {
-                    type: "behavioral_change",
-                    priority: "high",
-                    confidence: "confirmed",
-                    scope: "changed",
-                    message: "Auth middleware changed. Check tokens",
-                    context: "src/auth.ts",
-                    remediation: "Review carefully",
-                },
-            ],
-        });
-        const areas = selectTopAffectedAreas(result);
-        expect(areas).toEqual(["Auth middleware changed"]);
-    });
-    it("falls back to layer names when explain and insights are empty", () => {
-        const result = makeScanResult();
-        const areas = selectTopAffectedAreas(result);
-        expect(areas.length).toBeGreaterThan(0);
-        expect(areas.length).toBeLessThanOrEqual(3);
-        expect(areas).toContain("Security");
-    });
-    it("deduplicates normalized labels", () => {
-        const result = makeScanResult({
-            explain: {
-                reasons: [
-                    { id: "r1", layer: "security", title: "Auth flow", scoreImpact: -20 },
-                    { id: "r2", layer: "security", title: "auth flow", scoreImpact: -15 },
-                    {
-                        id: "r3",
-                        layer: "ecosystem",
-                        title: "Auth flow",
-                        scoreImpact: -10,
-                    },
-                ],
-            },
-        });
-        const areas = selectTopAffectedAreas(result);
-        const unique = new Set(areas.map((a) => a.toLowerCase()));
-        expect(unique.size).toBe(areas.length);
-        expect(areas).toContain("Auth flow");
-        expect(areas.filter((a) => a.toLowerCase() === "auth flow").length).toBe(1);
-    });
-    it("trims the 'Finding: ' prefix from labels", () => {
-        const result = makeScanResult({
-            explain: {
-                reasons: [
-                    {
-                        id: "r1",
-                        layer: "security",
-                        title: "Finding: Outdated lodash",
-                        scoreImpact: -20,
-                    },
-                ],
-            },
-        });
-        const areas = selectTopAffectedAreas(result);
-        expect(areas[0]).toBe("Outdated lodash");
-    });
-    it("truncates labels longer than maxLabelLen with ellipsis", () => {
-        const long = "A".repeat(50);
-        const result = makeScanResult({
-            explain: {
-                reasons: [
-                    { id: "r1", layer: "security", title: long, scoreImpact: -10 },
-                ],
-            },
-        });
-        const areas = selectTopAffectedAreas(result, { maxLabelLen: 10 });
-        expect(areas[0].length).toBeLessThanOrEqual(10);
-        expect(areas[0].endsWith("…")).toBe(true);
-    });
-    it("returns empty array when no useful signal at all", () => {
-        // Completely empty scan result with empty layerScores
-        const result = {
-            totalScore: 0,
-            layerScores: {
-                security: 0,
-                maintainability: 0,
-                ecosystem: 0,
-                upgradeImpact: 0,
-            },
-            findings: [],
-            generatedAt: "2026-01-01T00:00:00Z",
-        };
-        // With layer fallback this would return layer names; only truly empty when
-        // caller passes a result without layerScores entirely — validate max guard
-        const areas = selectTopAffectedAreas(result, { max: 3 });
-        expect(areas.length).toBeLessThanOrEqual(3);
-    });
-    it("returns [] when layerScores is missing and no explain/insights", () => {
-        const partial = {
-            totalScore: 10,
-            findings: [],
-            generatedAt: "2026-01-01T00:00:00Z",
-        };
-        expect(selectTopAffectedAreas(partial)).toEqual([]);
-    });
-});

package/dist/trustedScanGuards.test.d.ts

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

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

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