@shrkcrft/inspector 0.1.0-alpha.1

package/dist/test-runner.js

@@ -0,0 +1,560 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { existsSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { buildContext } from '@shrkcrft/context';
+import { buildTaskPacket } from "./task-packet.js";
+import { rankKnowledgeEntries } from "./task-ranker.js";
+import { buildProjectOverview, renderOverviewText } from "./project-overview.js";
+import { HELPERS } from "./helper-registry.js";
+async function importDefaultArray(absPath) {
+    if (!existsSync(absPath))
+        return [];
+    try {
+        const mod = (await import(__rewriteRelativeImportExtension(pathToFileURL(absPath).href)));
+        return Array.isArray(mod.default) ? mod.default : [];
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Load context tests from local sharkcraft config + any pack contributions.
+ */
+export async function loadContextTests(inspection) {
+    const tests = [];
+    // Local config file.
+    if (inspection.sharkcraftDir) {
+        const local = nodePath.join(inspection.sharkcraftDir, 'context-tests.ts');
+        if (existsSync(local)) {
+            tests.push(...(await importDefaultArray(local)));
+        }
+    }
+    // Pack contributions.
+    for (const pack of inspection.packs.validPacks) {
+        const c = pack.manifest.contributions;
+        for (const rel of c.contextTestFiles ?? []) {
+            const full = nodePath.resolve(pack.packageRoot, rel);
+            tests.push(...(await importDefaultArray(full)));
+        }
+    }
+    return tests;
+}
+export async function loadAgentContractTests(inspection) {
+    const tests = [];
+    if (inspection.sharkcraftDir) {
+        const local = nodePath.join(inspection.sharkcraftDir, 'agent-tests.ts');
+        if (existsSync(local)) {
+            tests.push(...(await importDefaultArray(local)));
+        }
+    }
+    for (const pack of inspection.packs.validPacks) {
+        const c = pack.manifest.contributions;
+        for (const rel of c.agentTestFiles ?? []) {
+            const full = nodePath.resolve(pack.packageRoot, rel);
+            tests.push(...(await importDefaultArray(full)));
+        }
+    }
+    return tests;
+}
+export function runContextTest(inspection, test) {
+    const overview = buildProjectOverview(inspection.workspace, inspection.config?.projectName);
+    const ctx = buildContext(inspection.knowledgeEntries, {
+        task: test.task,
+        maxTokens: test.maxTokens ?? 3500,
+        projectOverview: renderOverviewText(overview),
+    });
+    const bodyIds = new Set();
+    for (const section of ctx.sections) {
+        for (const id of section.entryIds)
+            bodyIds.add(id);
+    }
+    const missingInclude = [];
+    const presentInclude = [];
+    for (const id of test.mustInclude ?? []) {
+        if (bodyIds.has(id))
+            presentInclude.push(id);
+        else
+            missingInclude.push(id);
+    }
+    const unexpectedInclude = [];
+    for (const id of test.mustNotInclude ?? []) {
+        if (bodyIds.has(id))
+            unexpectedInclude.push(id);
+    }
+    const passed = missingInclude.length === 0 && unexpectedInclude.length === 0;
+    // Diagnostics: only populate on failure. Show the top-ranked alternatives
+    // the ranker chose for the task, so the test author can see what beat the
+    // expected entry — and tighten the rule's appliesWhen/tags accordingly.
+    let diagnostics;
+    if (!passed) {
+        const ranked = rankKnowledgeEntries(inspection.knowledgeEntries, test.task);
+        diagnostics = [];
+        for (const id of missingInclude) {
+            const exists = inspection.knowledgeEntries.some((e) => e.id === id);
+            diagnostics.push({
+                id,
+                existsInRegistry: exists,
+                topAlternatives: ranked.slice(0, 5).map((r) => ({
+                    id: r.item.id,
+                    score: r.score,
+                    reasons: r.reasons,
+                })),
+                suggestions: buildMissingIncludeSuggestions(id, exists, test.task),
+            });
+        }
+        for (const id of unexpectedInclude) {
+            const entry = inspection.knowledgeEntries.find((e) => e.id === id);
+            const reasons = ranked.find((r) => r.item.id === id)?.reasons ?? [];
+            diagnostics.push({
+                id,
+                existsInRegistry: !!entry,
+                topAlternatives: reasons.length
+                    ? [{ id, score: ranked.find((r) => r.item.id === id)?.score ?? 0, reasons }]
+                    : undefined,
+                suggestions: [
+                    `"${id}" appeared in the context body for "${test.task}".`,
+                    'Narrow its `appliesWhen` to avoid matching this task wording, or remove the entry from mustNotInclude if the inclusion is acceptable.',
+                ],
+            });
+        }
+    }
+    const result = {
+        id: test.id,
+        task: test.task,
+        passed,
+        presentInclude,
+        missingInclude,
+        unexpectedInclude,
+        totalTokens: ctx.totalTokens,
+        maxTokens: ctx.maxTokens,
+    };
+    if (!passed) {
+        result.failureSummary = `missing=${missingInclude.length} unexpected=${unexpectedInclude.length}`;
+    }
+    if (diagnostics)
+        result.diagnostics = diagnostics;
+    return result;
+}
+function buildMissingIncludeSuggestions(id, existsInRegistry, task) {
+    if (!existsInRegistry) {
+        return [
+            `Entry "${id}" does not exist in the inspection — either install the pack that ships it or correct the id.`,
+            `If the test expectation is wrong, update sharkcraft/context-tests.ts.`,
+        ];
+    }
+    return [
+        `Entry "${id}" exists but did not make the context for task "${task}".`,
+        `Try adding domain-aligned appliesWhen values (create-plugin / generate-service / register-defaults / …).`,
+        `Add task-relevant tags (plugin / capability / adapter / …).`,
+        `Reference the entry from a preset's includes.knowledgeIds / ruleIds so it ranks higher.`,
+        `Or raise its priority / shorten the title to include task-relevant tokens.`,
+    ];
+}
+export function runAgentContractTest(inspection, test, registries) {
+    const packet = buildTaskPacket(inspection, test.task, { maxTokens: 3500 });
+    const actualPipelines = packet.recommendedPipelines.map((p) => p.pipelineId);
+    const missingTemplates = (test.expectedTemplates ?? []).filter((id) => !packet.relevantTemplates.some((t) => t.id === id));
+    const missingRules = (test.expectedRules ?? []).filter((id) => !packet.relevantRules.some((r) => r.id === id));
+    const missingForbidden = (test.expectedForbiddenActions ?? []).filter((a) => !packet.forbiddenActions.includes(a));
+    const missingVerification = (test.expectedVerificationCommands ?? []).filter((c) => !packet.verificationCommands.includes(c));
+    // New expectation checks. Each one fails when the asset is missing
+    // from the relevant registry (drift detection) or — for commands — also
+    // not surfaced in the packet's recommended set.
+    const helperRegistry = registries?.helpers ?? loadHelperRegistryQuietly();
+    const playbookList = registries?.playbooks ?? listPlaybookIdsQuietly(inspection);
+    const policyChecks = registries?.policies ?? listPolicyIdsQuietly(inspection);
+    const constructList = registries?.constructs ?? listConstructIdsQuietly(inspection);
+    const commandCatalog = registries?.commands ?? listCommandIdsQuietly(inspection);
+    const knowledgeIds = registries?.knowledge ?? new Set(inspection.knowledgeEntries.map((e) => e.id));
+    const missingHelpers = (test.expectedHelpers ?? []).filter((id) => !helperRegistry.has(id));
+    const missingPlaybooks = (test.expectedPlaybooks ?? []).filter((id) => !playbookList.has(id));
+    const missingPolicies = (test.expectedPolicies ?? []).filter((id) => !policyChecks.has(id));
+    const missingConstructs = (test.expectedConstructs ?? []).filter((id) => !constructList.has(id));
+    const missingCommands = (test.expectedCommands ?? []).filter((id) => {
+        if (packet.recommendedCliCommands.includes(id))
+            return false;
+        // Accept either the catalog id form ("dev start") or the bare
+        // first token ("dev"). The catalog uses dotted ids that map to the
+        // command shape; we accept either form.
+        return !commandCatalog.has(id) && !commandCatalog.has(id.split(' ')[0]);
+    });
+    const missingKnowledge = (test.expectedKnowledge ?? []).filter((id) => !knowledgeIds.has(id));
+    // mustNotInclude — fail if any of these ids ended up surfaced in the packet.
+    const surfacedIds = new Set();
+    for (const t of packet.relevantTemplates)
+        surfacedIds.add(t.id);
+    for (const r of packet.relevantRules)
+        surfacedIds.add(r.id);
+    for (const p of packet.relevantPaths)
+        surfacedIds.add(p.id);
+    for (const p of packet.recommendedPipelines)
+        surfacedIds.add(p.pipelineId);
+    for (const p of packet.presetRecommendations)
+        surfacedIds.add(p.preset.id);
+    const unexpectedlyIncluded = (test.mustNotInclude ?? []).filter((id) => surfacedIds.has(id));
+    const pipelineOk = !test.expectedPipeline || actualPipelines.includes(test.expectedPipeline);
+    const passed = pipelineOk &&
+        missingTemplates.length === 0 &&
+        missingRules.length === 0 &&
+        missingForbidden.length === 0 &&
+        missingVerification.length === 0 &&
+        missingHelpers.length === 0 &&
+        missingPlaybooks.length === 0 &&
+        missingPolicies.length === 0 &&
+        missingConstructs.length === 0 &&
+        missingCommands.length === 0 &&
+        missingKnowledge.length === 0 &&
+        unexpectedlyIncluded.length === 0;
+    // Diagnostics on failure: per missing id, explain whether the entry
+    // exists in the registry and how to make it surface.
+    let diagnostics;
+    if (!passed) {
+        diagnostics = [];
+        for (const id of missingTemplates) {
+            const exists = inspection.templates.some((t) => t.id === id);
+            diagnostics.push({
+                id,
+                kind: 'template',
+                existsInRegistry: exists,
+                suggestions: exists
+                    ? [
+                        `Template "${id}" exists but the ranker did not place it in the top results.`,
+                        'Add task-aligned tags/appliesWhen to the template (e.g. tags:["plugin"], appliesWhen:["create-plugin"]).',
+                        'Reference the template from a preset that matches the task profile (includes.templateIds).',
+                        'Reference it from a pipeline step (`step.references`).',
+                    ]
+                    : [
+                        `Template "${id}" does not exist — install the pack that ships it or correct the id.`,
+                    ],
+            });
+        }
+        for (const id of missingRules) {
+            const exists = inspection.knowledgeEntries.some((e) => e.id === id);
+            diagnostics.push({
+                id,
+                kind: 'rule',
+                existsInRegistry: exists,
+                suggestions: exists
+                    ? [
+                        `Rule "${id}" exists but the ranker did not surface it for "${test.task}".`,
+                        'Align its appliesWhen with the domain (e.g. create-plugin / register-defaults / generate-service).',
+                        'Add domain tags (plugin / capability / adapter / defaults).',
+                        'Reference it from actionHints.relatedTemplates on a rule that *is* ranking, or include it in a preset.',
+                    ]
+                    : [
+                        `Rule "${id}" does not exist — install the pack that ships it or correct the id.`,
+                    ],
+            });
+        }
+        if (!pipelineOk && test.expectedPipeline) {
+            diagnostics.push({
+                id: test.expectedPipeline,
+                kind: 'pipeline',
+                existsInRegistry: inspection.pipelines.some((p) => p.id === test.expectedPipeline),
+                suggestions: [
+                    `Pipeline "${test.expectedPipeline}" did not rank in the top 3 for "${test.task}".`,
+                    'Add domain-aligned tags to the pipeline (tags:["plugin"], …).',
+                    'Add task tokens to its title / description so the ranker catches them.',
+                    'Reference the pipeline from a preset that the task profile recommends.',
+                ],
+            });
+        }
+        for (const action of missingForbidden) {
+            diagnostics.push({
+                id: action,
+                kind: 'forbidden-action',
+                existsInRegistry: false,
+                suggestions: [
+                    `No rule's actionHints.forbiddenActions contains "${action}" for this task's relevant set.`,
+                    'Add the forbiddenAction to one of the high-priority rules that match this task.',
+                ],
+            });
+        }
+        for (const cmd of missingVerification) {
+            diagnostics.push({
+                id: cmd,
+                kind: 'verification-command',
+                existsInRegistry: false,
+                suggestions: [
+                    `Verification command "${cmd}" is not aggregated for this task.`,
+                    'Add it to a high-priority rule\'s actionHints.verificationCommands.',
+                ],
+            });
+        }
+        // Diagnostics for the new expectation slots.
+        for (const id of missingHelpers) {
+            diagnostics.push({
+                id,
+                kind: 'helper',
+                existsInRegistry: helperRegistry.has(id),
+                suggestions: [
+                    `Helper "${id}" not found in the helper registry — install the pack that ships it or correct the id.`,
+                    'Make sure the helper is registered in HELPERS in packages/inspector/src/helper-registry.ts (or a pack contribution).',
+                ],
+            });
+        }
+        for (const id of missingPlaybooks) {
+            diagnostics.push({
+                id,
+                kind: 'playbook',
+                existsInRegistry: playbookList.has(id),
+                suggestions: [
+                    `Playbook "${id}" not found in the playbook registry — install the pack that ships it or correct the id.`,
+                    'Ensure the playbook file is referenced in sharkcraft.config.ts / pack contributions and exports a default array.',
+                ],
+            });
+        }
+        for (const id of missingPolicies) {
+            diagnostics.push({
+                id,
+                kind: 'policy',
+                existsInRegistry: policyChecks.has(id),
+                suggestions: [
+                    `Policy "${id}" not found in the policy-engine checks — install the pack that ships it or correct the id.`,
+                    'Add it to sharkcraft/policies.ts or a pack policyCheckFile.',
+                ],
+            });
+        }
+        for (const id of missingConstructs) {
+            diagnostics.push({
+                id,
+                kind: 'construct',
+                existsInRegistry: constructList.has(id),
+                suggestions: [
+                    `Construct "${id}" not found in the construct registry — install the pack that ships it or correct the id.`,
+                    'Add a defineConstruct() entry in sharkcraft/constructs.ts or a pack constructFile.',
+                ],
+            });
+        }
+        for (const id of missingCommands) {
+            diagnostics.push({
+                id,
+                kind: 'command',
+                existsInRegistry: commandCatalog.has(id) || commandCatalog.has(id.split(' ')[0]),
+                suggestions: [
+                    `Command "${id}" was not surfaced for "${test.task}" and is not in the command catalog.`,
+                    'Add it to a high-priority rule\'s actionHints.commands or check the command-catalog.ts entries.',
+                ],
+            });
+        }
+        for (const id of missingKnowledge) {
+            diagnostics.push({
+                id,
+                kind: 'knowledge',
+                existsInRegistry: knowledgeIds.has(id),
+                suggestions: [
+                    `Knowledge entry "${id}" is not present in the inspection — install the pack that ships it or correct the id.`,
+                ],
+            });
+        }
+        for (const id of unexpectedlyIncluded) {
+            diagnostics.push({
+                id,
+                kind: 'must-not-include',
+                existsInRegistry: true,
+                suggestions: [
+                    `"${id}" was surfaced by the ranker but the test forbids it.`,
+                    'Narrow its appliesWhen / tags to avoid matching this task wording.',
+                ],
+            });
+        }
+    }
+    const result = {
+        id: test.id,
+        task: test.task,
+        passed,
+        actualPipelines,
+        missingTemplates,
+        missingRules,
+        missingForbiddenActions: missingForbidden,
+        missingVerificationCommands: missingVerification,
+        missingHelpers,
+        missingPlaybooks,
+        missingPolicies,
+        missingConstructs,
+        missingCommands,
+        missingKnowledge,
+        unexpectedlyIncluded,
+    };
+    if (test.expectedPipeline)
+        result.expectedPipeline = test.expectedPipeline;
+    if (!passed) {
+        const partsList = [
+            `pipelineOk=${pipelineOk}`,
+            `missingTemplates=${missingTemplates.length}`,
+            `missingRules=${missingRules.length}`,
+            `missingHelpers=${missingHelpers.length}`,
+            `missingPlaybooks=${missingPlaybooks.length}`,
+            `missingPolicies=${missingPolicies.length}`,
+            `missingConstructs=${missingConstructs.length}`,
+            `missingCommands=${missingCommands.length}`,
+            `missingKnowledge=${missingKnowledge.length}`,
+            `unexpectedlyIncluded=${unexpectedlyIncluded.length}`,
+        ];
+        result.failureSummary = partsList.join(' ');
+    }
+    if (diagnostics)
+        result.diagnostics = diagnostics;
+    return result;
+}
+// ── Registry helpers ────────────────────────────────────────────────
+function loadHelperRegistryQuietly() {
+    try {
+        return new Set(HELPERS.map((h) => h.id));
+    }
+    catch {
+        return new Set();
+    }
+}
+function listPlaybookIdsQuietly(inspection) {
+    const reg = inspection
+        .playbookRegistry;
+    if (!reg || typeof reg.list !== 'function')
+        return new Set();
+    try {
+        return new Set(reg.list().map((p) => p.id));
+    }
+    catch {
+        return new Set();
+    }
+}
+function listPolicyIdsQuietly(inspection) {
+    const checks = inspection.policyChecks ?? [];
+    return new Set(checks.map((c) => c.id));
+}
+function listConstructIdsQuietly(inspection) {
+    const direct = inspection.constructs;
+    if (direct && direct.length > 0)
+        return new Set(direct.map((c) => c.id));
+    const reg = inspection
+        .constructRegistry;
+    if (reg && typeof reg.list === 'function') {
+        try {
+            return new Set(reg.list().map((c) => c.id));
+        }
+        catch {
+            return new Set();
+        }
+    }
+    return new Set();
+}
+function listCommandIdsQuietly(inspection) {
+    const cat = inspection.commandCatalog ?? [];
+    const out = new Set();
+    for (const c of cat) {
+        if (c.id)
+            out.add(c.id);
+        if (c.command)
+            out.add(c.command);
+    }
+    return out;
+}
+/**
+ * Async pre-loader for agent-contract test registries. Reads local
+ * sharkcraft/policies.ts, sharkcraft/constructs.ts, sharkcraft/playbooks/
+ * (and pack contributions where present). Result is sync-friendly so the
+ * runner can stay sync.
+ */
+export async function loadAgentContractRegistries(inspection) {
+    return {
+        helpers: loadHelperRegistryQuietly(),
+        playbooks: await loadPlaybookIdsAsync(inspection),
+        policies: await loadPolicyIdsAsync(inspection),
+        constructs: await loadConstructIdsAsync(inspection),
+        commands: listCommandIdsQuietly(inspection),
+        knowledge: new Set(inspection.knowledgeEntries.map((e) => e.id)),
+    };
+}
+async function importDefaultIdsArray(absPath) {
+    if (!existsSync(absPath))
+        return [];
+    try {
+        const mod = (await import(__rewriteRelativeImportExtension(pathToFileURL(absPath).href)));
+        return Array.isArray(mod.default) ? mod.default : [];
+    }
+    catch {
+        return [];
+    }
+}
+async function loadPolicyIdsAsync(inspection) {
+    const out = new Set();
+    if (inspection.sharkcraftDir) {
+        const local = nodePath.join(inspection.sharkcraftDir, 'policies.ts');
+        for (const entry of await importDefaultIdsArray(local)) {
+            if (entry?.id)
+                out.add(entry.id);
+        }
+    }
+    for (const pack of inspection.packs.validPacks) {
+        const c = pack.manifest.contributions;
+        for (const rel of c.policyCheckFiles ?? []) {
+            const full = nodePath.resolve(pack.packageRoot, rel);
+            for (const entry of await importDefaultIdsArray(full)) {
+                if (entry?.id)
+                    out.add(entry.id);
+            }
+        }
+    }
+    // Also include any policyChecks already on the inspection (sync fallback).
+    for (const id of listPolicyIdsQuietly(inspection))
+        out.add(id);
+    return out;
+}
+async function loadPlaybookIdsAsync(inspection) {
+    const out = new Set();
+    // Sync fallback from registry.
+    for (const id of listPlaybookIdsQuietly(inspection))
+        out.add(id);
+    // Local file.
+    if (inspection.sharkcraftDir) {
+        const local = nodePath.join(inspection.sharkcraftDir, 'playbooks.ts');
+        for (const entry of await importDefaultIdsArray(local)) {
+            if (entry?.id)
+                out.add(entry.id);
+        }
+    }
+    // Pack contributions.
+    for (const pack of inspection.packs.validPacks) {
+        const c = pack.manifest.contributions;
+        for (const rel of c.playbookFiles ?? []) {
+            const full = nodePath.resolve(pack.packageRoot, rel);
+            for (const entry of await importDefaultIdsArray(full)) {
+                if (entry?.id)
+                    out.add(entry.id);
+            }
+        }
+    }
+    return out;
+}
+async function loadConstructIdsAsync(inspection) {
+    const out = new Set();
+    // Sync fallback first.
+    for (const id of listConstructIdsQuietly(inspection))
+        out.add(id);
+    if (inspection.sharkcraftDir) {
+        const local = nodePath.join(inspection.sharkcraftDir, 'constructs.ts');
+        for (const entry of await importDefaultIdsArray(local)) {
+            if (entry?.id)
+                out.add(entry.id);
+        }
+    }
+    for (const pack of inspection.packs.validPacks) {
+        const c = pack.manifest.contributions;
+        for (const rel of c.constructFiles ?? []) {
+            const full = nodePath.resolve(pack.packageRoot, rel);
+            for (const entry of await importDefaultIdsArray(full)) {
+                if (entry?.id)
+                    out.add(entry.id);
+            }
+        }
+    }
+    return out;
+}

package/dist/uncertainty-report.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Shared uncertainty report shape.
+ *
+ * Extends `IUncertaintySummary` with a richer surface: reasons /
+ * missingSignals / conflictingSignals / suggestedCommands /
+ * safeFallbackCommand / whatWouldIncreaseConfidence.
+ *
+ * Pure, deterministic; can be derived from `IUncertaintySummary` or a
+ * fresh task packet.
+ */
+import { type IUncertaintySummary } from './uncertainty.js';
+import type { ITaskPacket } from './task-packet.js';
+export declare const UNCERTAINTY_REPORT_SCHEMA = "sharkcraft.uncertainty-report/v1";
+export interface IUncertaintySignalDetail {
+    readonly id: string;
+    readonly message: string;
+}
+export interface IUncertaintyReport {
+    readonly schema: typeof UNCERTAINTY_REPORT_SCHEMA;
+    readonly confidence: 'high' | 'medium' | 'low' | 'unknown';
+    readonly reasons: readonly string[];
+    readonly missingSignals: readonly IUncertaintySignalDetail[];
+    readonly conflictingSignals: readonly IUncertaintySignalDetail[];
+    readonly suggestedCommands: readonly string[];
+    readonly safeFallbackCommand: string;
+    readonly whatWouldIncreaseConfidence: readonly string[];
+}
+export declare function uncertaintyReportFromSummary(summary: IUncertaintySummary, fallback?: string): IUncertaintyReport;
+export declare function buildUncertaintyReportFromPacket(packet: ITaskPacket): IUncertaintyReport;
+/**
+ * Generic builder. Surfaces that don't have a task packet (PR summary,
+ * CI predict, handoff, contract) construct their own `IUncertaintyReport`
+ * by listing concrete signals.
+ */
+export interface IBuildUncertaintyReportInput {
+    readonly confidence: 'high' | 'medium' | 'low' | 'unknown';
+    readonly reasons?: readonly string[];
+    readonly missingSignals?: readonly IUncertaintySignalDetail[];
+    readonly conflictingSignals?: readonly IUncertaintySignalDetail[];
+    readonly suggestedCommands?: readonly string[];
+    readonly safeFallbackCommand: string;
+    readonly whatWouldIncreaseConfidence?: readonly string[];
+}
+export declare function buildUncertaintyReport(input: IBuildUncertaintyReportInput): IUncertaintyReport;
+export declare function renderUncertaintyReportText(report: IUncertaintyReport): string;
+//# sourceMappingURL=uncertainty-report.d.ts.map

package/dist/uncertainty-report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uncertainty-report.d.ts","sourceRoot":"","sources":["../src/uncertainty-report.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAGL,KAAK,mBAAmB,EACzB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,eAAO,MAAM,yBAAyB,qCAAqC,CAAC;AAE5E,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,MAAM,EAAE,OAAO,yBAAyB,CAAC;IAClD,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,GAAG,SAAS,CAAC;IAC3D,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,QAAQ,CAAC,cAAc,EAAE,SAAS,wBAAwB,EAAE,CAAC;IAC7D,QAAQ,CAAC,kBAAkB,EAAE,SAAS,wBAAwB,EAAE,CAAC;IACjE,QAAQ,CAAC,iBAAiB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9C,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,2BAA2B,EAAE,SAAS,MAAM,EAAE,CAAC;CACzD;AAQD,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,mBAAmB,EAC5B,QAAQ,SAAwC,GAC/C,kBAAkB,CA+BpB;AAED,wBAAgB,gCAAgC,CAAC,MAAM,EAAE,WAAW,GAAG,kBAAkB,CAGxF;AAED;;;;GAIG;AACH,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,GAAG,SAAS,CAAC;IAC3D,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,QAAQ,CAAC,cAAc,CAAC,EAAE,SAAS,wBAAwB,EAAE,CAAC;IAC9D,QAAQ,CAAC,kBAAkB,CAAC,EAAE,SAAS,wBAAwB,EAAE,CAAC;IAClE,QAAQ,CAAC,iBAAiB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/C,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,2BAA2B,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1D;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,4BAA4B,GAAG,kBAAkB,CAW9F;AAED,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,kBAAkB,GAAG,MAAM,CA4B9E"}