@idlekit/core 0.2.1 → 0.3.0

package/dist/sim/analysis/distribution.js

@@ -0,0 +1,1246 @@
+import * as _validateReport_1 from "typia/lib/internal/_validateReport";
+import * as _createStandardSchema_1 from "typia/lib/internal/_createStandardSchema";
+import typia, {} from "typia";
+import { mulberry32, logicalDrawId, logicalDrawSeed } from "../random";
+/**
+ * Distribution summary v1.
+ * Completion-conditioned quantiles stay labeled. They are not the population quantile.
+ * `mean-of-log10` is not an arithmetic mean.
+ */
+const DISTRIBUTION_ALGORITHM_VERSION = "distribution-v1";
+const DISTRIBUTION_SCHEMA_ID = "https://idlekit.dev/schemas/distribution.v1.schema.json";
+const QUANTILE_METHOD = "inclusive-floor-index";
+const QUANTILE_METHOD_VERSION = 1;
+/**
+ * @evidence docs/requirements/active/simulation-distribution.md#req-pr13-sample-accounting Each sample is observed, censored, failed, or unsupported. A censored tail is not an observed p95.
+ * @evidenceReview docs/requirements/active/simulation-distribution.md#req-pr13-sample-accounting #6e4e90e Re-read the section: 90 of 100 complete, the population p95 stays null, and an all-censored run is not mean 0.
+ */
+export const distributionSampleAccounting = "observed-censored-failed-unsupported";
+/**
+ * @evidence docs/requirements/active/simulation-distribution.md#req-pr13-quantile-convention The default quantile is inclusive floor of (n-1)*q. Keys are canonical, not rounded percents.
+ * @evidenceReview docs/requirements/active/simulation-distribution.md#req-pr13-quantile-convention #2413847 Re-read the section: the five-point array hits 1, 3, 4, and 5, an empty sample stays null, and q0.946 does not share a key with q0.954.
+ */
+export const distributionQuantileConvention = "inclusive-floor-index-v1";
+/**
+ * @evidence docs/requirements/active/simulation-distribution.md#req-pr13-logical-draws Logical draw id and seed ignore worker count and call order. Common random numbers need the execution stream.
+ * @evidenceReview docs/requirements/active/simulation-distribution.md#req-pr13-logical-draws #6e3688a Re-read the section: reversed calls keep draw 2, and an unsupported stream refuses pairing.
+ */
+export const distributionLogicalDraws = "logical-index-not-worker-slot";
+/**
+ * @evidence docs/requirements/active/simulation-distribution.md#req-pr13-empirical-drop A seeded 1% Bernoulli draw is checked inside a fixed tolerance. A deterministic model may report zero variance.
+ * @evidenceReview docs/requirements/active/simulation-distribution.md#req-pr13-empirical-drop #466e88b Re-read the section: the rate is not required to equal 0.01 exactly, and identical draws stay zero variance.
+ */
+export const distributionEmpiricalDrop = "seeded-bernoulli-tolerance";
+/**
+ * @evidence docs/requirements/active/simulation-distribution.md#req-pr13-mean-identity Arithmetic mean, mean of log10, and log10 of the mean are different slots. A missing first visible change is censored.
+ * @evidenceReview docs/requirements/active/simulation-distribution.md#req-pr13-mean-identity #5fa6bcc Re-read the section: mean of log10 of 10 and 1000 is 2, and an absent first visible change does not become active time or 0.
+ */
+export const distributionMeanIdentity = "arithmetic-mean-log-and-log-mean";
+export function distributionSchemaId() {
+    return DISTRIBUTION_SCHEMA_ID;
+}
+export function distributionAlgorithmVersion() {
+    return DISTRIBUTION_ALGORITHM_VERSION;
+}
+export class DistributionRejected extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "DistributionRejected";
+    }
+}
+/*
+ * 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 validateDistributionArtifactValidator;
+/**
+ * @evidence docs/requirements/active/simulation-distribution.md#req-pr13-quantile-convention The generated validator accepts this artifact.
+ * @evidenceReview docs/requirements/active/simulation-distribution.md#req-pr13-quantile-convention #2413847 Re-read the section: the wire object is distribution v1 and the method is inclusive-floor-index.
+ */
+export const validateDistributionArtifact = (input) => (validateDistributionArtifactValidator ??= (() => {
+    const _ip0 = input => "string" === typeof input["key"];
+    const _ip1 = input => "number" === typeof input["q"];
+    const _ip2 = input => null === input["value"] || "string" === typeof input["value"];
+    const _ve0 = "Readonly<{ schemaVersion: 1; algorithmVersion: \"distribution-v1\"; method: Readonly<{ id: \"inclusive-floor-index\"; version: 1; }>; status: \"ok\" | \"unavailable\" | \"unsupported\"; horizonSec: number | null; ... 7 more ...; warnings: readonly string[]; }>";
+    const _ve1 = "Readonly<{ draws: number; observed: number; rightCensored: number; failed: number; unsupported: number; completionRate: number | null; }>";
+    const _ve2 = "Readonly<{ key: string; q: number; conditioning: \"all-eligible-draws\"; estimator: \"common-horizon-order-statistic\" | \"not-estimated\"; status: \"observed\" | \"outside-observed-range\" | \"unavailable\"; value: string | null; }>";
+    const _ve3 = "ReadonlyArray<Readonly<{ key: string; q: number; conditioning: \"completed-only\"; status: \"observed\" | \"unavailable\"; value: string | null; }>>";
+    const _ve4 = "Readonly<{ arithmetic: Readonly<{ label: \"arithmetic-mean\" | \"log10-of-arithmetic-mean\" | \"mean-of-log10\"; status: \"observed\" | \"unavailable\" | \"unsupported\"; value: string | null; }>; meanLog10: Readonly<...>; log10OfMean: Readonly<...>; }>";
+    const _vp0 = (input, _path, _exceptionable = true) => "string" === typeof input["key"] || _report(_exceptionable, {
+        path: _path + ".key",
+        expected: "string",
+        value: input["key"]
+    });
+    const _vp1 = (input, _path, _exceptionable = true) => "number" === typeof input["q"] || _report(_exceptionable, {
+        path: _path + ".q",
+        expected: "number",
+        value: input["q"]
+    });
+    const _vp2 = (input, _path, _exceptionable = true) => null === input["value"] || "string" === typeof input["value"] || _report(_exceptionable, {
+        path: _path + ".value",
+        expected: "(null | string)",
+        value: input["value"]
+    });
+    const _ve5 = "Readonly<{ label: \"arithmetic-mean\" | \"log10-of-arithmetic-mean\" | \"mean-of-log10\"; status: \"observed\" | \"unavailable\" | \"unsupported\"; value: string | null; }>";
+    const _io0 = input => 1 === input.schemaVersion && "distribution-v1" === input.algorithmVersion && ("object" === typeof input.method && null !== input.method && _io1(input.method)) && ("ok" === input.status || "unavailable" === input.status || "unsupported" === input.status) && (null === input.horizonSec || "number" === typeof input.horizonSec) && ("object" === typeof input.accounting && null !== input.accounting && _io2(input.accounting)) && (Array.isArray(input.seeds) && input.seeds.every(elem => "object" === typeof elem && null !== elem && _io3(elem))) && ("object" === typeof input.uncertainty && null !== input.uncertainty && _io4(input.uncertainty)) && ("object" === typeof input.population && null !== input.population && _io5(input.population)) && (Array.isArray(input.conditional) && input.conditional.every(elem => "object" === typeof elem && null !== elem && _io6(elem))) && ("object" === typeof input.means && null !== input.means && _io7(input.means)) && ("object" === typeof input.reduction && null !== input.reduction && _io9(input.reduction)) && (Array.isArray(input.warnings) && input.warnings.every(elem => "string" === typeof elem));
+    const _io1 = input => "inclusive-floor-index" === input.id && 1 === input.version;
+    const _io2 = input => "number" === typeof input.draws && "number" === typeof input.observed && "number" === typeof input.rightCensored && "number" === typeof input.failed && "number" === typeof input.unsupported && (null === input.completionRate || "number" === typeof input.completionRate);
+    const _io3 = input => "string" === typeof input.drawId && "number" === typeof input.drawIndex && "number" === typeof input.seed;
+    const _io4 = input => ("mixed" === input.source || "model-strategy-session" === input.source || "monetization" === input.source) && "boolean" === typeof input.zeroVariance && (null === input.variance || "number" === typeof input.variance);
+    const _io5 = input => _ip0(input) && _ip1(input) && "all-eligible-draws" === input.conditioning && ("common-horizon-order-statistic" === input.estimator || "not-estimated" === input.estimator) && ("observed" === input.status || "outside-observed-range" === input.status || "unavailable" === input.status) && _ip2(input);
+    const _io6 = input => _ip0(input) && _ip1(input) && "completed-only" === input.conditioning && ("observed" === input.status || "unavailable" === input.status) && _ip2(input);
+    const _io7 = input => "object" === typeof input.arithmetic && null !== input.arithmetic && _io8(input.arithmetic) && ("object" === typeof input.meanLog10 && null !== input.meanLog10 && _io8(input.meanLog10)) && ("object" === typeof input.log10OfMean && null !== input.log10OfMean && _io8(input.log10OfMean));
+    const _io8 = input => ("arithmetic-mean" === input.label || "log10-of-arithmetic-mean" === input.label || "mean-of-log10" === input.label) && ("observed" === input.status || "unavailable" === input.status || "unsupported" === input.status) && _ip2(input);
+    const _io9 = input => "logical-draw-index" === input.order && true === input.workerCountIndependent;
+    const _vo0 = (input, _path, _exceptionable = true) => [1 === input.schemaVersion || _report(_exceptionable, {
+            path: _path + ".schemaVersion",
+            expected: "1",
+            value: input.schemaVersion
+        }), "distribution-v1" === input.algorithmVersion || _report(_exceptionable, {
+            path: _path + ".algorithmVersion",
+            expected: "\"distribution-v1\"",
+            value: input.algorithmVersion
+        }), ("object" === typeof input.method && null !== input.method || _report(_exceptionable, {
+            path: _path + ".method",
+            expected: "Readonly<{ id: \"inclusive-floor-index\"; version: 1; }>",
+            value: input.method
+        })) && _vo1(input.method, _path + ".method", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".method",
+            expected: "Readonly<{ id: \"inclusive-floor-index\"; version: 1; }>",
+            value: input.method
+        }), "ok" === input.status || "unavailable" === input.status || "unsupported" === input.status || _report(_exceptionable, {
+            path: _path + ".status",
+            expected: "(\"ok\" | \"unavailable\" | \"unsupported\")",
+            value: input.status
+        }), null === input.horizonSec || "number" === typeof input.horizonSec || _report(_exceptionable, {
+            path: _path + ".horizonSec",
+            expected: "(null | number)",
+            value: input.horizonSec
+        }), ("object" === typeof input.accounting && null !== input.accounting || _report(_exceptionable, {
+            path: _path + ".accounting",
+            expected: _ve1,
+            value: input.accounting
+        })) && _vo2(input.accounting, _path + ".accounting", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".accounting",
+            expected: _ve1,
+            value: input.accounting
+        }), (Array.isArray(input.seeds) || _report(_exceptionable, {
+            path: _path + ".seeds",
+            expected: "ReadonlyArray<Readonly<{ drawId: string; drawIndex: number; seed: number; }>>",
+            value: input.seeds
+        })) && input.seeds.map((elem, _index4) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+            path: _path + ".seeds[" + _index4 + "]",
+            expected: "Readonly<{ drawId: string; drawIndex: number; seed: number; }>",
+            value: elem
+        })) && _vo3(elem, _path + ".seeds[" + _index4 + "]", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".seeds[" + _index4 + "]",
+            expected: "Readonly<{ drawId: string; drawIndex: number; seed: number; }>",
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + ".seeds",
+            expected: "ReadonlyArray<Readonly<{ drawId: string; drawIndex: number; seed: number; }>>",
+            value: input.seeds
+        }), ("object" === typeof input.uncertainty && null !== input.uncertainty || _report(_exceptionable, {
+            path: _path + ".uncertainty",
+            expected: "Readonly<{ source: DistributionUncertaintySource; zeroVariance: boolean; variance: number | null; }>",
+            value: input.uncertainty
+        })) && _vo4(input.uncertainty, _path + ".uncertainty", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".uncertainty",
+            expected: "Readonly<{ source: DistributionUncertaintySource; zeroVariance: boolean; variance: number | null; }>",
+            value: input.uncertainty
+        }), ("object" === typeof input.population && null !== input.population || _report(_exceptionable, {
+            path: _path + ".population",
+            expected: _ve2,
+            value: input.population
+        })) && _vo5(input.population, _path + ".population", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".population",
+            expected: _ve2,
+            value: input.population
+        }), (Array.isArray(input.conditional) || _report(_exceptionable, {
+            path: _path + ".conditional",
+            expected: _ve3,
+            value: input.conditional
+        })) && input.conditional.map((elem, _index5) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+            path: _path + ".conditional[" + _index5 + "]",
+            expected: "Readonly<{ key: string; q: number; conditioning: \"completed-only\"; status: \"observed\" | \"unavailable\"; value: string | null; }>",
+            value: elem
+        })) && _vo6(elem, _path + ".conditional[" + _index5 + "]", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".conditional[" + _index5 + "]",
+            expected: "Readonly<{ key: string; q: number; conditioning: \"completed-only\"; status: \"observed\" | \"unavailable\"; value: string | null; }>",
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + ".conditional",
+            expected: _ve3,
+            value: input.conditional
+        }), ("object" === typeof input.means && null !== input.means || _report(_exceptionable, {
+            path: _path + ".means",
+            expected: _ve4,
+            value: input.means
+        })) && _vo7(input.means, _path + ".means", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".means",
+            expected: _ve4,
+            value: input.means
+        }), ("object" === typeof input.reduction && null !== input.reduction || _report(_exceptionable, {
+            path: _path + ".reduction",
+            expected: "Readonly<{ order: \"logical-draw-index\"; workerCountIndependent: true; }>",
+            value: input.reduction
+        })) && _vo9(input.reduction, _path + ".reduction", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".reduction",
+            expected: "Readonly<{ order: \"logical-draw-index\"; workerCountIndependent: true; }>",
+            value: input.reduction
+        }), (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
+        })].every(flag => flag);
+    const _vo1 = (input, _path, _exceptionable = true) => ["inclusive-floor-index" === input.id || _report(_exceptionable, {
+            path: _path + ".id",
+            expected: "\"inclusive-floor-index\"",
+            value: input.id
+        }), 1 === input.version || _report(_exceptionable, {
+            path: _path + ".version",
+            expected: "1",
+            value: input.version
+        })].every(flag => flag);
+    const _vo2 = (input, _path, _exceptionable = true) => ["number" === typeof input.draws || _report(_exceptionable, {
+            path: _path + ".draws",
+            expected: "number",
+            value: input.draws
+        }), "number" === typeof input.observed || _report(_exceptionable, {
+            path: _path + ".observed",
+            expected: "number",
+            value: input.observed
+        }), "number" === typeof input.rightCensored || _report(_exceptionable, {
+            path: _path + ".rightCensored",
+            expected: "number",
+            value: input.rightCensored
+        }), "number" === typeof input.failed || _report(_exceptionable, {
+            path: _path + ".failed",
+            expected: "number",
+            value: input.failed
+        }), "number" === typeof input.unsupported || _report(_exceptionable, {
+            path: _path + ".unsupported",
+            expected: "number",
+            value: input.unsupported
+        }), null === input.completionRate || "number" === typeof input.completionRate || _report(_exceptionable, {
+            path: _path + ".completionRate",
+            expected: "(null | number)",
+            value: input.completionRate
+        })].every(flag => flag);
+    const _vo3 = (input, _path, _exceptionable = true) => ["string" === typeof input.drawId || _report(_exceptionable, {
+            path: _path + ".drawId",
+            expected: "string",
+            value: input.drawId
+        }), "number" === typeof input.drawIndex || _report(_exceptionable, {
+            path: _path + ".drawIndex",
+            expected: "number",
+            value: input.drawIndex
+        }), "number" === typeof input.seed || _report(_exceptionable, {
+            path: _path + ".seed",
+            expected: "number",
+            value: input.seed
+        })].every(flag => flag);
+    const _vo4 = (input, _path, _exceptionable = true) => ["mixed" === input.source || "model-strategy-session" === input.source || "monetization" === input.source || _report(_exceptionable, {
+            path: _path + ".source",
+            expected: "(\"mixed\" | \"model-strategy-session\" | \"monetization\")",
+            value: input.source
+        }), "boolean" === typeof input.zeroVariance || _report(_exceptionable, {
+            path: _path + ".zeroVariance",
+            expected: "boolean",
+            value: input.zeroVariance
+        }), null === input.variance || "number" === typeof input.variance || _report(_exceptionable, {
+            path: _path + ".variance",
+            expected: "(null | number)",
+            value: input.variance
+        })].every(flag => flag);
+    const _vo5 = (input, _path, _exceptionable = true) => [_vp0(input, _path, true && _exceptionable), _vp1(input, _path, true && _exceptionable), "all-eligible-draws" === input.conditioning || _report(_exceptionable, {
+            path: _path + ".conditioning",
+            expected: "\"all-eligible-draws\"",
+            value: input.conditioning
+        }), "common-horizon-order-statistic" === input.estimator || "not-estimated" === input.estimator || _report(_exceptionable, {
+            path: _path + ".estimator",
+            expected: "(\"common-horizon-order-statistic\" | \"not-estimated\")",
+            value: input.estimator
+        }), "observed" === input.status || "outside-observed-range" === input.status || "unavailable" === input.status || _report(_exceptionable, {
+            path: _path + ".status",
+            expected: "(\"observed\" | \"outside-observed-range\" | \"unavailable\")",
+            value: input.status
+        }), _vp2(input, _path, true && _exceptionable)].every(flag => flag);
+    const _vo6 = (input, _path, _exceptionable = true) => [_vp0(input, _path, true && _exceptionable), _vp1(input, _path, true && _exceptionable), "completed-only" === input.conditioning || _report(_exceptionable, {
+            path: _path + ".conditioning",
+            expected: "\"completed-only\"",
+            value: input.conditioning
+        }), "observed" === input.status || "unavailable" === input.status || _report(_exceptionable, {
+            path: _path + ".status",
+            expected: "(\"observed\" | \"unavailable\")",
+            value: input.status
+        }), _vp2(input, _path, true && _exceptionable)].every(flag => flag);
+    const _vo7 = (input, _path, _exceptionable = true) => [("object" === typeof input.arithmetic && null !== input.arithmetic || _report(_exceptionable, {
+            path: _path + ".arithmetic",
+            expected: _ve5,
+            value: input.arithmetic
+        })) && _vo8(input.arithmetic, _path + ".arithmetic", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".arithmetic",
+            expected: _ve5,
+            value: input.arithmetic
+        }), ("object" === typeof input.meanLog10 && null !== input.meanLog10 || _report(_exceptionable, {
+            path: _path + ".meanLog10",
+            expected: _ve5,
+            value: input.meanLog10
+        })) && _vo8(input.meanLog10, _path + ".meanLog10", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".meanLog10",
+            expected: _ve5,
+            value: input.meanLog10
+        }), ("object" === typeof input.log10OfMean && null !== input.log10OfMean || _report(_exceptionable, {
+            path: _path + ".log10OfMean",
+            expected: _ve5,
+            value: input.log10OfMean
+        })) && _vo8(input.log10OfMean, _path + ".log10OfMean", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".log10OfMean",
+            expected: _ve5,
+            value: input.log10OfMean
+        })].every(flag => flag);
+    const _vo8 = (input, _path, _exceptionable = true) => ["arithmetic-mean" === input.label || "log10-of-arithmetic-mean" === input.label || "mean-of-log10" === input.label || _report(_exceptionable, {
+            path: _path + ".label",
+            expected: "(\"arithmetic-mean\" | \"log10-of-arithmetic-mean\" | \"mean-of-log10\")",
+            value: input.label
+        }), "observed" === input.status || "unavailable" === input.status || "unsupported" === input.status || _report(_exceptionable, {
+            path: _path + ".status",
+            expected: "(\"observed\" | \"unavailable\" | \"unsupported\")",
+            value: input.status
+        }), _vp2(input, _path, true && _exceptionable)].every(flag => flag);
+    const _vo9 = (input, _path, _exceptionable = true) => ["logical-draw-index" === input.order || _report(_exceptionable, {
+            path: _path + ".order",
+            expected: "\"logical-draw-index\"",
+            value: input.order
+        }), true === input.workerCountIndependent || _report(_exceptionable, {
+            path: _path + ".workerCountIndependent",
+            expected: "true",
+            value: input.workerCountIndependent
+        })].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);
+function buildDistributionJsonSchema() {
+    return {
+        components: {
+            schemas: {
+                "ReadonlyschemaVersion1algorithmVersiondistribution-v1methodReadonlyidinclusive-floor-indexversion1statusokunavailableunsupportedhorizonSecnumbernull---7more---warningsreadonlystring": {
+                    type: "object",
+                    properties: {
+                        schemaVersion: {
+                            "const": 1
+                        },
+                        algorithmVersion: {
+                            "const": "distribution-v1"
+                        },
+                        method: {
+                            $ref: "#/components/schemas/Readonlyidinclusive-floor-indexversion1"
+                        },
+                        status: {
+                            oneOf: [
+                                {
+                                    "const": "ok"
+                                },
+                                {
+                                    "const": "unavailable"
+                                },
+                                {
+                                    "const": "unsupported"
+                                }
+                            ]
+                        },
+                        horizonSec: {
+                            oneOf: [
+                                {
+                                    type: "null"
+                                },
+                                {
+                                    type: "number"
+                                }
+                            ]
+                        },
+                        accounting: {
+                            $ref: "#/components/schemas/ReadonlydrawsnumberobservednumberrightCensorednumberfailednumberunsupportednumbercompletionRatenumbernull"
+                        },
+                        seeds: {
+                            type: "array",
+                            items: {
+                                $ref: "#/components/schemas/ReadonlydrawIdstringdrawIndexnumberseednumber"
+                            }
+                        },
+                        uncertainty: {
+                            $ref: "#/components/schemas/ReadonlysourceDistributionUncertaintySourcezeroVariancebooleanvariancenumbernull"
+                        },
+                        population: {
+                            $ref: "#/components/schemas/Readonlykeystringqnumberconditioningall-eligible-drawsestimatorcommon-horizon-order-statisticnot-estimatedstatusobservedoutside-observed-rangeunavailablevaluestringnull"
+                        },
+                        conditional: {
+                            type: "array",
+                            items: {
+                                $ref: "#/components/schemas/Readonlykeystringqnumberconditioningcompleted-onlystatusobservedunavailablevaluestringnull"
+                            }
+                        },
+                        means: {
+                            $ref: "#/components/schemas/ReadonlyarithmeticReadonlylabelarithmetic-meanlog10-of-arithmetic-meanmean-of-log10statusobservedunavailableunsupportedvaluestringnullmeanLog10Readonly---log10OfMeanReadonly---"
+                        },
+                        reduction: {
+                            $ref: "#/components/schemas/Readonlyorderlogical-draw-indexworkerCountIndependenttrue"
+                        },
+                        warnings: {
+                            type: "array",
+                            items: {
+                                type: "string"
+                            }
+                        }
+                    },
+                    required: [
+                        "schemaVersion",
+                        "algorithmVersion",
+                        "method",
+                        "status",
+                        "horizonSec",
+                        "accounting",
+                        "seeds",
+                        "uncertainty",
+                        "population",
+                        "conditional",
+                        "means",
+                        "reduction",
+                        "warnings"
+                    ],
+                    additionalProperties: false
+                },
+                "Readonlyidinclusive-floor-indexversion1": {
+                    type: "object",
+                    properties: {
+                        id: {
+                            "const": "inclusive-floor-index"
+                        },
+                        version: {
+                            "const": 1
+                        }
+                    },
+                    required: [
+                        "id",
+                        "version"
+                    ],
+                    additionalProperties: false
+                },
+                ReadonlydrawsnumberobservednumberrightCensorednumberfailednumberunsupportednumbercompletionRatenumbernull: {
+                    type: "object",
+                    properties: {
+                        draws: {
+                            type: "number"
+                        },
+                        observed: {
+                            type: "number"
+                        },
+                        rightCensored: {
+                            type: "number"
+                        },
+                        failed: {
+                            type: "number"
+                        },
+                        unsupported: {
+                            type: "number"
+                        },
+                        completionRate: {
+                            oneOf: [
+                                {
+                                    type: "null"
+                                },
+                                {
+                                    type: "number"
+                                }
+                            ]
+                        }
+                    },
+                    required: [
+                        "draws",
+                        "observed",
+                        "rightCensored",
+                        "failed",
+                        "unsupported",
+                        "completionRate"
+                    ],
+                    additionalProperties: false
+                },
+                ReadonlydrawIdstringdrawIndexnumberseednumber: {
+                    type: "object",
+                    properties: {
+                        drawId: {
+                            type: "string"
+                        },
+                        drawIndex: {
+                            type: "number"
+                        },
+                        seed: {
+                            type: "number"
+                        }
+                    },
+                    required: [
+                        "drawId",
+                        "drawIndex",
+                        "seed"
+                    ],
+                    additionalProperties: false
+                },
+                ReadonlysourceDistributionUncertaintySourcezeroVariancebooleanvariancenumbernull: {
+                    type: "object",
+                    properties: {
+                        source: {
+                            $ref: "#/components/schemas/DistributionUncertaintySource"
+                        },
+                        zeroVariance: {
+                            type: "boolean"
+                        },
+                        variance: {
+                            oneOf: [
+                                {
+                                    type: "null"
+                                },
+                                {
+                                    type: "number"
+                                }
+                            ]
+                        }
+                    },
+                    required: [
+                        "source",
+                        "zeroVariance",
+                        "variance"
+                    ],
+                    additionalProperties: false
+                },
+                DistributionUncertaintySource: {
+                    oneOf: [
+                        {
+                            "const": "mixed"
+                        },
+                        {
+                            "const": "model-strategy-session"
+                        },
+                        {
+                            "const": "monetization"
+                        }
+                    ]
+                },
+                "Readonlykeystringqnumberconditioningall-eligible-drawsestimatorcommon-horizon-order-statisticnot-estimatedstatusobservedoutside-observed-rangeunavailablevaluestringnull": {
+                    type: "object",
+                    properties: {
+                        key: {
+                            type: "string"
+                        },
+                        q: {
+                            type: "number"
+                        },
+                        conditioning: {
+                            "const": "all-eligible-draws"
+                        },
+                        estimator: {
+                            oneOf: [
+                                {
+                                    "const": "common-horizon-order-statistic"
+                                },
+                                {
+                                    "const": "not-estimated"
+                                }
+                            ]
+                        },
+                        status: {
+                            oneOf: [
+                                {
+                                    "const": "observed"
+                                },
+                                {
+                                    "const": "outside-observed-range"
+                                },
+                                {
+                                    "const": "unavailable"
+                                }
+                            ]
+                        },
+                        value: {
+                            oneOf: [
+                                {
+                                    type: "null"
+                                },
+                                {
+                                    type: "string"
+                                }
+                            ]
+                        }
+                    },
+                    required: [
+                        "key",
+                        "q",
+                        "conditioning",
+                        "estimator",
+                        "status",
+                        "value"
+                    ],
+                    additionalProperties: false
+                },
+                "Readonlykeystringqnumberconditioningcompleted-onlystatusobservedunavailablevaluestringnull": {
+                    type: "object",
+                    properties: {
+                        key: {
+                            type: "string"
+                        },
+                        q: {
+                            type: "number"
+                        },
+                        conditioning: {
+                            "const": "completed-only"
+                        },
+                        status: {
+                            oneOf: [
+                                {
+                                    "const": "observed"
+                                },
+                                {
+                                    "const": "unavailable"
+                                }
+                            ]
+                        },
+                        value: {
+                            oneOf: [
+                                {
+                                    type: "null"
+                                },
+                                {
+                                    type: "string"
+                                }
+                            ]
+                        }
+                    },
+                    required: [
+                        "key",
+                        "q",
+                        "conditioning",
+                        "status",
+                        "value"
+                    ],
+                    additionalProperties: false
+                },
+                "ReadonlyarithmeticReadonlylabelarithmetic-meanlog10-of-arithmetic-meanmean-of-log10statusobservedunavailableunsupportedvaluestringnullmeanLog10Readonly---log10OfMeanReadonly---": {
+                    type: "object",
+                    properties: {
+                        arithmetic: {
+                            $ref: "#/components/schemas/Readonlylabelarithmetic-meanlog10-of-arithmetic-meanmean-of-log10statusobservedunavailableunsupportedvaluestringnull"
+                        },
+                        meanLog10: {
+                            $ref: "#/components/schemas/Readonlylabelarithmetic-meanlog10-of-arithmetic-meanmean-of-log10statusobservedunavailableunsupportedvaluestringnull"
+                        },
+                        log10OfMean: {
+                            $ref: "#/components/schemas/Readonlylabelarithmetic-meanlog10-of-arithmetic-meanmean-of-log10statusobservedunavailableunsupportedvaluestringnull"
+                        }
+                    },
+                    required: [
+                        "arithmetic",
+                        "meanLog10",
+                        "log10OfMean"
+                    ],
+                    additionalProperties: false
+                },
+                "Readonlylabelarithmetic-meanlog10-of-arithmetic-meanmean-of-log10statusobservedunavailableunsupportedvaluestringnull": {
+                    type: "object",
+                    properties: {
+                        label: {
+                            oneOf: [
+                                {
+                                    "const": "arithmetic-mean"
+                                },
+                                {
+                                    "const": "log10-of-arithmetic-mean"
+                                },
+                                {
+                                    "const": "mean-of-log10"
+                                }
+                            ]
+                        },
+                        status: {
+                            oneOf: [
+                                {
+                                    "const": "observed"
+                                },
+                                {
+                                    "const": "unavailable"
+                                },
+                                {
+                                    "const": "unsupported"
+                                }
+                            ]
+                        },
+                        value: {
+                            oneOf: [
+                                {
+                                    type: "null"
+                                },
+                                {
+                                    type: "string"
+                                }
+                            ]
+                        }
+                    },
+                    required: [
+                        "label",
+                        "status",
+                        "value"
+                    ],
+                    additionalProperties: false
+                },
+                "Readonlyorderlogical-draw-indexworkerCountIndependenttrue": {
+                    type: "object",
+                    properties: {
+                        order: {
+                            "const": "logical-draw-index"
+                        },
+                        workerCountIndependent: {
+                            "const": true
+                        }
+                    },
+                    required: [
+                        "order",
+                        "workerCountIndependent"
+                    ],
+                    additionalProperties: false
+                }
+            }
+        },
+        schema: {
+            type: "object",
+            properties: {
+                schemaVersion: {
+                    "const": 1
+                },
+                algorithmVersion: {
+                    "const": "distribution-v1"
+                },
+                method: {
+                    $ref: "#/components/schemas/Readonlyidinclusive-floor-indexversion1"
+                },
+                status: {
+                    oneOf: [
+                        {
+                            "const": "ok"
+                        },
+                        {
+                            "const": "unavailable"
+                        },
+                        {
+                            "const": "unsupported"
+                        }
+                    ]
+                },
+                horizonSec: {
+                    oneOf: [
+                        {
+                            type: "null"
+                        },
+                        {
+                            type: "number"
+                        }
+                    ]
+                },
+                accounting: {
+                    $ref: "#/components/schemas/ReadonlydrawsnumberobservednumberrightCensorednumberfailednumberunsupportednumbercompletionRatenumbernull"
+                },
+                seeds: {
+                    type: "array",
+                    items: {
+                        $ref: "#/components/schemas/ReadonlydrawIdstringdrawIndexnumberseednumber"
+                    }
+                },
+                uncertainty: {
+                    $ref: "#/components/schemas/ReadonlysourceDistributionUncertaintySourcezeroVariancebooleanvariancenumbernull"
+                },
+                population: {
+                    $ref: "#/components/schemas/Readonlykeystringqnumberconditioningall-eligible-drawsestimatorcommon-horizon-order-statisticnot-estimatedstatusobservedoutside-observed-rangeunavailablevaluestringnull"
+                },
+                conditional: {
+                    type: "array",
+                    items: {
+                        $ref: "#/components/schemas/Readonlykeystringqnumberconditioningcompleted-onlystatusobservedunavailablevaluestringnull"
+                    }
+                },
+                means: {
+                    $ref: "#/components/schemas/ReadonlyarithmeticReadonlylabelarithmetic-meanlog10-of-arithmetic-meanmean-of-log10statusobservedunavailableunsupportedvaluestringnullmeanLog10Readonly---log10OfMeanReadonly---"
+                },
+                reduction: {
+                    $ref: "#/components/schemas/Readonlyorderlogical-draw-indexworkerCountIndependenttrue"
+                },
+                warnings: {
+                    type: "array",
+                    items: {
+                        type: "string"
+                    }
+                }
+            },
+            required: [
+                "schemaVersion",
+                "algorithmVersion",
+                "method",
+                "status",
+                "horizonSec",
+                "accounting",
+                "seeds",
+                "uncertainty",
+                "population",
+                "conditional",
+                "means",
+                "reduction",
+                "warnings"
+            ],
+            additionalProperties: false
+        },
+        version: "3.1"
+    };
+}
+let distributionJsonSchemaUnit;
+/**
+ * @evidence docs/requirements/active/simulation-distribution.md#req-pr13-quantile-convention The structural schema is OpenAPI 3.1 from typia.
+ * @evidenceReview docs/requirements/active/simulation-distribution.md#req-pr13-quantile-convention #2413847 Re-read the section: schema version is 3.1.
+ */
+export function distributionJsonSchema() {
+    distributionJsonSchemaUnit ??= buildDistributionJsonSchema();
+    return distributionJsonSchemaUnit;
+}
+const WARNINGS = [
+    "a censored sample is not a zero-second completion",
+    "a failed or unsupported sample is not an observed improvement",
+    "completion-conditioned quantiles are not the population quantile",
+    "mean of log10 is not the arithmetic mean, and log10 of the mean is a third metric",
+    "this estimator is not a survival model for varying censoring times",
+    "logical draw seeds ignore worker count and call order",
+    "zero variance is a valid result when the model consumes no randomness",
+];
+export function canonicalQuantileKey(q) {
+    if (typeof q !== "number" || !Number.isFinite(q) || q < 0 || q > 1) {
+        throw new DistributionRejected("distribution quantile must be a finite number from 0 to 1");
+    }
+    return `q${Object.is(q, -0) ? "0" : String(q)}`;
+}
+/**
+ * Inclusive floor index on the ordered finite values.
+ * Empty input is null, not 0. This is method `inclusive-floor-index` version 1.
+ */
+export function quantileInclusiveFloor(values, q) {
+    canonicalQuantileKey(q);
+    const sorted = values.filter((value) => Number.isFinite(value)).sort((left, right) => left - right);
+    if (sorted.length === 0)
+        return null;
+    const index = Math.max(0, Math.min(sorted.length - 1, Math.floor((sorted.length - 1) * q)));
+    return sorted[index] ?? null;
+}
+export function assertDistributionRun(args) {
+    if (typeof args.draws !== "number" || !Number.isFinite(args.draws) || args.draws < 1) {
+        throw new DistributionRejected("distribution draws must be a finite number >= 1");
+    }
+    const count = Math.floor(args.draws);
+    if (count < 1)
+        throw new DistributionRejected("distribution draws must be a finite number >= 1");
+    if (typeof args.seed !== "number" || !Number.isFinite(args.seed)) {
+        throw new DistributionRejected("distribution seed must be finite");
+    }
+    if (args.budget !== undefined && (typeof args.budget !== "number" || !Number.isFinite(args.budget) || args.budget < count)) {
+        throw new DistributionRejected("distribution budget must be a finite number >= draws");
+    }
+    quantileKeys(args.quantiles);
+    if (args.coupling?.commonRandomNumbers && args.coupling.executionStream !== true) {
+        throw new DistributionRejected("common random numbers require the execution stream");
+    }
+    return count;
+}
+/** One uniform from the logical draw seed. Worker count is not an argument. */
+export function independentBernoulli(seed, drawIndex, probability) {
+    if (typeof probability !== "number" || !Number.isFinite(probability) || probability < 0 || probability > 1) {
+        throw new DistributionRejected("distribution probability must be a finite number from 0 to 1");
+    }
+    return mulberry32(logicalDrawSeed(seed, drawIndex))() < probability;
+}
+/**
+ * A missing first visible change is censored.
+ * It is not replaced with active time or with 0.
+ */
+export function firstVisibleDistributionSample(args) {
+    if (!Number.isInteger(args.drawIndex) || args.drawIndex < 0) {
+        throw new DistributionRejected("distribution drawIndex must be an integer >= 0");
+    }
+    if (typeof args.seed !== "number" || !Number.isFinite(args.seed)) {
+        throw new DistributionRejected("distribution seed must be finite");
+    }
+    if (args.firstVisibleChangeSec === undefined) {
+        return {
+            drawIndex: args.drawIndex,
+            seed: args.seed,
+            status: "censored",
+            value: null,
+            source: "model-strategy-session",
+        };
+    }
+    // Seconds since the session start. A non-finite or negative time is not a completion.
+    if (!Number.isFinite(args.firstVisibleChangeSec) || args.firstVisibleChangeSec < 0) {
+        return {
+            drawIndex: args.drawIndex,
+            seed: args.seed,
+            status: "failed",
+            value: null,
+            source: "model-strategy-session",
+        };
+    }
+    return {
+        drawIndex: args.drawIndex,
+        seed: args.seed,
+        status: "observed",
+        value: String(args.firstVisibleChangeSec),
+        source: "model-strategy-session",
+    };
+}
+function quantileKeys(quantiles) {
+    if (quantiles.length === 0)
+        throw new DistributionRejected("distribution quantiles must be non-empty");
+    const keys = [];
+    const seen = new Set();
+    for (const q of quantiles) {
+        const key = canonicalQuantileKey(q);
+        if (seen.has(key))
+            throw new DistributionRejected(`distribution quantile key ${key} is duplicated`);
+        seen.add(key);
+        keys.push(key);
+    }
+    return keys;
+}
+function formatFinite(value) {
+    if (Object.is(value, -0))
+        return "0";
+    return String(value);
+}
+const DECIMAL_WIRE = /^([+-]?)(\d*)(?:\.(\d*))?(?:e([+-]?\d+))?$/i;
+/** Sign, significant digits, and exponent of a decimal spelling, so two spellings of one value compare equal. */
+function decimalKey(text) {
+    const match = DECIMAL_WIRE.exec(text.trim());
+    if (!match)
+        return null;
+    const whole = match[2] ?? "";
+    const fraction = match[3] ?? "";
+    if (whole === "" && fraction === "")
+        return null;
+    // Index scans, not /0+$/: a regex anchored at the end rescans a long run of zeros from every start.
+    const raw = `${whole}${fraction}`;
+    let first = 0;
+    while (first < raw.length && raw[first] === "0")
+        first += 1;
+    let last = raw.length;
+    while (last > first && raw[last - 1] === "0")
+        last -= 1;
+    if (first === last)
+        return "0";
+    const exponent = Number(match[4] ?? "0") - fraction.length + (raw.length - last);
+    return `${match[1] === "-" ? "-" : ""}${raw.slice(first, last)}e${exponent}`;
+}
+/**
+ * The observed value as a number, only when the number is the value the caller wrote.
+ * A spelling that rounds, such as 9007199254740993, is rejected rather than reported as a neighbour.
+ */
+function parseObserved(value) {
+    if (value === null)
+        return null;
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed))
+        return null;
+    const written = decimalKey(value);
+    if (written === null)
+        return null;
+    if (written !== decimalKey(String(parsed)) && !(written === "0" && parsed === 0)) {
+        throw new DistributionRejected(`distribution observed value ${value} is not exactly representable`);
+    }
+    return parsed;
+}
+/** Neumaier compensated sum of value / scale. A large value that cancels does not erase a small residual. */
+function compensatedSum(values, scale) {
+    let sum = 0;
+    let compensation = 0;
+    for (const value of values) {
+        const term = value / scale;
+        const next = sum + term;
+        compensation += Math.abs(sum) >= Math.abs(term) ? sum - next + term : term - next + sum;
+        sum = next;
+    }
+    return sum + compensation;
+}
+/** Mean that stays finite when the values are finite and keeps small residuals when large values cancel. */
+function finiteMean(values) {
+    let smallest = Number.POSITIVE_INFINITY;
+    let largest = Number.NEGATIVE_INFINITY;
+    for (const value of values) {
+        smallest = Math.min(smallest, value);
+        largest = Math.max(largest, value);
+    }
+    // The unscaled sum keeps subnormal terms. Only when it overflows are the terms divided by a power of two large
+    // enough that n of them cannot overflow; that division is exact for every term that is not itself subnormal.
+    const unscaled = compensatedSum(values, 1);
+    const mean = Number.isFinite(unscaled)
+        ? unscaled / values.length
+        : (() => {
+            // Scale only the terms of at least 1, which cannot underflow when halved a few times. Smaller terms keep
+            // their own unscaled sum, so a subnormal residual survives large values that overflow and cancel.
+            const scale = 2 ** (Math.ceil(Math.log2(values.length)) + 1);
+            const large = values.filter((value) => Math.abs(value) >= 1);
+            const small = values.filter((value) => Math.abs(value) < 1);
+            return (compensatedSum(large, scale) / values.length) * scale + compensatedSum(small, 1) / values.length;
+        })();
+    // Every mean lies inside [min, max], so rounding at the number limit cannot step past it.
+    return Math.min(largest, Math.max(smallest, mean));
+}
+/** Population variance, rescaled when the squares overflow. Null when the variance itself is not a finite number. */
+function finiteVariance(values, mean) {
+    const plain = values.reduce((sum, value) => sum + (value - mean) ** 2, 0) / values.length;
+    if (Number.isFinite(plain))
+        return plain;
+    let scale = 0;
+    for (const value of values)
+        scale = Math.max(scale, Math.abs(value - mean));
+    if (!Number.isFinite(scale) || scale === 0)
+        return null;
+    const scaled = values.reduce((sum, value) => sum + ((value - mean) / scale) ** 2, 0) / values.length;
+    const variance = scaled * scale * scale;
+    return Number.isFinite(variance) ? variance : null;
+}
+function meanSlot(label, status, value) {
+    return {
+        label,
+        status,
+        value: status === "observed" && value !== null && Number.isFinite(value) ? formatFinite(value) : null,
+    };
+}
+function populationAt(observed, censored, probability, horizonSec) {
+    const key = canonicalQuantileKey(probability);
+    if (horizonSec === null) {
+        return {
+            key,
+            q: probability,
+            conditioning: "all-eligible-draws",
+            estimator: "not-estimated",
+            status: "unavailable",
+            value: null,
+        };
+    }
+    const eligible = observed.length + censored;
+    if (eligible === 0 || observed.length === 0) {
+        return {
+            key,
+            q: probability,
+            conditioning: "all-eligible-draws",
+            estimator: "common-horizon-order-statistic",
+            status: "unavailable",
+            value: null,
+        };
+    }
+    const sorted = [...observed].sort((left, right) => left - right);
+    const index = Math.floor((eligible - 1) * probability);
+    if (index >= sorted.length) {
+        return {
+            key,
+            q: probability,
+            conditioning: "all-eligible-draws",
+            estimator: "common-horizon-order-statistic",
+            status: "outside-observed-range",
+            value: null,
+        };
+    }
+    const value = sorted[index];
+    if (value === undefined) {
+        return {
+            key,
+            q: probability,
+            conditioning: "all-eligible-draws",
+            estimator: "common-horizon-order-statistic",
+            status: "unavailable",
+            value: null,
+        };
+    }
+    return {
+        key,
+        q: probability,
+        conditioning: "all-eligible-draws",
+        estimator: "common-horizon-order-statistic",
+        status: "observed",
+        value: formatFinite(value),
+    };
+}
+/**
+ * Summarise fixed samples. Empty observed values stay unavailable.
+ * The population p95 uses a common horizon only. It does not copy the conditional quantile.
+ */
+export function analyzeDistribution(request) {
+    if (request.coupling?.commonRandomNumbers && request.coupling.executionStream !== true) {
+        throw new DistributionRejected("common random numbers require the execution stream");
+    }
+    const keys = quantileKeys(request.quantiles);
+    const probability = request.populationProbability ?? 0.95;
+    canonicalQuantileKey(probability);
+    const horizonSec = request.horizonSec === undefined ? null : request.horizonSec;
+    if (horizonSec !== null && (typeof horizonSec !== "number" || !Number.isFinite(horizonSec) || horizonSec < 0)) {
+        throw new DistributionRejected("distribution horizonSec must be a finite number >= 0 or null");
+    }
+    const ordered = [...request.samples].sort((left, right) => left.drawIndex - right.drawIndex);
+    const seen = new Set();
+    const observed = [];
+    let rightCensored = 0;
+    let failed = 0;
+    let unsupported = 0;
+    const sources = new Set();
+    for (const sample of ordered) {
+        if (!Number.isInteger(sample.drawIndex) || sample.drawIndex < 0) {
+            throw new DistributionRejected("distribution drawIndex must be an integer >= 0");
+        }
+        if (seen.has(sample.drawIndex))
+            throw new DistributionRejected("distribution drawIndex must be unique");
+        seen.add(sample.drawIndex);
+        if (typeof sample.seed !== "number" || !Number.isFinite(sample.seed)) {
+            throw new DistributionRejected("distribution seed must be finite");
+        }
+        // Untyped input can carry any source. The artifact names only the two the contract declares.
+        if (sample.source !== "model-strategy-session" && sample.source !== "monetization") {
+            throw new DistributionRejected("distribution sample source must be model-strategy-session or monetization");
+        }
+        sources.add(sample.source);
+        if (sample.status === "censored") {
+            rightCensored += 1;
+            continue;
+        }
+        if (sample.status === "failed") {
+            failed += 1;
+            continue;
+        }
+        if (sample.status === "unsupported") {
+            unsupported += 1;
+            continue;
+        }
+        // Untyped input can carry any status. Only "observed" is counted as a completion.
+        if (sample.status !== "observed") {
+            throw new DistributionRejected("distribution sample status must be observed, censored, failed, or unsupported");
+        }
+        const parsed = parseObserved(sample.value);
+        if (parsed === null) {
+            failed += 1;
+            continue;
+        }
+        // The common-horizon estimator ranks every censored draw after every completion. A completion past the
+        // horizon would make that rank unknowable.
+        if (horizonSec !== null && parsed > horizonSec) {
+            throw new DistributionRejected("distribution observed value exceeds the common horizonSec");
+        }
+        observed.push(parsed);
+    }
+    const eligible = observed.length + rightCensored;
+    const completionRate = eligible > 0 ? observed.length / eligible : null;
+    const arithmetic = observed.length > 0 ? finiteMean(observed) : null;
+    const identical = observed.every((value) => value === observed[0]);
+    const rawVariance = arithmetic === null ? null : finiteVariance(observed, arithmetic);
+    // Distinct observations whose squared deviations underflow are not zero variance. That variance is reported as
+    // absent, and zeroVariance stays tied to identical draws.
+    const variance = rawVariance === 0 && !identical ? null : rawVariance;
+    const positive = observed.every((value) => value > 0);
+    // The log values are summed with compensation too, so a small one survives large ones that cancel.
+    const meanLog = arithmetic !== null && positive ? compensatedSum(observed.map((value) => Math.log10(value)), 1) / observed.length : null;
+    const logMean = arithmetic !== null && arithmetic > 0 ? Math.log10(arithmetic) : null;
+    const source = sources.size > 1 ? "mixed" : ([...sources][0] ?? "model-strategy-session");
+    const population = populationAt(observed, rightCensored, probability, horizonSec);
+    const conditional = request.quantiles.map((q, index) => {
+        const value = quantileInclusiveFloor(observed, q);
+        return {
+            key: keys[index] ?? canonicalQuantileKey(q),
+            q,
+            conditioning: "completed-only",
+            status: value === null ? "unavailable" : "observed",
+            value: value === null ? null : formatFinite(value),
+        };
+    });
+    const status = ordered.length > 0 && unsupported === ordered.length
+        ? "unsupported"
+        : observed.length === 0
+            ? "unavailable"
+            : "ok";
+    return {
+        schemaVersion: 1,
+        algorithmVersion: DISTRIBUTION_ALGORITHM_VERSION,
+        method: { id: QUANTILE_METHOD, version: QUANTILE_METHOD_VERSION },
+        status,
+        horizonSec,
+        accounting: {
+            draws: ordered.length,
+            observed: observed.length,
+            rightCensored,
+            failed,
+            unsupported,
+            completionRate,
+        },
+        seeds: ordered.map((sample) => ({
+            drawId: logicalDrawId(sample.drawIndex),
+            drawIndex: sample.drawIndex,
+            seed: sample.seed,
+        })),
+        uncertainty: {
+            source,
+            zeroVariance: arithmetic !== null && identical,
+            variance,
+        },
+        population,
+        conditional,
+        means: {
+            arithmetic: meanSlot("arithmetic-mean", arithmetic === null ? "unavailable" : "observed", arithmetic),
+            meanLog10: meanSlot("mean-of-log10", arithmetic === null ? "unavailable" : positive ? "observed" : "unsupported", meanLog),
+            log10OfMean: meanSlot("log10-of-arithmetic-mean", arithmetic === null ? "unavailable" : arithmetic > 0 ? "observed" : "unsupported", logMean),
+        },
+        reduction: { order: "logical-draw-index", workerCountIndependent: true },
+        warnings: arithmetic !== null && variance === null
+            ? [
+                ...WARNINGS,
+                rawVariance === 0
+                    ? "variance is below the number range and is not reported"
+                    : "variance exceeds the number range and is not reported",
+            ]
+            : WARNINGS,
+    };
+}
+//# sourceMappingURL=distribution.js.map