@idlekit/core 0.2.1 → 0.3.0

package/dist/sim/analysis/contracts.js

@@ -0,0 +1,1230 @@
+import * as _validateReport_1 from "typia/lib/internal/_validateReport";
+import * as _createStandardSchema_1 from "typia/lib/internal/_createStandardSchema";
+import { createHash } from "crypto";
+import typia, {} from "typia";
+/**
+ * Analysis artifact v1.
+ * This is not CLI `_meta` and it does not replace ScenarioV1.
+ * DX-02 owns AnalyzerRegistry. This module does not run analyzers.
+ */
+const ANALYSIS_SCHEMA_ID = "https://idlekit.dev/schemas/analysis.artifact.v1.schema.json";
+const ANALYSIS_ALGORITHM_VERSION = "analysis-artifact-v1";
+export function analysisSchemaId() {
+    return ANALYSIS_SCHEMA_ID;
+}
+export function analysisAlgorithmVersion() {
+    return ANALYSIS_ALGORITHM_VERSION;
+}
+/**
+ * @evidence docs/requirements/active/analysis-contracts.md#req-pr08-shared-goal One predicate feeds the ETA, experiment, and check adapters.
+ * @evidenceReview docs/requirements/active/analysis-contracts.md#req-pr08-shared-goal #89fb124 Re-read the section: the shared id is eta-experiment-check.
+ */
+export const sharedGoalEvaluation = "eta-experiment-check";
+/**
+ * @evidence docs/requirements/active/analysis-contracts.md#req-pr08-custom-metric A model id is registered from the outside. Core does not name that model's resources.
+ * @evidenceReview docs/requirements/active/analysis-contracts.md#req-pr08-custom-metric #9564912 Re-read the section: registration is a registry entry, not a Model method.
+ */
+export const customMetricRegistration = "model-analysis-registry";
+/**
+ * @evidence docs/requirements/active/analysis-contracts.md#req-pr08-analysis-artifact The wire contract is analysis artifact v1. Missing numbers stay absent.
+ * @evidenceReview docs/requirements/active/analysis-contracts.md#req-pr08-analysis-artifact #5f4c544 Re-read the section: the id is idlekit.analysis.artifact.v1 and status is separate from method.
+ */
+export const analysisArtifactContract = "idlekit.analysis.artifact.v1";
+/*
+ * typia runs on first call, not at module load. A plugin that the bundled CLI loads
+ * imports core source without the transform, and a module-load call would throw there.
+ */
+let analysisArtifactValidator;
+export const validateAnalysisArtifact = (input) => (analysisArtifactValidator ??= (() => {
+    const _ip0 = input => Array.isArray(input["assumptions"]) && input["assumptions"].every(elem => "string" === typeof elem);
+    const _ip1 = input => "censored" === input["status"] || "error" === input["status"] || "insufficient-data" === input["status"] || "invalid" === input["status"] || "ok" === input["status"] || "unknown" === input["status"] || "unsupported" === input["status"];
+    const _ip2 = input => undefined === input["method"] || "analytic-local" === input["method"] || "exact" === input["method"] || "fixed-step" === input["method"] || "heuristic-fit" === input["method"] || "monte-carlo" === input["method"];
+    const _ve0 = "Readonly<{ schemaVersion: 1; algorithmVersion: string; assumptions: readonly string[]; warnings: readonly string[]; observationCoverage: ArtifactCoverage; horizon?: Readonly<{ sec: number; kind: \"budget\" | \"duration\" | \"unknown\" | \"until\"; }> | undefined; ... 4 more ...; capabilities: Readonly<...>; }>";
+    const _vp0 = (input, _path, _exceptionable = true) => (Array.isArray(input["assumptions"]) || _report(_exceptionable, {
+        path: _path + ".assumptions",
+        expected: "ReadonlyArray<string>",
+        value: input["assumptions"]
+    })) && input["assumptions"].map((elem, _index5) => "string" === typeof elem || _report(_exceptionable, {
+        path: _path + ".assumptions[" + _index5 + "]",
+        expected: "string",
+        value: elem
+    })).every(flag => flag) || _report(_exceptionable, {
+        path: _path + ".assumptions",
+        expected: "ReadonlyArray<string>",
+        value: input["assumptions"]
+    });
+    const _ve1 = "Readonly<{ metricId: string; metricVersion: number; meaning: string; metricKind: MetricKind; timeAxis: MetricTimeAxis; domain: MetricDomain; reading: \"estimated\" | ... 1 more ... | \"unavailable\"; ... 5 more ...; reason?: string | undefined; }>";
+    const _ve2 = "ReadonlyArray<Readonly<{ metricId: string; metricVersion: number; meaning: string; metricKind: MetricKind; timeAxis: MetricTimeAxis; domain: MetricDomain; reading: \"estimated\" | ... 1 more ... | \"unavailable\"; ... 5 more ...; reason?: string | undefined; }>>";
+    const _ve3 = "Readonly<{ goalId: string; goalVersion: number; status: AnalysisStatus; method?: AnalysisMethod | undefined; reached?: boolean | undefined; atSec?: number | undefined; assumptions: readonly string[]; }>";
+    const _ve4 = "ReadonlyArray<Readonly<{ goalId: string; goalVersion: number; status: AnalysisStatus; method?: AnalysisMethod | undefined; reached?: boolean | undefined; atSec?: number | undefined; assumptions: readonly string[]; }>>";
+    const _ve5 = "Readonly<{ metrics: CapabilityKnowledge; goals: CapabilityKnowledge; reset: CapabilityKnowledge; flow: CapabilityKnowledge; advance: CapabilityKnowledge; }>";
+    const _vp1 = (input, _path, _exceptionable = true) => "censored" === input["status"] || "error" === input["status"] || "insufficient-data" === input["status"] || "invalid" === input["status"] || "ok" === input["status"] || "unknown" === input["status"] || "unsupported" === input["status"] || _report(_exceptionable, {
+        path: _path + ".status",
+        expected: "(\"censored\" | \"error\" | \"insufficient-data\" | \"invalid\" | \"ok\" | \"unknown\" | \"unsupported\")",
+        value: input["status"]
+    });
+    const _vp2 = (input, _path, _exceptionable = true) => undefined === input["method"] || "analytic-local" === input["method"] || "exact" === input["method"] || "fixed-step" === input["method"] || "heuristic-fit" === input["method"] || "monte-carlo" === input["method"] || _report(_exceptionable, {
+        path: _path + ".method",
+        expected: "(\"analytic-local\" | \"exact\" | \"fixed-step\" | \"heuristic-fit\" | \"monte-carlo\" | undefined)",
+        value: input["method"]
+    });
+    const _io0 = input => 1 === input.schemaVersion && "string" === typeof input.algorithmVersion && _ip0(input) && (Array.isArray(input.warnings) && input.warnings.every(elem => "string" === typeof elem)) && ("complete" === input.observationCoverage || "disabled" === input.observationCoverage || "incomplete" === input.observationCoverage || "partial" === input.observationCoverage || "unknown" === input.observationCoverage) && (undefined === input.horizon || "object" === typeof input.horizon && null !== input.horizon && _io1(input.horizon)) && (undefined === input.sampleCount || "number" === typeof input.sampleCount) && (undefined === input.effectiveRunHash || "string" === typeof input.effectiveRunHash) && (Array.isArray(input.metrics) && input.metrics.every(elem => "object" === typeof elem && null !== elem && _io2(elem))) && (Array.isArray(input.goals) && input.goals.every(elem => "object" === typeof elem && null !== elem && _io4(elem))) && ("object" === typeof input.capabilities && null !== input.capabilities && _io5(input.capabilities));
+    const _io1 = input => "number" === typeof input.sec && ("budget" === input.kind || "duration" === input.kind || "unknown" === input.kind || "until" === input.kind);
+    const _io2 = input => "string" === typeof input.metricId && "number" === typeof input.metricVersion && "string" === typeof input.meaning && ("cumulative" === input.metricKind || "stock" === input.metricKind) && ("instant" === input.timeAxis || "interval" === input.timeAxis) && ("amount" === input.domain || "count" === input.domain || "ratio" === input.domain || "time" === input.domain) && ("estimated" === input.reading || "observed" === input.reading || "unavailable" === input.reading) && _ip1(input) && _ip2(input) && (undefined === input.sign || "negative" === input.sign || "nonfinite" === input.sign || "positive" === input.sign || "zero" === input.sign) && (undefined === input.amount || "object" === typeof input.amount && null !== input.amount && _io3(input.amount)) && (undefined === input.value || "number" === typeof input.value) && (undefined === input.reason || "string" === typeof input.reason);
+    const _io3 = input => "string" === typeof input.unit && "string" === typeof input.decimal;
+    const _io4 = input => "string" === typeof input.goalId && "number" === typeof input.goalVersion && _ip1(input) && _ip2(input) && (undefined === input.reached || "boolean" === typeof input.reached) && (undefined === input.atSec || "number" === typeof input.atSec) && _ip0(input);
+    const _io5 = input => ("statically-known" === input.metrics || "unknown" === input.metrics || "unsupported" === input.metrics) && ("statically-known" === input.goals || "unknown" === input.goals || "unsupported" === input.goals) && ("statically-known" === input.reset || "unknown" === input.reset || "unsupported" === input.reset) && ("statically-known" === input.flow || "unknown" === input.flow || "unsupported" === input.flow) && ("statically-known" === input.advance || "unknown" === input.advance || "unsupported" === input.advance);
+    const _vo0 = (input, _path, _exceptionable = true) => [1 === input.schemaVersion || _report(_exceptionable, {
+            path: _path + ".schemaVersion",
+            expected: "1",
+            value: input.schemaVersion
+        }), "string" === typeof input.algorithmVersion || _report(_exceptionable, {
+            path: _path + ".algorithmVersion",
+            expected: "string",
+            value: input.algorithmVersion
+        }), _vp0(input, _path, true && _exceptionable), (Array.isArray(input.warnings) || _report(_exceptionable, {
+            path: _path + ".warnings",
+            expected: "ReadonlyArray<string>",
+            value: input.warnings
+        })) && input.warnings.map((elem, _index6) => "string" === typeof elem || _report(_exceptionable, {
+            path: _path + ".warnings[" + _index6 + "]",
+            expected: "string",
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + ".warnings",
+            expected: "ReadonlyArray<string>",
+            value: input.warnings
+        }), "complete" === input.observationCoverage || "disabled" === input.observationCoverage || "incomplete" === input.observationCoverage || "partial" === input.observationCoverage || "unknown" === input.observationCoverage || _report(_exceptionable, {
+            path: _path + ".observationCoverage",
+            expected: "(\"complete\" | \"disabled\" | \"incomplete\" | \"partial\" | \"unknown\")",
+            value: input.observationCoverage
+        }), undefined === input.horizon || ("object" === typeof input.horizon && null !== input.horizon || _report(_exceptionable, {
+            path: _path + ".horizon",
+            expected: "(Readonly<{ sec: number; kind: \"budget\" | \"duration\" | \"unknown\" | \"until\"; }> | undefined)",
+            value: input.horizon
+        })) && _vo1(input.horizon, _path + ".horizon", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".horizon",
+            expected: "(Readonly<{ sec: number; kind: \"budget\" | \"duration\" | \"unknown\" | \"until\"; }> | undefined)",
+            value: input.horizon
+        }), undefined === input.sampleCount || "number" === typeof input.sampleCount || _report(_exceptionable, {
+            path: _path + ".sampleCount",
+            expected: "(number | undefined)",
+            value: input.sampleCount
+        }), undefined === input.effectiveRunHash || "string" === typeof input.effectiveRunHash || _report(_exceptionable, {
+            path: _path + ".effectiveRunHash",
+            expected: "(string | undefined)",
+            value: input.effectiveRunHash
+        }), (Array.isArray(input.metrics) || _report(_exceptionable, {
+            path: _path + ".metrics",
+            expected: _ve2,
+            value: input.metrics
+        })) && input.metrics.map((elem, _index7) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+            path: _path + ".metrics[" + _index7 + "]",
+            expected: _ve1,
+            value: elem
+        })) && _vo2(elem, _path + ".metrics[" + _index7 + "]", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".metrics[" + _index7 + "]",
+            expected: _ve1,
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + ".metrics",
+            expected: _ve2,
+            value: input.metrics
+        }), (Array.isArray(input.goals) || _report(_exceptionable, {
+            path: _path + ".goals",
+            expected: _ve4,
+            value: input.goals
+        })) && input.goals.map((elem, _index8) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+            path: _path + ".goals[" + _index8 + "]",
+            expected: _ve3,
+            value: elem
+        })) && _vo4(elem, _path + ".goals[" + _index8 + "]", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".goals[" + _index8 + "]",
+            expected: _ve3,
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + ".goals",
+            expected: _ve4,
+            value: input.goals
+        }), ("object" === typeof input.capabilities && null !== input.capabilities || _report(_exceptionable, {
+            path: _path + ".capabilities",
+            expected: _ve5,
+            value: input.capabilities
+        })) && _vo5(input.capabilities, _path + ".capabilities", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".capabilities",
+            expected: _ve5,
+            value: input.capabilities
+        })].every(flag => flag);
+    const _vo1 = (input, _path, _exceptionable = true) => ["number" === typeof input.sec || _report(_exceptionable, {
+            path: _path + ".sec",
+            expected: "number",
+            value: input.sec
+        }), "budget" === input.kind || "duration" === input.kind || "unknown" === input.kind || "until" === input.kind || _report(_exceptionable, {
+            path: _path + ".kind",
+            expected: "(\"budget\" | \"duration\" | \"unknown\" | \"until\")",
+            value: input.kind
+        })].every(flag => flag);
+    const _vo2 = (input, _path, _exceptionable = true) => ["string" === typeof input.metricId || _report(_exceptionable, {
+            path: _path + ".metricId",
+            expected: "string",
+            value: input.metricId
+        }), "number" === typeof input.metricVersion || _report(_exceptionable, {
+            path: _path + ".metricVersion",
+            expected: "number",
+            value: input.metricVersion
+        }), "string" === typeof input.meaning || _report(_exceptionable, {
+            path: _path + ".meaning",
+            expected: "string",
+            value: input.meaning
+        }), "cumulative" === input.metricKind || "stock" === input.metricKind || _report(_exceptionable, {
+            path: _path + ".metricKind",
+            expected: "(\"cumulative\" | \"stock\")",
+            value: input.metricKind
+        }), "instant" === input.timeAxis || "interval" === input.timeAxis || _report(_exceptionable, {
+            path: _path + ".timeAxis",
+            expected: "(\"instant\" | \"interval\")",
+            value: input.timeAxis
+        }), "amount" === input.domain || "count" === input.domain || "ratio" === input.domain || "time" === input.domain || _report(_exceptionable, {
+            path: _path + ".domain",
+            expected: "(\"amount\" | \"count\" | \"ratio\" | \"time\")",
+            value: input.domain
+        }), "estimated" === input.reading || "observed" === input.reading || "unavailable" === input.reading || _report(_exceptionable, {
+            path: _path + ".reading",
+            expected: "(\"estimated\" | \"observed\" | \"unavailable\")",
+            value: input.reading
+        }), _vp1(input, _path, true && _exceptionable), _vp2(input, _path, true && _exceptionable), undefined === input.sign || "negative" === input.sign || "nonfinite" === input.sign || "positive" === input.sign || "zero" === input.sign || _report(_exceptionable, {
+            path: _path + ".sign",
+            expected: "(\"negative\" | \"nonfinite\" | \"positive\" | \"zero\" | undefined)",
+            value: input.sign
+        }), undefined === input.amount || ("object" === typeof input.amount && null !== input.amount || _report(_exceptionable, {
+            path: _path + ".amount",
+            expected: "(Readonly<{ unit: string; decimal: string; }> | undefined)",
+            value: input.amount
+        })) && _vo3(input.amount, _path + ".amount", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".amount",
+            expected: "(Readonly<{ unit: string; decimal: string; }> | undefined)",
+            value: input.amount
+        }), undefined === input.value || "number" === typeof input.value || _report(_exceptionable, {
+            path: _path + ".value",
+            expected: "(number | undefined)",
+            value: input.value
+        }), undefined === input.reason || "string" === typeof input.reason || _report(_exceptionable, {
+            path: _path + ".reason",
+            expected: "(string | undefined)",
+            value: input.reason
+        })].every(flag => flag);
+    const _vo3 = (input, _path, _exceptionable = true) => ["string" === typeof input.unit || _report(_exceptionable, {
+            path: _path + ".unit",
+            expected: "string",
+            value: input.unit
+        }), "string" === typeof input.decimal || _report(_exceptionable, {
+            path: _path + ".decimal",
+            expected: "string",
+            value: input.decimal
+        })].every(flag => flag);
+    const _vo4 = (input, _path, _exceptionable = true) => ["string" === typeof input.goalId || _report(_exceptionable, {
+            path: _path + ".goalId",
+            expected: "string",
+            value: input.goalId
+        }), "number" === typeof input.goalVersion || _report(_exceptionable, {
+            path: _path + ".goalVersion",
+            expected: "number",
+            value: input.goalVersion
+        }), _vp1(input, _path, true && _exceptionable), _vp2(input, _path, true && _exceptionable), undefined === input.reached || "boolean" === typeof input.reached || _report(_exceptionable, {
+            path: _path + ".reached",
+            expected: "(boolean | undefined)",
+            value: input.reached
+        }), undefined === input.atSec || "number" === typeof input.atSec || _report(_exceptionable, {
+            path: _path + ".atSec",
+            expected: "(number | undefined)",
+            value: input.atSec
+        }), _vp0(input, _path, true && _exceptionable)].every(flag => flag);
+    const _vo5 = (input, _path, _exceptionable = true) => ["statically-known" === input.metrics || "unknown" === input.metrics || "unsupported" === input.metrics || _report(_exceptionable, {
+            path: _path + ".metrics",
+            expected: "(\"statically-known\" | \"unknown\" | \"unsupported\")",
+            value: input.metrics
+        }), "statically-known" === input.goals || "unknown" === input.goals || "unsupported" === input.goals || _report(_exceptionable, {
+            path: _path + ".goals",
+            expected: "(\"statically-known\" | \"unknown\" | \"unsupported\")",
+            value: input.goals
+        }), "statically-known" === input.reset || "unknown" === input.reset || "unsupported" === input.reset || _report(_exceptionable, {
+            path: _path + ".reset",
+            expected: "(\"statically-known\" | \"unknown\" | \"unsupported\")",
+            value: input.reset
+        }), "statically-known" === input.flow || "unknown" === input.flow || "unsupported" === input.flow || _report(_exceptionable, {
+            path: _path + ".flow",
+            expected: "(\"statically-known\" | \"unknown\" | \"unsupported\")",
+            value: input.flow
+        }), "statically-known" === input.advance || "unknown" === input.advance || "unsupported" === input.advance || _report(_exceptionable, {
+            path: _path + ".advance",
+            expected: "(\"statically-known\" | \"unknown\" | \"unsupported\")",
+            value: input.advance
+        })].every(flag => flag);
+    const __is = input => "object" === typeof input && null !== input && _io0(input);
+    let errors;
+    let _report;
+    return _createStandardSchema_1._createStandardSchema(input => {
+        if (false === __is(input)) {
+            errors = [];
+            _report = _validateReport_1._validateReport(errors);
+            ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                path: _path + "",
+                expected: _ve0,
+                value: input
+            })) && _vo0(input, _path + "", true) || _report(true, {
+                path: _path + "",
+                expected: _ve0,
+                value: input
+            }))(input, "$input", true);
+            const success = 0 === errors.length;
+            return success ? {
+                success,
+                data: input
+            } : {
+                success,
+                errors,
+                data: input
+            };
+        }
+        return {
+            success: true,
+            data: input
+        };
+    });
+})())(input);
+export function parseAnalysisArtifact(input) {
+    return (() => {
+        const _ip0 = input => Array.isArray(input["assumptions"]) && input["assumptions"].every(elem => "string" === typeof elem);
+        const _ip1 = input => "censored" === input["status"] || "error" === input["status"] || "insufficient-data" === input["status"] || "invalid" === input["status"] || "ok" === input["status"] || "unknown" === input["status"] || "unsupported" === input["status"];
+        const _ip2 = input => undefined === input["method"] || "analytic-local" === input["method"] || "exact" === input["method"] || "fixed-step" === input["method"] || "heuristic-fit" === input["method"] || "monte-carlo" === input["method"];
+        const _ve0 = "Readonly<{ schemaVersion: 1; algorithmVersion: string; assumptions: readonly string[]; warnings: readonly string[]; observationCoverage: ArtifactCoverage; horizon?: Readonly<{ sec: number; kind: \"budget\" | \"duration\" | \"unknown\" | \"until\"; }> | undefined; ... 4 more ...; capabilities: Readonly<...>; }>";
+        const _vp0 = (input, _path, _exceptionable = true) => (Array.isArray(input["assumptions"]) || _report(_exceptionable, {
+            path: _path + ".assumptions",
+            expected: "ReadonlyArray<string>",
+            value: input["assumptions"]
+        })) && input["assumptions"].map((elem, _index5) => "string" === typeof elem || _report(_exceptionable, {
+            path: _path + ".assumptions[" + _index5 + "]",
+            expected: "string",
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + ".assumptions",
+            expected: "ReadonlyArray<string>",
+            value: input["assumptions"]
+        });
+        const _ve1 = "Readonly<{ metricId: string; metricVersion: number; meaning: string; metricKind: MetricKind; timeAxis: MetricTimeAxis; domain: MetricDomain; reading: \"estimated\" | ... 1 more ... | \"unavailable\"; ... 5 more ...; reason?: string | undefined; }>";
+        const _ve2 = "ReadonlyArray<Readonly<{ metricId: string; metricVersion: number; meaning: string; metricKind: MetricKind; timeAxis: MetricTimeAxis; domain: MetricDomain; reading: \"estimated\" | ... 1 more ... | \"unavailable\"; ... 5 more ...; reason?: string | undefined; }>>";
+        const _ve3 = "Readonly<{ goalId: string; goalVersion: number; status: AnalysisStatus; method?: AnalysisMethod | undefined; reached?: boolean | undefined; atSec?: number | undefined; assumptions: readonly string[]; }>";
+        const _ve4 = "ReadonlyArray<Readonly<{ goalId: string; goalVersion: number; status: AnalysisStatus; method?: AnalysisMethod | undefined; reached?: boolean | undefined; atSec?: number | undefined; assumptions: readonly string[]; }>>";
+        const _ve5 = "Readonly<{ metrics: CapabilityKnowledge; goals: CapabilityKnowledge; reset: CapabilityKnowledge; flow: CapabilityKnowledge; advance: CapabilityKnowledge; }>";
+        const _vp1 = (input, _path, _exceptionable = true) => "censored" === input["status"] || "error" === input["status"] || "insufficient-data" === input["status"] || "invalid" === input["status"] || "ok" === input["status"] || "unknown" === input["status"] || "unsupported" === input["status"] || _report(_exceptionable, {
+            path: _path + ".status",
+            expected: "(\"censored\" | \"error\" | \"insufficient-data\" | \"invalid\" | \"ok\" | \"unknown\" | \"unsupported\")",
+            value: input["status"]
+        });
+        const _vp2 = (input, _path, _exceptionable = true) => undefined === input["method"] || "analytic-local" === input["method"] || "exact" === input["method"] || "fixed-step" === input["method"] || "heuristic-fit" === input["method"] || "monte-carlo" === input["method"] || _report(_exceptionable, {
+            path: _path + ".method",
+            expected: "(\"analytic-local\" | \"exact\" | \"fixed-step\" | \"heuristic-fit\" | \"monte-carlo\" | undefined)",
+            value: input["method"]
+        });
+        const _io0 = input => 1 === input.schemaVersion && "string" === typeof input.algorithmVersion && _ip0(input) && (Array.isArray(input.warnings) && input.warnings.every(elem => "string" === typeof elem)) && ("complete" === input.observationCoverage || "disabled" === input.observationCoverage || "incomplete" === input.observationCoverage || "partial" === input.observationCoverage || "unknown" === input.observationCoverage) && (undefined === input.horizon || "object" === typeof input.horizon && null !== input.horizon && _io1(input.horizon)) && (undefined === input.sampleCount || "number" === typeof input.sampleCount) && (undefined === input.effectiveRunHash || "string" === typeof input.effectiveRunHash) && (Array.isArray(input.metrics) && input.metrics.every(elem => "object" === typeof elem && null !== elem && _io2(elem))) && (Array.isArray(input.goals) && input.goals.every(elem => "object" === typeof elem && null !== elem && _io4(elem))) && ("object" === typeof input.capabilities && null !== input.capabilities && _io5(input.capabilities));
+        const _io1 = input => "number" === typeof input.sec && ("budget" === input.kind || "duration" === input.kind || "unknown" === input.kind || "until" === input.kind);
+        const _io2 = input => "string" === typeof input.metricId && "number" === typeof input.metricVersion && "string" === typeof input.meaning && ("cumulative" === input.metricKind || "stock" === input.metricKind) && ("instant" === input.timeAxis || "interval" === input.timeAxis) && ("amount" === input.domain || "count" === input.domain || "ratio" === input.domain || "time" === input.domain) && ("estimated" === input.reading || "observed" === input.reading || "unavailable" === input.reading) && _ip1(input) && _ip2(input) && (undefined === input.sign || "negative" === input.sign || "nonfinite" === input.sign || "positive" === input.sign || "zero" === input.sign) && (undefined === input.amount || "object" === typeof input.amount && null !== input.amount && _io3(input.amount)) && (undefined === input.value || "number" === typeof input.value) && (undefined === input.reason || "string" === typeof input.reason);
+        const _io3 = input => "string" === typeof input.unit && "string" === typeof input.decimal;
+        const _io4 = input => "string" === typeof input.goalId && "number" === typeof input.goalVersion && _ip1(input) && _ip2(input) && (undefined === input.reached || "boolean" === typeof input.reached) && (undefined === input.atSec || "number" === typeof input.atSec) && _ip0(input);
+        const _io5 = input => ("statically-known" === input.metrics || "unknown" === input.metrics || "unsupported" === input.metrics) && ("statically-known" === input.goals || "unknown" === input.goals || "unsupported" === input.goals) && ("statically-known" === input.reset || "unknown" === input.reset || "unsupported" === input.reset) && ("statically-known" === input.flow || "unknown" === input.flow || "unsupported" === input.flow) && ("statically-known" === input.advance || "unknown" === input.advance || "unsupported" === input.advance);
+        const _vo0 = (input, _path, _exceptionable = true) => [1 === input.schemaVersion || _report(_exceptionable, {
+                path: _path + ".schemaVersion",
+                expected: "1",
+                value: input.schemaVersion
+            }), "string" === typeof input.algorithmVersion || _report(_exceptionable, {
+                path: _path + ".algorithmVersion",
+                expected: "string",
+                value: input.algorithmVersion
+            }), _vp0(input, _path, true && _exceptionable), (Array.isArray(input.warnings) || _report(_exceptionable, {
+                path: _path + ".warnings",
+                expected: "ReadonlyArray<string>",
+                value: input.warnings
+            })) && input.warnings.map((elem, _index6) => "string" === typeof elem || _report(_exceptionable, {
+                path: _path + ".warnings[" + _index6 + "]",
+                expected: "string",
+                value: elem
+            })).every(flag => flag) || _report(_exceptionable, {
+                path: _path + ".warnings",
+                expected: "ReadonlyArray<string>",
+                value: input.warnings
+            }), "complete" === input.observationCoverage || "disabled" === input.observationCoverage || "incomplete" === input.observationCoverage || "partial" === input.observationCoverage || "unknown" === input.observationCoverage || _report(_exceptionable, {
+                path: _path + ".observationCoverage",
+                expected: "(\"complete\" | \"disabled\" | \"incomplete\" | \"partial\" | \"unknown\")",
+                value: input.observationCoverage
+            }), undefined === input.horizon || ("object" === typeof input.horizon && null !== input.horizon || _report(_exceptionable, {
+                path: _path + ".horizon",
+                expected: "(Readonly<{ sec: number; kind: \"budget\" | \"duration\" | \"unknown\" | \"until\"; }> | undefined)",
+                value: input.horizon
+            })) && _vo1(input.horizon, _path + ".horizon", true && _exceptionable) || _report(_exceptionable, {
+                path: _path + ".horizon",
+                expected: "(Readonly<{ sec: number; kind: \"budget\" | \"duration\" | \"unknown\" | \"until\"; }> | undefined)",
+                value: input.horizon
+            }), undefined === input.sampleCount || "number" === typeof input.sampleCount || _report(_exceptionable, {
+                path: _path + ".sampleCount",
+                expected: "(number | undefined)",
+                value: input.sampleCount
+            }), undefined === input.effectiveRunHash || "string" === typeof input.effectiveRunHash || _report(_exceptionable, {
+                path: _path + ".effectiveRunHash",
+                expected: "(string | undefined)",
+                value: input.effectiveRunHash
+            }), (Array.isArray(input.metrics) || _report(_exceptionable, {
+                path: _path + ".metrics",
+                expected: _ve2,
+                value: input.metrics
+            })) && input.metrics.map((elem, _index7) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                path: _path + ".metrics[" + _index7 + "]",
+                expected: _ve1,
+                value: elem
+            })) && _vo2(elem, _path + ".metrics[" + _index7 + "]", true && _exceptionable) || _report(_exceptionable, {
+                path: _path + ".metrics[" + _index7 + "]",
+                expected: _ve1,
+                value: elem
+            })).every(flag => flag) || _report(_exceptionable, {
+                path: _path + ".metrics",
+                expected: _ve2,
+                value: input.metrics
+            }), (Array.isArray(input.goals) || _report(_exceptionable, {
+                path: _path + ".goals",
+                expected: _ve4,
+                value: input.goals
+            })) && input.goals.map((elem, _index8) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                path: _path + ".goals[" + _index8 + "]",
+                expected: _ve3,
+                value: elem
+            })) && _vo4(elem, _path + ".goals[" + _index8 + "]", true && _exceptionable) || _report(_exceptionable, {
+                path: _path + ".goals[" + _index8 + "]",
+                expected: _ve3,
+                value: elem
+            })).every(flag => flag) || _report(_exceptionable, {
+                path: _path + ".goals",
+                expected: _ve4,
+                value: input.goals
+            }), ("object" === typeof input.capabilities && null !== input.capabilities || _report(_exceptionable, {
+                path: _path + ".capabilities",
+                expected: _ve5,
+                value: input.capabilities
+            })) && _vo5(input.capabilities, _path + ".capabilities", true && _exceptionable) || _report(_exceptionable, {
+                path: _path + ".capabilities",
+                expected: _ve5,
+                value: input.capabilities
+            })].every(flag => flag);
+        const _vo1 = (input, _path, _exceptionable = true) => ["number" === typeof input.sec || _report(_exceptionable, {
+                path: _path + ".sec",
+                expected: "number",
+                value: input.sec
+            }), "budget" === input.kind || "duration" === input.kind || "unknown" === input.kind || "until" === input.kind || _report(_exceptionable, {
+                path: _path + ".kind",
+                expected: "(\"budget\" | \"duration\" | \"unknown\" | \"until\")",
+                value: input.kind
+            })].every(flag => flag);
+        const _vo2 = (input, _path, _exceptionable = true) => ["string" === typeof input.metricId || _report(_exceptionable, {
+                path: _path + ".metricId",
+                expected: "string",
+                value: input.metricId
+            }), "number" === typeof input.metricVersion || _report(_exceptionable, {
+                path: _path + ".metricVersion",
+                expected: "number",
+                value: input.metricVersion
+            }), "string" === typeof input.meaning || _report(_exceptionable, {
+                path: _path + ".meaning",
+                expected: "string",
+                value: input.meaning
+            }), "cumulative" === input.metricKind || "stock" === input.metricKind || _report(_exceptionable, {
+                path: _path + ".metricKind",
+                expected: "(\"cumulative\" | \"stock\")",
+                value: input.metricKind
+            }), "instant" === input.timeAxis || "interval" === input.timeAxis || _report(_exceptionable, {
+                path: _path + ".timeAxis",
+                expected: "(\"instant\" | \"interval\")",
+                value: input.timeAxis
+            }), "amount" === input.domain || "count" === input.domain || "ratio" === input.domain || "time" === input.domain || _report(_exceptionable, {
+                path: _path + ".domain",
+                expected: "(\"amount\" | \"count\" | \"ratio\" | \"time\")",
+                value: input.domain
+            }), "estimated" === input.reading || "observed" === input.reading || "unavailable" === input.reading || _report(_exceptionable, {
+                path: _path + ".reading",
+                expected: "(\"estimated\" | \"observed\" | \"unavailable\")",
+                value: input.reading
+            }), _vp1(input, _path, true && _exceptionable), _vp2(input, _path, true && _exceptionable), undefined === input.sign || "negative" === input.sign || "nonfinite" === input.sign || "positive" === input.sign || "zero" === input.sign || _report(_exceptionable, {
+                path: _path + ".sign",
+                expected: "(\"negative\" | \"nonfinite\" | \"positive\" | \"zero\" | undefined)",
+                value: input.sign
+            }), undefined === input.amount || ("object" === typeof input.amount && null !== input.amount || _report(_exceptionable, {
+                path: _path + ".amount",
+                expected: "(Readonly<{ unit: string; decimal: string; }> | undefined)",
+                value: input.amount
+            })) && _vo3(input.amount, _path + ".amount", true && _exceptionable) || _report(_exceptionable, {
+                path: _path + ".amount",
+                expected: "(Readonly<{ unit: string; decimal: string; }> | undefined)",
+                value: input.amount
+            }), undefined === input.value || "number" === typeof input.value || _report(_exceptionable, {
+                path: _path + ".value",
+                expected: "(number | undefined)",
+                value: input.value
+            }), undefined === input.reason || "string" === typeof input.reason || _report(_exceptionable, {
+                path: _path + ".reason",
+                expected: "(string | undefined)",
+                value: input.reason
+            })].every(flag => flag);
+        const _vo3 = (input, _path, _exceptionable = true) => ["string" === typeof input.unit || _report(_exceptionable, {
+                path: _path + ".unit",
+                expected: "string",
+                value: input.unit
+            }), "string" === typeof input.decimal || _report(_exceptionable, {
+                path: _path + ".decimal",
+                expected: "string",
+                value: input.decimal
+            })].every(flag => flag);
+        const _vo4 = (input, _path, _exceptionable = true) => ["string" === typeof input.goalId || _report(_exceptionable, {
+                path: _path + ".goalId",
+                expected: "string",
+                value: input.goalId
+            }), "number" === typeof input.goalVersion || _report(_exceptionable, {
+                path: _path + ".goalVersion",
+                expected: "number",
+                value: input.goalVersion
+            }), _vp1(input, _path, true && _exceptionable), _vp2(input, _path, true && _exceptionable), undefined === input.reached || "boolean" === typeof input.reached || _report(_exceptionable, {
+                path: _path + ".reached",
+                expected: "(boolean | undefined)",
+                value: input.reached
+            }), undefined === input.atSec || "number" === typeof input.atSec || _report(_exceptionable, {
+                path: _path + ".atSec",
+                expected: "(number | undefined)",
+                value: input.atSec
+            }), _vp0(input, _path, true && _exceptionable)].every(flag => flag);
+        const _vo5 = (input, _path, _exceptionable = true) => ["statically-known" === input.metrics || "unknown" === input.metrics || "unsupported" === input.metrics || _report(_exceptionable, {
+                path: _path + ".metrics",
+                expected: "(\"statically-known\" | \"unknown\" | \"unsupported\")",
+                value: input.metrics
+            }), "statically-known" === input.goals || "unknown" === input.goals || "unsupported" === input.goals || _report(_exceptionable, {
+                path: _path + ".goals",
+                expected: "(\"statically-known\" | \"unknown\" | \"unsupported\")",
+                value: input.goals
+            }), "statically-known" === input.reset || "unknown" === input.reset || "unsupported" === input.reset || _report(_exceptionable, {
+                path: _path + ".reset",
+                expected: "(\"statically-known\" | \"unknown\" | \"unsupported\")",
+                value: input.reset
+            }), "statically-known" === input.flow || "unknown" === input.flow || "unsupported" === input.flow || _report(_exceptionable, {
+                path: _path + ".flow",
+                expected: "(\"statically-known\" | \"unknown\" | \"unsupported\")",
+                value: input.flow
+            }), "statically-known" === input.advance || "unknown" === input.advance || "unsupported" === input.advance || _report(_exceptionable, {
+                path: _path + ".advance",
+                expected: "(\"statically-known\" | \"unknown\" | \"unsupported\")",
+                value: input.advance
+            })].every(flag => flag);
+        const __is = input => "object" === typeof input && null !== input && _io0(input);
+        let errors;
+        let _report;
+        const __validate = input => {
+            if (false === __is(input)) {
+                errors = [];
+                _report = _validateReport_1._validateReport(errors);
+                ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                    path: _path + "",
+                    expected: _ve0,
+                    value: input
+                })) && _vo0(input, _path + "", true) || _report(true, {
+                    path: _path + "",
+                    expected: _ve0,
+                    value: input
+                }))(input, "$input", true);
+                const success = 0 === errors.length;
+                return success ? {
+                    success,
+                    data: input
+                } : {
+                    success,
+                    errors,
+                    data: input
+                };
+            }
+            return {
+                success: true,
+                data: input
+            };
+        };
+        return input => __validate(JSON.parse(input));
+    })()(input);
+}
+function buildAnalysisArtifactJsonSchema() {
+    return {
+        components: {
+            schemas: {
+                "ReadonlyschemaVersion1algorithmVersionstringassumptionsreadonlystringwarningsreadonlystringobservationCoverageArtifactCoveragehorizonReadonlysecnumberkindbudgetdurationunknownuntilundefined---4more---capabilitiesReadonly---": {
+                    type: "object",
+                    properties: {
+                        schemaVersion: {
+                            "const": 1
+                        },
+                        algorithmVersion: {
+                            type: "string"
+                        },
+                        assumptions: {
+                            type: "array",
+                            items: {
+                                type: "string"
+                            }
+                        },
+                        warnings: {
+                            type: "array",
+                            items: {
+                                type: "string"
+                            }
+                        },
+                        observationCoverage: {
+                            $ref: "#/components/schemas/ArtifactCoverage"
+                        },
+                        horizon: {
+                            $ref: "#/components/schemas/Readonlysecnumberkindbudgetdurationunknownuntil"
+                        },
+                        sampleCount: {
+                            type: "number"
+                        },
+                        effectiveRunHash: {
+                            type: "string"
+                        },
+                        metrics: {
+                            type: "array",
+                            items: {
+                                $ref: "#/components/schemas/ReadonlymetricIdstringmetricVersionnumbermeaningstringmetricKindMetricKindtimeAxisMetricTimeAxisdomainMetricDomainreadingestimated---1more---unavailable---5more---reasonstringundefined"
+                            }
+                        },
+                        goals: {
+                            type: "array",
+                            items: {
+                                $ref: "#/components/schemas/ReadonlygoalIdstringgoalVersionnumberstatusAnalysisStatusmethodAnalysisMethodundefinedreachedbooleanundefinedatSecnumberundefinedassumptionsreadonlystring"
+                            }
+                        },
+                        capabilities: {
+                            $ref: "#/components/schemas/ReadonlymetricsCapabilityKnowledgegoalsCapabilityKnowledgeresetCapabilityKnowledgeflowCapabilityKnowledgeadvanceCapabilityKnowledge"
+                        }
+                    },
+                    required: [
+                        "schemaVersion",
+                        "algorithmVersion",
+                        "assumptions",
+                        "warnings",
+                        "observationCoverage",
+                        "metrics",
+                        "goals",
+                        "capabilities"
+                    ],
+                    additionalProperties: false
+                },
+                ArtifactCoverage: {
+                    oneOf: [
+                        {
+                            "const": "complete"
+                        },
+                        {
+                            "const": "disabled"
+                        },
+                        {
+                            "const": "incomplete"
+                        },
+                        {
+                            "const": "partial"
+                        },
+                        {
+                            "const": "unknown"
+                        }
+                    ]
+                },
+                Readonlysecnumberkindbudgetdurationunknownuntil: {
+                    type: "object",
+                    properties: {
+                        sec: {
+                            type: "number"
+                        },
+                        kind: {
+                            oneOf: [
+                                {
+                                    "const": "budget"
+                                },
+                                {
+                                    "const": "duration"
+                                },
+                                {
+                                    "const": "unknown"
+                                },
+                                {
+                                    "const": "until"
+                                }
+                            ]
+                        }
+                    },
+                    required: [
+                        "sec",
+                        "kind"
+                    ],
+                    additionalProperties: false
+                },
+                "ReadonlymetricIdstringmetricVersionnumbermeaningstringmetricKindMetricKindtimeAxisMetricTimeAxisdomainMetricDomainreadingestimated---1more---unavailable---5more---reasonstringundefined": {
+                    type: "object",
+                    properties: {
+                        metricId: {
+                            type: "string"
+                        },
+                        metricVersion: {
+                            type: "number"
+                        },
+                        meaning: {
+                            type: "string"
+                        },
+                        metricKind: {
+                            $ref: "#/components/schemas/MetricKind"
+                        },
+                        timeAxis: {
+                            $ref: "#/components/schemas/MetricTimeAxis"
+                        },
+                        domain: {
+                            $ref: "#/components/schemas/MetricDomain"
+                        },
+                        reading: {
+                            oneOf: [
+                                {
+                                    "const": "estimated"
+                                },
+                                {
+                                    "const": "observed"
+                                },
+                                {
+                                    "const": "unavailable"
+                                }
+                            ]
+                        },
+                        status: {
+                            $ref: "#/components/schemas/AnalysisStatus"
+                        },
+                        method: {
+                            oneOf: [
+                                {
+                                    "const": "analytic-local"
+                                },
+                                {
+                                    "const": "exact"
+                                },
+                                {
+                                    "const": "fixed-step"
+                                },
+                                {
+                                    "const": "heuristic-fit"
+                                },
+                                {
+                                    "const": "monte-carlo"
+                                }
+                            ]
+                        },
+                        sign: {
+                            oneOf: [
+                                {
+                                    "const": "negative"
+                                },
+                                {
+                                    "const": "nonfinite"
+                                },
+                                {
+                                    "const": "positive"
+                                },
+                                {
+                                    "const": "zero"
+                                }
+                            ]
+                        },
+                        amount: {
+                            $ref: "#/components/schemas/Readonlyunitstringdecimalstring"
+                        },
+                        value: {
+                            type: "number"
+                        },
+                        reason: {
+                            type: "string"
+                        }
+                    },
+                    required: [
+                        "metricId",
+                        "metricVersion",
+                        "meaning",
+                        "metricKind",
+                        "timeAxis",
+                        "domain",
+                        "reading",
+                        "status"
+                    ],
+                    additionalProperties: false
+                },
+                MetricKind: {
+                    oneOf: [
+                        {
+                            "const": "cumulative"
+                        },
+                        {
+                            "const": "stock"
+                        }
+                    ]
+                },
+                MetricTimeAxis: {
+                    oneOf: [
+                        {
+                            "const": "instant"
+                        },
+                        {
+                            "const": "interval"
+                        }
+                    ]
+                },
+                MetricDomain: {
+                    oneOf: [
+                        {
+                            "const": "amount"
+                        },
+                        {
+                            "const": "count"
+                        },
+                        {
+                            "const": "ratio"
+                        },
+                        {
+                            "const": "time"
+                        }
+                    ]
+                },
+                AnalysisStatus: {
+                    oneOf: [
+                        {
+                            "const": "censored"
+                        },
+                        {
+                            "const": "error"
+                        },
+                        {
+                            "const": "insufficient-data"
+                        },
+                        {
+                            "const": "invalid"
+                        },
+                        {
+                            "const": "ok"
+                        },
+                        {
+                            "const": "unknown"
+                        },
+                        {
+                            "const": "unsupported"
+                        }
+                    ]
+                },
+                Readonlyunitstringdecimalstring: {
+                    type: "object",
+                    properties: {
+                        unit: {
+                            type: "string"
+                        },
+                        decimal: {
+                            type: "string"
+                        }
+                    },
+                    required: [
+                        "unit",
+                        "decimal"
+                    ],
+                    additionalProperties: false
+                },
+                ReadonlygoalIdstringgoalVersionnumberstatusAnalysisStatusmethodAnalysisMethodundefinedreachedbooleanundefinedatSecnumberundefinedassumptionsreadonlystring: {
+                    type: "object",
+                    properties: {
+                        goalId: {
+                            type: "string"
+                        },
+                        goalVersion: {
+                            type: "number"
+                        },
+                        status: {
+                            $ref: "#/components/schemas/AnalysisStatus"
+                        },
+                        method: {
+                            oneOf: [
+                                {
+                                    "const": "analytic-local"
+                                },
+                                {
+                                    "const": "exact"
+                                },
+                                {
+                                    "const": "fixed-step"
+                                },
+                                {
+                                    "const": "heuristic-fit"
+                                },
+                                {
+                                    "const": "monte-carlo"
+                                }
+                            ]
+                        },
+                        reached: {
+                            type: "boolean"
+                        },
+                        atSec: {
+                            type: "number"
+                        },
+                        assumptions: {
+                            type: "array",
+                            items: {
+                                type: "string"
+                            }
+                        }
+                    },
+                    required: [
+                        "goalId",
+                        "goalVersion",
+                        "status",
+                        "assumptions"
+                    ],
+                    additionalProperties: false
+                },
+                ReadonlymetricsCapabilityKnowledgegoalsCapabilityKnowledgeresetCapabilityKnowledgeflowCapabilityKnowledgeadvanceCapabilityKnowledge: {
+                    type: "object",
+                    properties: {
+                        metrics: {
+                            $ref: "#/components/schemas/CapabilityKnowledge"
+                        },
+                        goals: {
+                            $ref: "#/components/schemas/CapabilityKnowledge"
+                        },
+                        reset: {
+                            $ref: "#/components/schemas/CapabilityKnowledge"
+                        },
+                        flow: {
+                            $ref: "#/components/schemas/CapabilityKnowledge"
+                        },
+                        advance: {
+                            $ref: "#/components/schemas/CapabilityKnowledge"
+                        }
+                    },
+                    required: [
+                        "metrics",
+                        "goals",
+                        "reset",
+                        "flow",
+                        "advance"
+                    ],
+                    additionalProperties: false
+                },
+                CapabilityKnowledge: {
+                    oneOf: [
+                        {
+                            "const": "statically-known"
+                        },
+                        {
+                            "const": "unknown"
+                        },
+                        {
+                            "const": "unsupported"
+                        }
+                    ]
+                }
+            }
+        },
+        schema: {
+            type: "object",
+            properties: {
+                schemaVersion: {
+                    "const": 1
+                },
+                algorithmVersion: {
+                    type: "string"
+                },
+                assumptions: {
+                    type: "array",
+                    items: {
+                        type: "string"
+                    }
+                },
+                warnings: {
+                    type: "array",
+                    items: {
+                        type: "string"
+                    }
+                },
+                observationCoverage: {
+                    $ref: "#/components/schemas/ArtifactCoverage"
+                },
+                horizon: {
+                    $ref: "#/components/schemas/Readonlysecnumberkindbudgetdurationunknownuntil"
+                },
+                sampleCount: {
+                    type: "number"
+                },
+                effectiveRunHash: {
+                    type: "string"
+                },
+                metrics: {
+                    type: "array",
+                    items: {
+                        $ref: "#/components/schemas/ReadonlymetricIdstringmetricVersionnumbermeaningstringmetricKindMetricKindtimeAxisMetricTimeAxisdomainMetricDomainreadingestimated---1more---unavailable---5more---reasonstringundefined"
+                    }
+                },
+                goals: {
+                    type: "array",
+                    items: {
+                        $ref: "#/components/schemas/ReadonlygoalIdstringgoalVersionnumberstatusAnalysisStatusmethodAnalysisMethodundefinedreachedbooleanundefinedatSecnumberundefinedassumptionsreadonlystring"
+                    }
+                },
+                capabilities: {
+                    $ref: "#/components/schemas/ReadonlymetricsCapabilityKnowledgegoalsCapabilityKnowledgeresetCapabilityKnowledgeflowCapabilityKnowledgeadvanceCapabilityKnowledge"
+                }
+            },
+            required: [
+                "schemaVersion",
+                "algorithmVersion",
+                "assumptions",
+                "warnings",
+                "observationCoverage",
+                "metrics",
+                "goals",
+                "capabilities"
+            ],
+            additionalProperties: false
+        },
+        version: "3.1"
+    };
+}
+let analysisArtifactJsonSchemaUnit;
+export function analysisArtifactJsonSchema() {
+    analysisArtifactJsonSchemaUnit ??= buildAnalysisArtifactJsonSchema();
+    return analysisArtifactJsonSchemaUnit;
+}
+function sha256Text(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+export function analysisCanonicalJson(value) {
+    return renderCanonical(value, new Set());
+}
+function renderCanonical(value, seen) {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value) ?? "null";
+    if (seen.has(value))
+        return '"[circular]"';
+    seen.add(value);
+    try {
+        if (Array.isArray(value)) {
+            const entries = Array.from({ length: value.length }, (_, index) => renderCanonical(value[index] ?? null, seen));
+            return `[${entries.join(",")}]`;
+        }
+        const entries = Object.entries(value).filter(([, entry]) => entry !== undefined);
+        entries.sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0));
+        return `{${entries
+            .map(([key, entry]) => `${JSON.stringify(key)}:${renderCanonical(entry, seen)}`)
+            .join(",")}}`;
+    }
+    finally {
+        seen.delete(value);
+    }
+}
+export function analysisSchemaHash() {
+    return sha256Text(analysisCanonicalJson(analysisArtifactJsonSchema()));
+}
+export function artifactProvenance(artifact, schemaHash) {
+    // Goal-level assumptions, such as a wallet fallback for net worth, are part of the analytical basis.
+    const goalAssumptions = (artifact.goals ?? [])
+        .filter((goal) => goal.assumptions.length > 0)
+        .map((goal) => ({ goalId: goal.goalId, goalVersion: goal.goalVersion, assumptions: goal.assumptions }));
+    const assumptionHash = sha256Text(analysisCanonicalJson(goalAssumptions.length > 0 ? { assumptions: artifact.assumptions, goalAssumptions } : artifact.assumptions));
+    const provenance = sha256Text(analysisCanonicalJson({
+        algorithmVersion: artifact.algorithmVersion,
+        assumptionHash,
+        schemaHash,
+    }));
+    return {
+        schemaHash,
+        algorithmVersion: artifact.algorithmVersion,
+        assumptionHash,
+        provenance,
+    };
+}
+export function classifyAmount(engine, amount, unit) {
+    if (!engine.isFinite(amount)) {
+        return {
+            status: "invalid",
+            sign: "nonfinite",
+            reason: nonfiniteKind(engine.toString(amount)),
+        };
+    }
+    const decimal = engine.toString(amount);
+    const cmp = engine.cmp(amount, engine.zero());
+    if (cmp < 0)
+        return { status: "ok", sign: "negative", amount: { unit, decimal } };
+    if (cmp === 0)
+        return { status: "ok", sign: "zero", amount: { unit, decimal } };
+    return { status: "ok", sign: "positive", amount: { unit, decimal } };
+}
+function nonfiniteKind(text) {
+    const lower = text.toLowerCase();
+    if (lower.includes("nan"))
+        return "nan";
+    if (text.startsWith("-"))
+        return "negative-infinity";
+    return "infinity";
+}
+export function classifyFinite(value) {
+    if (!Number.isFinite(value)) {
+        return {
+            status: "invalid",
+            sign: "nonfinite",
+            reason: nonfiniteKind(String(value)),
+        };
+    }
+    if (value < 0)
+        return { status: "ok", sign: "negative", value };
+    if (value === 0)
+        return { status: "ok", sign: "zero", value };
+    return { status: "ok", sign: "positive", value };
+}
+const DECIMAL_SPELLING = /^([+-])?(\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i;
+/** The sign a finite decimal spelling denotes, without an engine. An unparsed spelling is null. */
+function decimalSign(decimal) {
+    const match = DECIMAL_SPELLING.exec(decimal.trim());
+    if (!match)
+        return null;
+    if (!/[1-9]/.test(match[2] ?? ""))
+        return "zero";
+    return match[1] === "-" ? "negative" : "positive";
+}
+/** Nonfinite spellings an engine can print. A nonfinite amount is invalid and omits `amount`. */
+const NONFINITE_DECIMAL = /^[+-]?(nan|inf|infinity)$/i;
+/**
+ * Cross-field rules the generator does not claim.
+ * Unavailable readings must not carry a numeric stand-in.
+ */
+export function validateAnalysisSemantics(artifact) {
+    const issues = [];
+    artifact.metrics.forEach((reading, index) => {
+        const path = `metrics.${index}`;
+        const unavailable = reading.reading === "unavailable" || reading.status !== "ok";
+        if (reading.status !== "ok" && reading.reading !== "unavailable") {
+            issues.push({ path, message: "non-ok reading is not labeled unavailable" });
+        }
+        if (unavailable && (reading.amount !== undefined || reading.value !== undefined)) {
+            issues.push({ path, message: "unavailable reading carries a value" });
+        }
+        if (reading.status === "ok" && reading.domain === "amount" && reading.amount === undefined) {
+            issues.push({ path, message: "ok amount reading has no decimal" });
+        }
+        if (reading.status === "ok" && reading.domain !== "amount" && reading.value === undefined) {
+            issues.push({ path, message: "ok numeric reading has no value" });
+        }
+        if (reading.value !== undefined && !Number.isFinite(reading.value)) {
+            issues.push({ path, message: "numeric value is nonfinite" });
+        }
+        if (reading.amount !== undefined && NONFINITE_DECIMAL.test(reading.amount.decimal.trim())) {
+            issues.push({ path, message: "amount decimal is nonfinite" });
+        }
+        if (reading.value !== undefined && Number.isFinite(reading.value) && reading.sign !== undefined) {
+            const sign = reading.value < 0 ? "negative" : reading.value === 0 ? "zero" : "positive";
+            if (reading.sign !== sign)
+                issues.push({ path, message: "numeric sign contradicts its value" });
+        }
+        // One representation per domain: an amount reading has no number, and a numeric reading has no amount.
+        if (reading.domain === "amount" && reading.value !== undefined) {
+            issues.push({ path, message: "amount reading carries a numeric value" });
+        }
+        if (reading.domain !== "amount" && reading.amount !== undefined) {
+            issues.push({ path, message: "numeric reading carries an amount" });
+        }
+        if (reading.amount !== undefined && reading.sign !== undefined) {
+            const expected = decimalSign(reading.amount.decimal);
+            if (expected !== null && reading.sign !== expected) {
+                issues.push({ path, message: "sign does not match the amount decimal" });
+            }
+        }
+        if (!Number.isFinite(reading.metricVersion)) {
+            issues.push({ path, message: "metricVersion is nonfinite" });
+        }
+    });
+    artifact.goals.forEach((goal, index) => {
+        if (goal.status !== "ok" && goal.reached !== undefined) {
+            issues.push({ path: `goals.${index}`, message: "unreached status still carries reached" });
+        }
+        if (goal.status !== "ok" && goal.method !== undefined) {
+            issues.push({ path: `goals.${index}`, message: "non-ok goal carries a method" });
+        }
+        if (!Number.isFinite(goal.goalVersion)) {
+            issues.push({ path: `goals.${index}`, message: "goalVersion is nonfinite" });
+        }
+        if (goal.atSec !== undefined && !Number.isFinite(goal.atSec)) {
+            issues.push({ path: `goals.${index}`, message: "atSec is nonfinite" });
+        }
+    });
+    // JSON writes a nonfinite number as null, which the generated schema rejects.
+    if (artifact.horizon !== undefined && !Number.isFinite(artifact.horizon.sec)) {
+        issues.push({ path: "horizon.sec", message: "horizon.sec is nonfinite" });
+    }
+    if (artifact.sampleCount !== undefined &&
+        (!Number.isInteger(artifact.sampleCount) || artifact.sampleCount < 0)) {
+        issues.push({ path: "sampleCount", message: "sampleCount is not a nonnegative integer" });
+    }
+    return issues;
+}
+export function renderAnalysisMarkdown(artifact) {
+    const lines = [
+        "# Analysis artifact v1",
+        "",
+        `Algorithm: ${artifact.algorithmVersion}`,
+        `Coverage: ${artifact.observationCoverage}`,
+        `Capabilities: metrics ${artifact.capabilities.metrics}, goals ${artifact.capabilities.goals}, reset ${artifact.capabilities.reset}, flow ${artifact.capabilities.flow}, advance ${artifact.capabilities.advance}`,
+    ];
+    if (artifact.effectiveRunHash !== undefined)
+        lines.push(`Run: ${artifact.effectiveRunHash}`);
+    if (artifact.sampleCount !== undefined)
+        lines.push(`Samples: ${artifact.sampleCount}`);
+    if (artifact.assumptions.length > 0) {
+        lines.push("", "## Assumptions", ...artifact.assumptions.map((item) => `- ${item}`));
+    }
+    if (artifact.warnings.length > 0) {
+        lines.push("", "## Warnings", ...artifact.warnings.map((item) => `- ${item}`));
+    }
+    lines.push("", "## Metrics");
+    if (artifact.metrics.length === 0)
+        lines.push("None.");
+    for (const metric of artifact.metrics) {
+        const wire = metric.amount
+            ? `${metric.amount.decimal} ${metric.amount.unit}`
+            : metric.value !== undefined
+                ? String(metric.value)
+                : "absent";
+        lines.push(`- ${metric.metricId}@${metric.metricVersion} ${metric.reading} ${metric.status} ${wire}`);
+    }
+    lines.push("", "## Goals");
+    if (artifact.goals.length === 0)
+        lines.push("None.");
+    for (const goal of artifact.goals) {
+        const reached = goal.reached === undefined ? "absent" : String(goal.reached);
+        // A reach time belongs to a goal that was reached. Other statuses do not print one.
+        const at = goal.atSec === undefined || goal.status !== "ok" || goal.reached !== true ? "" : ` at ${goal.atSec}s`;
+        lines.push(`- ${goal.goalId}@${goal.goalVersion} ${goal.status} reached ${reached}${at}`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+export function analysisArtifactJson(artifact) {
+    return `${analysisCanonicalJson(artifact)}\n`;
+}
+export function unavailableReading(args) {
+    return {
+        metricId: args.metricId,
+        metricVersion: args.metricVersion,
+        meaning: args.meaning,
+        metricKind: args.metricKind,
+        timeAxis: args.timeAxis,
+        domain: args.domain,
+        reading: "unavailable",
+        status: args.status,
+        ...(args.reason !== undefined ? { reason: args.reason } : {}),
+    };
+}
+//# sourceMappingURL=contracts.js.map