@idlekit/core 0.2.0 → 0.3.0

package/dist/sim/analysis/experiment.js

@@ -0,0 +1,2206 @@
+import * as _validateReport_1 from "typia/lib/internal/_validateReport";
+import * as _createStandardSchema_1 from "typia/lib/internal/_createStandardSchema";
+import typia, {} from "typia";
+import { compileScenario } from "../../scenario/compile";
+import { canonicalJson, sha256Text } from "../../scenario/scenarioContract";
+import { createRunFactory } from "../runFactory";
+import { runScenario } from "../simulator";
+import { runElapsedSec } from "../types";
+import { assignmentFitsParamSpace, elasticityFromChange, localElasticity, relativeParameterChange, paretoFrontBy, } from "./sensitivity";
+/**
+ * Experiment spec v1.
+ * Separate from ScenarioV1 and from strategy-only TuneSpecV1.
+ * The first method is a fixed candidate sweep plus one-at-a-time local sensitivity.
+ */
+const EXPERIMENT_ALGORITHM_VERSION = "experiment-oat-v1";
+const EXPERIMENT_ESTIMATOR_VERSION = "one-at-a-time-local-v1";
+const EXPERIMENT_SCHEMA_ID = "https://idlekit.dev/schemas/experiment.v1.schema.json";
+const EXPERIMENT_METHOD = "fixed-sweep-and-one-at-a-time";
+/**
+ * @evidence docs/requirements/active/parameter-experiments.md#req-pr14-tune-signature TuneSpec stays strategy-only. The experiment spec is a separate object.
+ * @evidenceReview docs/requirements/active/parameter-experiments.md#req-pr14-tune-signature #365035c Re-read the section: strategy tune still scores seeds 7 and 11 as 9, and the experiment spec is not a TuneSpec.
+ */
+export const experimentSeparateSpec = "experiment-spec-not-tunespec";
+/**
+ * @evidence docs/requirements/active/parameter-experiments.md#req-pr14-registered-setter Assignment uses a registered identifier path and the model or strategy schema. JSONPath, prototype, and eval paths are refused before a run.
+ * @evidenceReview docs/requirements/active/parameter-experiments.md#req-pr14-registered-setter #847f7d0 Re-read the section: a prototype path, an out-of-range integer, a non-finite choice value, a non-finite space bound, a schema-invalid rate, a stripped path, overlapping paths, a session dimension, a repeated seed, a non-finite limit, and a repeated constraint id throw before model create.
+ */
+export const experimentRegisteredSetter = "registered-key-not-jsonpath";
+/**
+ * @evidence docs/requirements/active/parameter-experiments.md#req-pr14-local-elasticity Constant income reaches T/p. Local elasticity is signed and is not a Sobol or global index.
+ * @evidenceReview docs/requirements/active/parameter-experiments.md#req-pr14-local-elasticity #bd1aa44 Re-read the section: rate 2 reaches in 5 with elasticity -0.5, rate 0.5 reaches in 20 with elasticity -2, maxPicks stays flat, and the conformance relation checks -p/p' for divisor rates.
+ */
+export const experimentLocalOat = "one-at-a-time-local-not-sobol";
+/**
+ * @evidence docs/requirements/active/parameter-experiments.md#req-pr14-candidate-order Candidate order does not change the report, and the input scenario object is not written.
+ * @evidenceReview docs/requirements/active/parameter-experiments.md#req-pr14-candidate-order #7cede33 Re-read the section: reversed candidate ids keep the same effective hash, the scenario JSON is unchanged, the one compile per experiment brings create to 6, and elasticity rows follow the sorted dimension ids.
+ */
+export const experimentCandidateOrder = "sorted-candidates-unmutated-scenario";
+/**
+ * @evidence docs/requirements/active/parameter-experiments.md#req-pr14-censored-horizon A goal missed inside the horizon stays censored. That time is not the horizon and is not differentiated.
+ * @evidenceReview docs/requirements/active/parameter-experiments.md#req-pr14-censored-horizon #befcebb Re-read the section: horizon 9 with target 10 leaves the reach time null, not 9, the reach time is read on the way while the run continues to the horizon, and no scenario stop condition or step budget ends it early.
+ */
+export const experimentCensoredHorizon = "censored-time-not-horizon";
+/**
+ * @evidence docs/requirements/active/parameter-experiments.md#req-pr14-pareto-unknown Pareto keeps per-metric tradeoffs. An unknown objective is uncompared, not a win.
+ * @evidenceReview docs/requirements/active/parameter-experiments.md#req-pr14-pareto-unknown #440698a Re-read the section: A, B, and C are non-dominated, D is dominated, E is uncompared, money is compared pairwise in the effective engine, and the elasticity stays in that engine until it is text.
+ */
+export const experimentParetoUnknown = "unknown-is-not-superior";
+/**
+ * @evidence docs/requirements/active/parameter-experiments.md#req-pr14-task-descriptor Each task records its id, parameter JSON, logical seed, and engine and model versions. It does not store a function.
+ * @evidenceReview docs/requirements/active/parameter-experiments.md#req-pr14-task-descriptor #10a3f42 Re-read the section: the income candidate changes incomeRate and the policy candidate changes maxPicks on the same seed, both from the raw scenario params applied in dimension id order, and a string probe id is JSON text.
+ */
+export const experimentTaskDescriptor = "task-id-params-seed-version";
+const WARNINGS = [
+    "one-at-a-time local sensitivity is not global sensitivity and is not a Sobol index",
+    "a censored reach time is not the horizon and is not differentiated",
+    "an unknown or censored objective is not a superior Pareto result",
+    "constraint violations are listed per metric and are not a weighted score",
+];
+export function experimentSchemaId() {
+    return EXPERIMENT_SCHEMA_ID;
+}
+export function experimentAlgorithmVersion() {
+    return EXPERIMENT_ALGORITHM_VERSION;
+}
+export function experimentEstimatorVersion() {
+    return EXPERIMENT_ESTIMATOR_VERSION;
+}
+export class ExperimentRejected extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ExperimentRejected";
+    }
+}
+/*
+ * 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 validateExperimentArtifactValidator;
+/**
+ * @evidence docs/requirements/active/parameter-experiments.md#req-pr14-task-descriptor The generated validator accepts this artifact.
+ * @evidenceReview docs/requirements/active/parameter-experiments.md#req-pr14-task-descriptor #10a3f42 Re-read the section: the wire object is experiment v1 and the method is fixed-sweep-and-one-at-a-time.
+ */
+export const validateExperimentArtifact = (input) => (validateExperimentArtifactValidator ??= (() => {
+    const _ip0 = input => 1 === input["schemaVersion"];
+    const _ip1 = input => "idlekit.experiment.v1" === input["contract"];
+    const _ip2 = input => "one-at-a-time-local-v1" === input["estimatorVersion"];
+    const _ip3 = input => "experiment-oat-v1" === input["algorithmVersion"];
+    const _ip4 = input => "fixed-sweep-and-one-at-a-time" === input["method"];
+    const _ip5 = input => false === input["globalSensitivity"];
+    const _ip6 = input => false === input["sobol"];
+    const _ip7 = input => "object" === typeof input["scenario"] && null !== input["scenario"] && _io1(input["scenario"]);
+    const _ip8 = input => "string" === typeof input["originalSpecHash"];
+    const _ip9 = input => "string" === typeof input["effectiveSpecHash"];
+    const _ip10 = input => "string" === typeof input["effectiveRunHash"];
+    const _ip11 = input => "object" === typeof input["budget"] && null !== input["budget"] && _io2(input["budget"]);
+    const _ip12 = input => Array.isArray(input["tasks"]) && input["tasks"].every(elem => "object" === typeof elem && null !== elem && _io3(elem));
+    const _ip13 = input => Array.isArray(input["candidates"]) && input["candidates"].every(elem => "object" === typeof elem && null !== elem && _io4(elem));
+    const _ip14 = input => Array.isArray(input["elasticities"]) && input["elasticities"].every(elem => "object" === typeof elem && null !== elem && _io6(elem));
+    const _ip15 = input => "object" === typeof input["pareto"] && null !== input["pareto"] && _io7(input["pareto"]);
+    const _ip16 = input => Array.isArray(input["warnings"]) && input["warnings"].every(elem => "string" === typeof elem);
+    const _ip17 = input => "string" === typeof input["taskId"];
+    const _ip18 = input => "string" === typeof input["candidateId"];
+    const _ip19 = input => "number" === typeof input["logicalSeed"];
+    const _ip20 = input => "string" === typeof input["engineId"];
+    const _ip21 = input => "string" === typeof input["engineVersion"];
+    const _ip22 = input => "string" === typeof input["modelId"];
+    const _ip23 = input => "number" === typeof input["modelVersion"];
+    const _ip24 = input => null === input["strategyId"] || "string" === typeof input["strategyId"];
+    const _ip25 = input => "string" === typeof input["modelParams"];
+    const _ip26 = input => "string" === typeof input["strategyParams"];
+    const _ip27 = input => "string" === typeof input["sessionPattern"];
+    const _ip28 = input => "number" === typeof input["sessionDays"];
+    const _ip29 = input => "number" === typeof input["horizonSec"];
+    const _ip30 = input => "number" === typeof input["stepSec"];
+    const _ip31 = input => "endMoney" === input["metricId"] || "timeToMoney" === input["metricId"] || "varBenefit" === input["metricId"];
+    const _ip32 = input => "censored" === input["status"] || "failed" === input["status"] || "observed" === input["status"] || "rejected" === input["status"];
+    const _ip33 = input => null === input["value"] || "string" === typeof input["value"];
+    const _ve0 = "Readonly<{ schemaVersion: 1; contract: \"idlekit.experiment.v1\"; estimatorVersion: \"one-at-a-time-local-v1\"; algorithmVersion: \"experiment-oat-v1\"; method: \"fixed-sweep-and-one-at-a-time\"; ... 11 more ...; warnings: readonly string[]; }>";
+    const _vp0 = (input, _path, _exceptionable = true) => 1 === input["schemaVersion"] || _report(_exceptionable, {
+        path: _path + ".schemaVersion",
+        expected: "1",
+        value: input["schemaVersion"]
+    });
+    const _vp1 = (input, _path, _exceptionable = true) => "idlekit.experiment.v1" === input["contract"] || _report(_exceptionable, {
+        path: _path + ".contract",
+        expected: "\"idlekit.experiment.v1\"",
+        value: input["contract"]
+    });
+    const _vp2 = (input, _path, _exceptionable = true) => "one-at-a-time-local-v1" === input["estimatorVersion"] || _report(_exceptionable, {
+        path: _path + ".estimatorVersion",
+        expected: "\"one-at-a-time-local-v1\"",
+        value: input["estimatorVersion"]
+    });
+    const _vp3 = (input, _path, _exceptionable = true) => "experiment-oat-v1" === input["algorithmVersion"] || _report(_exceptionable, {
+        path: _path + ".algorithmVersion",
+        expected: "\"experiment-oat-v1\"",
+        value: input["algorithmVersion"]
+    });
+    const _vp4 = (input, _path, _exceptionable = true) => "fixed-sweep-and-one-at-a-time" === input["method"] || _report(_exceptionable, {
+        path: _path + ".method",
+        expected: "\"fixed-sweep-and-one-at-a-time\"",
+        value: input["method"]
+    });
+    const _vp5 = (input, _path, _exceptionable = true) => false === input["globalSensitivity"] || _report(_exceptionable, {
+        path: _path + ".globalSensitivity",
+        expected: "false",
+        value: input["globalSensitivity"]
+    });
+    const _vp6 = (input, _path, _exceptionable = true) => false === input["sobol"] || _report(_exceptionable, {
+        path: _path + ".sobol",
+        expected: "false",
+        value: input["sobol"]
+    });
+    const _vp7 = (input, _path, _exceptionable = true) => ("object" === typeof input["scenario"] && null !== input["scenario"] || _report(_exceptionable, {
+        path: _path + ".scenario",
+        expected: "Readonly<{ ref: string; hash: string; }>",
+        value: input["scenario"]
+    })) && _vo1(input["scenario"], _path + ".scenario", true && _exceptionable) || _report(_exceptionable, {
+        path: _path + ".scenario",
+        expected: "Readonly<{ ref: string; hash: string; }>",
+        value: input["scenario"]
+    });
+    const _vp8 = (input, _path, _exceptionable = true) => "string" === typeof input["originalSpecHash"] || _report(_exceptionable, {
+        path: _path + ".originalSpecHash",
+        expected: "string",
+        value: input["originalSpecHash"]
+    });
+    const _vp9 = (input, _path, _exceptionable = true) => "string" === typeof input["effectiveSpecHash"] || _report(_exceptionable, {
+        path: _path + ".effectiveSpecHash",
+        expected: "string",
+        value: input["effectiveSpecHash"]
+    });
+    const _vp10 = (input, _path, _exceptionable = true) => "string" === typeof input["effectiveRunHash"] || _report(_exceptionable, {
+        path: _path + ".effectiveRunHash",
+        expected: "string",
+        value: input["effectiveRunHash"]
+    });
+    const _vp11 = (input, _path, _exceptionable = true) => ("object" === typeof input["budget"] && null !== input["budget"] || _report(_exceptionable, {
+        path: _path + ".budget",
+        expected: "Readonly<{ candidates: number; seeds: number; usedCandidates: number; usedSeeds: number; }>",
+        value: input["budget"]
+    })) && _vo2(input["budget"], _path + ".budget", true && _exceptionable) || _report(_exceptionable, {
+        path: _path + ".budget",
+        expected: "Readonly<{ candidates: number; seeds: number; usedCandidates: number; usedSeeds: number; }>",
+        value: input["budget"]
+    });
+    const _vp12 = (input, _path, _exceptionable = true) => (Array.isArray(input["tasks"]) || _report(_exceptionable, {
+        path: _path + ".tasks",
+        expected: _ve2,
+        value: input["tasks"]
+    })) && input["tasks"].map((elem, _index9) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+        path: _path + ".tasks[" + _index9 + "]",
+        expected: _ve1,
+        value: elem
+    })) && _vo3(elem, _path + ".tasks[" + _index9 + "]", true && _exceptionable) || _report(_exceptionable, {
+        path: _path + ".tasks[" + _index9 + "]",
+        expected: _ve1,
+        value: elem
+    })).every(flag => flag) || _report(_exceptionable, {
+        path: _path + ".tasks",
+        expected: _ve2,
+        value: input["tasks"]
+    });
+    const _ve1 = "Readonly<{ taskId: string; candidateId: string; logicalSeed: number; engineId: string; engineVersion: string; modelId: string; modelVersion: number; strategyId: string | null; modelParams: string; ... 7 more ...; value: string | null; }>";
+    const _ve2 = "ReadonlyArray<Readonly<{ taskId: string; candidateId: string; logicalSeed: number; engineId: string; engineVersion: string; modelId: string; modelVersion: number; strategyId: string | null; modelParams: string; ... 7 more ...; value: string | null; }>>";
+    const _vp13 = (input, _path, _exceptionable = true) => (Array.isArray(input["candidates"]) || _report(_exceptionable, {
+        path: _path + ".candidates",
+        expected: _ve4,
+        value: input["candidates"]
+    })) && input["candidates"].map((elem, _index10) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+        path: _path + ".candidates[" + _index10 + "]",
+        expected: _ve3,
+        value: elem
+    })) && _vo4(elem, _path + ".candidates[" + _index10 + "]", true && _exceptionable) || _report(_exceptionable, {
+        path: _path + ".candidates[" + _index10 + "]",
+        expected: _ve3,
+        value: elem
+    })).every(flag => flag) || _report(_exceptionable, {
+        path: _path + ".candidates",
+        expected: _ve4,
+        value: input["candidates"]
+    });
+    const _ve3 = "Readonly<{ id: string; metrics: readonly Readonly<{ metricId: ExperimentMetricId; status: ExperimentMetricStatus; value: string | null; }>[]; constraintViolations: readonly string[]; }>";
+    const _ve4 = "ReadonlyArray<Readonly<{ id: string; metrics: readonly Readonly<{ metricId: ExperimentMetricId; status: ExperimentMetricStatus; value: string | null; }>[]; constraintViolations: readonly string[]; }>>";
+    const _vp14 = (input, _path, _exceptionable = true) => (Array.isArray(input["elasticities"]) || _report(_exceptionable, {
+        path: _path + ".elasticities",
+        expected: _ve6,
+        value: input["elasticities"]
+    })) && input["elasticities"].map((elem, _index11) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+        path: _path + ".elasticities[" + _index11 + "]",
+        expected: _ve5,
+        value: elem
+    })) && _vo6(elem, _path + ".elasticities[" + _index11 + "]", true && _exceptionable) || _report(_exceptionable, {
+        path: _path + ".elasticities[" + _index11 + "]",
+        expected: _ve5,
+        value: elem
+    })).every(flag => flag) || _report(_exceptionable, {
+        path: _path + ".elasticities",
+        expected: _ve6,
+        value: input["elasticities"]
+    });
+    const _ve5 = "Readonly<{ dimensionId: string; candidateId: string; metricId: ExperimentMetricId; method: \"one-at-a-time-local\"; methodVersion: 1; globalSensitivity: false; sobol: false; status: \"observed\" | \"unavailable\"; elasticity: string | null; absoluteChange: string | null; direction: \"flat\" | ... 2 more ... | \"unavailable\";...";
+    const _ve6 = "ReadonlyArray<Readonly<{ dimensionId: string; candidateId: string; metricId: ExperimentMetricId; method: \"one-at-a-time-local\"; methodVersion: 1; globalSensitivity: false; sobol: false; status: \"observed\" | \"unavailable\"; elasticity: string | null; absoluteChange: string | null; direction: \"flat\" | ... 2 more ... | \"unavailable\";...>";
+    const _vp15 = (input, _path, _exceptionable = true) => ("object" === typeof input["pareto"] && null !== input["pareto"] || _report(_exceptionable, {
+        path: _path + ".pareto",
+        expected: "Readonly<{ sense: \"per-metric\"; nonDominated: readonly string[]; uncompared: readonly string[]; }>",
+        value: input["pareto"]
+    })) && _vo7(input["pareto"], _path + ".pareto", true && _exceptionable) || _report(_exceptionable, {
+        path: _path + ".pareto",
+        expected: "Readonly<{ sense: \"per-metric\"; nonDominated: readonly string[]; uncompared: readonly string[]; }>",
+        value: input["pareto"]
+    });
+    const _vp16 = (input, _path, _exceptionable = true) => (Array.isArray(input["warnings"]) || _report(_exceptionable, {
+        path: _path + ".warnings",
+        expected: "ReadonlyArray<string>",
+        value: input["warnings"]
+    })) && input["warnings"].map((elem, _index12) => "string" === typeof elem || _report(_exceptionable, {
+        path: _path + ".warnings[" + _index12 + "]",
+        expected: "string",
+        value: elem
+    })).every(flag => flag) || _report(_exceptionable, {
+        path: _path + ".warnings",
+        expected: "ReadonlyArray<string>",
+        value: input["warnings"]
+    });
+    const _vp17 = (input, _path, _exceptionable = true) => "string" === typeof input["taskId"] || _report(_exceptionable, {
+        path: _path + ".taskId",
+        expected: "string",
+        value: input["taskId"]
+    });
+    const _vp18 = (input, _path, _exceptionable = true) => "string" === typeof input["candidateId"] || _report(_exceptionable, {
+        path: _path + ".candidateId",
+        expected: "string",
+        value: input["candidateId"]
+    });
+    const _vp19 = (input, _path, _exceptionable = true) => "number" === typeof input["logicalSeed"] || _report(_exceptionable, {
+        path: _path + ".logicalSeed",
+        expected: "number",
+        value: input["logicalSeed"]
+    });
+    const _vp20 = (input, _path, _exceptionable = true) => "string" === typeof input["engineId"] || _report(_exceptionable, {
+        path: _path + ".engineId",
+        expected: "string",
+        value: input["engineId"]
+    });
+    const _vp21 = (input, _path, _exceptionable = true) => "string" === typeof input["engineVersion"] || _report(_exceptionable, {
+        path: _path + ".engineVersion",
+        expected: "string",
+        value: input["engineVersion"]
+    });
+    const _vp22 = (input, _path, _exceptionable = true) => "string" === typeof input["modelId"] || _report(_exceptionable, {
+        path: _path + ".modelId",
+        expected: "string",
+        value: input["modelId"]
+    });
+    const _vp23 = (input, _path, _exceptionable = true) => "number" === typeof input["modelVersion"] || _report(_exceptionable, {
+        path: _path + ".modelVersion",
+        expected: "number",
+        value: input["modelVersion"]
+    });
+    const _vp24 = (input, _path, _exceptionable = true) => null === input["strategyId"] || "string" === typeof input["strategyId"] || _report(_exceptionable, {
+        path: _path + ".strategyId",
+        expected: "(null | string)",
+        value: input["strategyId"]
+    });
+    const _vp25 = (input, _path, _exceptionable = true) => "string" === typeof input["modelParams"] || _report(_exceptionable, {
+        path: _path + ".modelParams",
+        expected: "string",
+        value: input["modelParams"]
+    });
+    const _vp26 = (input, _path, _exceptionable = true) => "string" === typeof input["strategyParams"] || _report(_exceptionable, {
+        path: _path + ".strategyParams",
+        expected: "string",
+        value: input["strategyParams"]
+    });
+    const _vp27 = (input, _path, _exceptionable = true) => "string" === typeof input["sessionPattern"] || _report(_exceptionable, {
+        path: _path + ".sessionPattern",
+        expected: "string",
+        value: input["sessionPattern"]
+    });
+    const _vp28 = (input, _path, _exceptionable = true) => "number" === typeof input["sessionDays"] || _report(_exceptionable, {
+        path: _path + ".sessionDays",
+        expected: "number",
+        value: input["sessionDays"]
+    });
+    const _vp29 = (input, _path, _exceptionable = true) => "number" === typeof input["horizonSec"] || _report(_exceptionable, {
+        path: _path + ".horizonSec",
+        expected: "number",
+        value: input["horizonSec"]
+    });
+    const _vp30 = (input, _path, _exceptionable = true) => "number" === typeof input["stepSec"] || _report(_exceptionable, {
+        path: _path + ".stepSec",
+        expected: "number",
+        value: input["stepSec"]
+    });
+    const _vp31 = (input, _path, _exceptionable = true) => "endMoney" === input["metricId"] || "timeToMoney" === input["metricId"] || "varBenefit" === input["metricId"] || _report(_exceptionable, {
+        path: _path + ".metricId",
+        expected: "(\"endMoney\" | \"timeToMoney\" | \"varBenefit\")",
+        value: input["metricId"]
+    });
+    const _vp32 = (input, _path, _exceptionable = true) => "censored" === input["status"] || "failed" === input["status"] || "observed" === input["status"] || "rejected" === input["status"] || _report(_exceptionable, {
+        path: _path + ".status",
+        expected: "(\"censored\" | \"failed\" | \"observed\" | \"rejected\")",
+        value: input["status"]
+    });
+    const _vp33 = (input, _path, _exceptionable = true) => null === input["value"] || "string" === typeof input["value"] || _report(_exceptionable, {
+        path: _path + ".value",
+        expected: "(null | string)",
+        value: input["value"]
+    });
+    const _io0 = input => _ip0(input) && _ip1(input) && _ip2(input) && _ip3(input) && _ip4(input) && _ip5(input) && _ip6(input) && _ip7(input) && _ip8(input) && _ip9(input) && _ip10(input) && _ip11(input) && _ip12(input) && _ip13(input) && _ip14(input) && _ip15(input) && _ip16(input);
+    const _io1 = input => "string" === typeof input.ref && "string" === typeof input.hash;
+    const _io2 = input => "number" === typeof input.candidates && "number" === typeof input.seeds && "number" === typeof input.usedCandidates && "number" === typeof input.usedSeeds;
+    const _io3 = input => _ip17(input) && _ip18(input) && _ip19(input) && _ip20(input) && _ip21(input) && _ip22(input) && _ip23(input) && _ip24(input) && _ip25(input) && _ip26(input) && _ip27(input) && _ip28(input) && _ip29(input) && _ip30(input) && _ip31(input) && _ip32(input) && _ip33(input);
+    const _io4 = input => "string" === typeof input.id && (Array.isArray(input.metrics) && input.metrics.every(elem => "object" === typeof elem && null !== elem && _io5(elem))) && (Array.isArray(input.constraintViolations) && input.constraintViolations.every(elem => "string" === typeof elem));
+    const _io5 = input => _ip31(input) && _ip32(input) && _ip33(input);
+    const _io6 = input => "string" === typeof input.dimensionId && _ip18(input) && _ip31(input) && "one-at-a-time-local" === input.method && 1 === input.methodVersion && _ip5(input) && _ip6(input) && ("observed" === input.status || "unavailable" === input.status) && (null === input.elasticity || "string" === typeof input.elasticity) && (null === input.absoluteChange || "string" === typeof input.absoluteChange) && ("flat" === input.direction || "higher" === input.direction || "lower" === input.direction || "unavailable" === input.direction);
+    const _io7 = input => "per-metric" === input.sense && (Array.isArray(input.nonDominated) && input.nonDominated.every(elem => "string" === typeof elem)) && (Array.isArray(input.uncompared) && input.uncompared.every(elem => "string" === typeof elem));
+    const _vo0 = (input, _path, _exceptionable = true) => [_vp0(input, _path, true && _exceptionable), _vp1(input, _path, true && _exceptionable), _vp2(input, _path, true && _exceptionable), _vp3(input, _path, true && _exceptionable), _vp4(input, _path, true && _exceptionable), _vp5(input, _path, true && _exceptionable), _vp6(input, _path, true && _exceptionable), _vp7(input, _path, true && _exceptionable), _vp8(input, _path, true && _exceptionable), _vp9(input, _path, true && _exceptionable), _vp10(input, _path, true && _exceptionable), _vp11(input, _path, true && _exceptionable), _vp12(input, _path, true && _exceptionable), _vp13(input, _path, true && _exceptionable), _vp14(input, _path, true && _exceptionable), _vp15(input, _path, true && _exceptionable), _vp16(input, _path, true && _exceptionable)].every(flag => flag);
+    const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.ref || _report(_exceptionable, {
+            path: _path + ".ref",
+            expected: "string",
+            value: input.ref
+        }), "string" === typeof input.hash || _report(_exceptionable, {
+            path: _path + ".hash",
+            expected: "string",
+            value: input.hash
+        })].every(flag => flag);
+    const _vo2 = (input, _path, _exceptionable = true) => ["number" === typeof input.candidates || _report(_exceptionable, {
+            path: _path + ".candidates",
+            expected: "number",
+            value: input.candidates
+        }), "number" === typeof input.seeds || _report(_exceptionable, {
+            path: _path + ".seeds",
+            expected: "number",
+            value: input.seeds
+        }), "number" === typeof input.usedCandidates || _report(_exceptionable, {
+            path: _path + ".usedCandidates",
+            expected: "number",
+            value: input.usedCandidates
+        }), "number" === typeof input.usedSeeds || _report(_exceptionable, {
+            path: _path + ".usedSeeds",
+            expected: "number",
+            value: input.usedSeeds
+        })].every(flag => flag);
+    const _vo3 = (input, _path, _exceptionable = true) => [_vp17(input, _path, true && _exceptionable), _vp18(input, _path, true && _exceptionable), _vp19(input, _path, true && _exceptionable), _vp20(input, _path, true && _exceptionable), _vp21(input, _path, true && _exceptionable), _vp22(input, _path, true && _exceptionable), _vp23(input, _path, true && _exceptionable), _vp24(input, _path, true && _exceptionable), _vp25(input, _path, true && _exceptionable), _vp26(input, _path, true && _exceptionable), _vp27(input, _path, true && _exceptionable), _vp28(input, _path, true && _exceptionable), _vp29(input, _path, true && _exceptionable), _vp30(input, _path, true && _exceptionable), _vp31(input, _path, true && _exceptionable), _vp32(input, _path, true && _exceptionable), _vp33(input, _path, true && _exceptionable)].every(flag => flag);
+    const _vo4 = (input, _path, _exceptionable = true) => ["string" === typeof input.id || _report(_exceptionable, {
+            path: _path + ".id",
+            expected: "string",
+            value: input.id
+        }), (Array.isArray(input.metrics) || _report(_exceptionable, {
+            path: _path + ".metrics",
+            expected: "ReadonlyArray<Readonly<{ metricId: ExperimentMetricId; status: ExperimentMetricStatus; value: string | null; }>>",
+            value: input.metrics
+        })) && input.metrics.map((elem, _index13) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+            path: _path + ".metrics[" + _index13 + "]",
+            expected: "Readonly<{ metricId: ExperimentMetricId; status: ExperimentMetricStatus; value: string | null; }>",
+            value: elem
+        })) && _vo5(elem, _path + ".metrics[" + _index13 + "]", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".metrics[" + _index13 + "]",
+            expected: "Readonly<{ metricId: ExperimentMetricId; status: ExperimentMetricStatus; value: string | null; }>",
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + ".metrics",
+            expected: "ReadonlyArray<Readonly<{ metricId: ExperimentMetricId; status: ExperimentMetricStatus; value: string | null; }>>",
+            value: input.metrics
+        }), (Array.isArray(input.constraintViolations) || _report(_exceptionable, {
+            path: _path + ".constraintViolations",
+            expected: "ReadonlyArray<string>",
+            value: input.constraintViolations
+        })) && input.constraintViolations.map((elem, _index14) => "string" === typeof elem || _report(_exceptionable, {
+            path: _path + ".constraintViolations[" + _index14 + "]",
+            expected: "string",
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + ".constraintViolations",
+            expected: "ReadonlyArray<string>",
+            value: input.constraintViolations
+        })].every(flag => flag);
+    const _vo5 = (input, _path, _exceptionable = true) => [_vp31(input, _path, true && _exceptionable), _vp32(input, _path, true && _exceptionable), _vp33(input, _path, true && _exceptionable)].every(flag => flag);
+    const _vo6 = (input, _path, _exceptionable = true) => ["string" === typeof input.dimensionId || _report(_exceptionable, {
+            path: _path + ".dimensionId",
+            expected: "string",
+            value: input.dimensionId
+        }), _vp18(input, _path, true && _exceptionable), _vp31(input, _path, true && _exceptionable), "one-at-a-time-local" === input.method || _report(_exceptionable, {
+            path: _path + ".method",
+            expected: "\"one-at-a-time-local\"",
+            value: input.method
+        }), 1 === input.methodVersion || _report(_exceptionable, {
+            path: _path + ".methodVersion",
+            expected: "1",
+            value: input.methodVersion
+        }), _vp5(input, _path, true && _exceptionable), _vp6(input, _path, true && _exceptionable), "observed" === input.status || "unavailable" === input.status || _report(_exceptionable, {
+            path: _path + ".status",
+            expected: "(\"observed\" | \"unavailable\")",
+            value: input.status
+        }), null === input.elasticity || "string" === typeof input.elasticity || _report(_exceptionable, {
+            path: _path + ".elasticity",
+            expected: "(null | string)",
+            value: input.elasticity
+        }), null === input.absoluteChange || "string" === typeof input.absoluteChange || _report(_exceptionable, {
+            path: _path + ".absoluteChange",
+            expected: "(null | string)",
+            value: input.absoluteChange
+        }), "flat" === input.direction || "higher" === input.direction || "lower" === input.direction || "unavailable" === input.direction || _report(_exceptionable, {
+            path: _path + ".direction",
+            expected: "(\"flat\" | \"higher\" | \"lower\" | \"unavailable\")",
+            value: input.direction
+        })].every(flag => flag);
+    const _vo7 = (input, _path, _exceptionable = true) => ["per-metric" === input.sense || _report(_exceptionable, {
+            path: _path + ".sense",
+            expected: "\"per-metric\"",
+            value: input.sense
+        }), (Array.isArray(input.nonDominated) || _report(_exceptionable, {
+            path: _path + ".nonDominated",
+            expected: "ReadonlyArray<string>",
+            value: input.nonDominated
+        })) && input.nonDominated.map((elem, _index15) => "string" === typeof elem || _report(_exceptionable, {
+            path: _path + ".nonDominated[" + _index15 + "]",
+            expected: "string",
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + ".nonDominated",
+            expected: "ReadonlyArray<string>",
+            value: input.nonDominated
+        }), (Array.isArray(input.uncompared) || _report(_exceptionable, {
+            path: _path + ".uncompared",
+            expected: "ReadonlyArray<string>",
+            value: input.uncompared
+        })) && input.uncompared.map((elem, _index16) => "string" === typeof elem || _report(_exceptionable, {
+            path: _path + ".uncompared[" + _index16 + "]",
+            expected: "string",
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + ".uncompared",
+            expected: "ReadonlyArray<string>",
+            value: input.uncompared
+        })].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 buildExperimentJsonSchema() {
+    return {
+        components: {
+            schemas: {
+                "ReadonlyschemaVersion1contractidlekit_x2E_experiment_x2E_v1estimatorVersionone-at-a-time-local-v1algorithmVersionexperiment-oat-v1methodfixed-sweep-and-one-at-a-time---11more---warningsreadonlystring-x86544DB8D4D46D5D": {
+                    type: "object",
+                    properties: {
+                        schemaVersion: {
+                            "const": 1
+                        },
+                        contract: {
+                            "const": "idlekit.experiment.v1"
+                        },
+                        estimatorVersion: {
+                            "const": "one-at-a-time-local-v1"
+                        },
+                        algorithmVersion: {
+                            "const": "experiment-oat-v1"
+                        },
+                        method: {
+                            "const": "fixed-sweep-and-one-at-a-time"
+                        },
+                        globalSensitivity: {
+                            "const": false
+                        },
+                        sobol: {
+                            "const": false
+                        },
+                        scenario: {
+                            $ref: "#/components/schemas/Readonlyrefstringhashstring"
+                        },
+                        originalSpecHash: {
+                            type: "string"
+                        },
+                        effectiveSpecHash: {
+                            type: "string"
+                        },
+                        effectiveRunHash: {
+                            type: "string"
+                        },
+                        budget: {
+                            $ref: "#/components/schemas/ReadonlycandidatesnumberseedsnumberusedCandidatesnumberusedSeedsnumber"
+                        },
+                        tasks: {
+                            type: "array",
+                            items: {
+                                $ref: "#/components/schemas/ReadonlytaskIdstringcandidateIdstringlogicalSeednumberengineIdstringengineVersionstringmodelIdstringmodelVersionnumberstrategyIdstringnullmodelParamsstring---7more---valuestringnull"
+                            }
+                        },
+                        candidates: {
+                            type: "array",
+                            items: {
+                                $ref: "#/components/schemas/ReadonlyidstringmetricsreadonlyReadonlymetricIdExperimentMetricIdstatusExperimentMetricStatusvaluestringnullconstraintViolationsreadonlystring"
+                            }
+                        },
+                        elasticities: {
+                            type: "array",
+                            items: {
+                                $ref: "#/components/schemas/ReadonlydimensionIdstringcandidateIdstringmetricIdExperimentMetricIdmethodone-at-a-time-localmethodVersion1globalSensitivityfalsesobolfalsestatusobservedunavailableelasticitystringnullabsoluteChangestringnulldirectionflat---2more---unavailable---"
+                            }
+                        },
+                        pareto: {
+                            $ref: "#/components/schemas/Readonlysenseper-metricnonDominatedreadonlystringuncomparedreadonlystring"
+                        },
+                        warnings: {
+                            type: "array",
+                            items: {
+                                type: "string"
+                            }
+                        }
+                    },
+                    required: [
+                        "schemaVersion",
+                        "contract",
+                        "estimatorVersion",
+                        "algorithmVersion",
+                        "method",
+                        "globalSensitivity",
+                        "sobol",
+                        "scenario",
+                        "originalSpecHash",
+                        "effectiveSpecHash",
+                        "effectiveRunHash",
+                        "budget",
+                        "tasks",
+                        "candidates",
+                        "elasticities",
+                        "pareto",
+                        "warnings"
+                    ],
+                    additionalProperties: false
+                },
+                Readonlyrefstringhashstring: {
+                    type: "object",
+                    properties: {
+                        ref: {
+                            type: "string"
+                        },
+                        hash: {
+                            type: "string"
+                        }
+                    },
+                    required: [
+                        "ref",
+                        "hash"
+                    ],
+                    additionalProperties: false
+                },
+                ReadonlycandidatesnumberseedsnumberusedCandidatesnumberusedSeedsnumber: {
+                    type: "object",
+                    properties: {
+                        candidates: {
+                            type: "number"
+                        },
+                        seeds: {
+                            type: "number"
+                        },
+                        usedCandidates: {
+                            type: "number"
+                        },
+                        usedSeeds: {
+                            type: "number"
+                        }
+                    },
+                    required: [
+                        "candidates",
+                        "seeds",
+                        "usedCandidates",
+                        "usedSeeds"
+                    ],
+                    additionalProperties: false
+                },
+                "ReadonlytaskIdstringcandidateIdstringlogicalSeednumberengineIdstringengineVersionstringmodelIdstringmodelVersionnumberstrategyIdstringnullmodelParamsstring---7more---valuestringnull": {
+                    type: "object",
+                    properties: {
+                        taskId: {
+                            type: "string"
+                        },
+                        candidateId: {
+                            type: "string"
+                        },
+                        logicalSeed: {
+                            type: "number"
+                        },
+                        engineId: {
+                            type: "string"
+                        },
+                        engineVersion: {
+                            type: "string"
+                        },
+                        modelId: {
+                            type: "string"
+                        },
+                        modelVersion: {
+                            type: "number"
+                        },
+                        strategyId: {
+                            oneOf: [
+                                {
+                                    type: "null"
+                                },
+                                {
+                                    type: "string"
+                                }
+                            ]
+                        },
+                        modelParams: {
+                            type: "string"
+                        },
+                        strategyParams: {
+                            type: "string"
+                        },
+                        sessionPattern: {
+                            type: "string"
+                        },
+                        sessionDays: {
+                            type: "number"
+                        },
+                        horizonSec: {
+                            type: "number"
+                        },
+                        stepSec: {
+                            type: "number"
+                        },
+                        metricId: {
+                            $ref: "#/components/schemas/ExperimentMetricId"
+                        },
+                        status: {
+                            $ref: "#/components/schemas/ExperimentMetricStatus"
+                        },
+                        value: {
+                            oneOf: [
+                                {
+                                    type: "null"
+                                },
+                                {
+                                    type: "string"
+                                }
+                            ]
+                        }
+                    },
+                    required: [
+                        "taskId",
+                        "candidateId",
+                        "logicalSeed",
+                        "engineId",
+                        "engineVersion",
+                        "modelId",
+                        "modelVersion",
+                        "strategyId",
+                        "modelParams",
+                        "strategyParams",
+                        "sessionPattern",
+                        "sessionDays",
+                        "horizonSec",
+                        "stepSec",
+                        "metricId",
+                        "status",
+                        "value"
+                    ],
+                    additionalProperties: false
+                },
+                ExperimentMetricId: {
+                    oneOf: [
+                        {
+                            "const": "endMoney"
+                        },
+                        {
+                            "const": "timeToMoney"
+                        },
+                        {
+                            "const": "varBenefit"
+                        }
+                    ]
+                },
+                ExperimentMetricStatus: {
+                    oneOf: [
+                        {
+                            "const": "censored"
+                        },
+                        {
+                            "const": "failed"
+                        },
+                        {
+                            "const": "observed"
+                        },
+                        {
+                            "const": "rejected"
+                        }
+                    ]
+                },
+                ReadonlyidstringmetricsreadonlyReadonlymetricIdExperimentMetricIdstatusExperimentMetricStatusvaluestringnullconstraintViolationsreadonlystring: {
+                    type: "object",
+                    properties: {
+                        id: {
+                            type: "string"
+                        },
+                        metrics: {
+                            type: "array",
+                            items: {
+                                $ref: "#/components/schemas/ReadonlymetricIdExperimentMetricIdstatusExperimentMetricStatusvaluestringnull"
+                            }
+                        },
+                        constraintViolations: {
+                            type: "array",
+                            items: {
+                                type: "string"
+                            }
+                        }
+                    },
+                    required: [
+                        "id",
+                        "metrics",
+                        "constraintViolations"
+                    ],
+                    additionalProperties: false
+                },
+                ReadonlymetricIdExperimentMetricIdstatusExperimentMetricStatusvaluestringnull: {
+                    type: "object",
+                    properties: {
+                        metricId: {
+                            $ref: "#/components/schemas/ExperimentMetricId"
+                        },
+                        status: {
+                            $ref: "#/components/schemas/ExperimentMetricStatus"
+                        },
+                        value: {
+                            oneOf: [
+                                {
+                                    type: "null"
+                                },
+                                {
+                                    type: "string"
+                                }
+                            ]
+                        }
+                    },
+                    required: [
+                        "metricId",
+                        "status",
+                        "value"
+                    ],
+                    additionalProperties: false
+                },
+                "ReadonlydimensionIdstringcandidateIdstringmetricIdExperimentMetricIdmethodone-at-a-time-localmethodVersion1globalSensitivityfalsesobolfalsestatusobservedunavailableelasticitystringnullabsoluteChangestringnulldirectionflat---2more---unavailable---": {
+                    type: "object",
+                    properties: {
+                        dimensionId: {
+                            type: "string"
+                        },
+                        candidateId: {
+                            type: "string"
+                        },
+                        metricId: {
+                            $ref: "#/components/schemas/ExperimentMetricId"
+                        },
+                        method: {
+                            "const": "one-at-a-time-local"
+                        },
+                        methodVersion: {
+                            "const": 1
+                        },
+                        globalSensitivity: {
+                            "const": false
+                        },
+                        sobol: {
+                            "const": false
+                        },
+                        status: {
+                            oneOf: [
+                                {
+                                    "const": "observed"
+                                },
+                                {
+                                    "const": "unavailable"
+                                }
+                            ]
+                        },
+                        elasticity: {
+                            oneOf: [
+                                {
+                                    type: "null"
+                                },
+                                {
+                                    type: "string"
+                                }
+                            ]
+                        },
+                        absoluteChange: {
+                            oneOf: [
+                                {
+                                    type: "null"
+                                },
+                                {
+                                    type: "string"
+                                }
+                            ]
+                        },
+                        direction: {
+                            oneOf: [
+                                {
+                                    "const": "flat"
+                                },
+                                {
+                                    "const": "higher"
+                                },
+                                {
+                                    "const": "lower"
+                                },
+                                {
+                                    "const": "unavailable"
+                                }
+                            ]
+                        }
+                    },
+                    required: [
+                        "dimensionId",
+                        "candidateId",
+                        "metricId",
+                        "method",
+                        "methodVersion",
+                        "globalSensitivity",
+                        "sobol",
+                        "status",
+                        "elasticity",
+                        "absoluteChange",
+                        "direction"
+                    ],
+                    additionalProperties: false
+                },
+                "Readonlysenseper-metricnonDominatedreadonlystringuncomparedreadonlystring": {
+                    type: "object",
+                    properties: {
+                        sense: {
+                            "const": "per-metric"
+                        },
+                        nonDominated: {
+                            type: "array",
+                            items: {
+                                type: "string"
+                            }
+                        },
+                        uncompared: {
+                            type: "array",
+                            items: {
+                                type: "string"
+                            }
+                        }
+                    },
+                    required: [
+                        "sense",
+                        "nonDominated",
+                        "uncompared"
+                    ],
+                    additionalProperties: false
+                }
+            }
+        },
+        schema: {
+            type: "object",
+            properties: {
+                schemaVersion: {
+                    "const": 1
+                },
+                contract: {
+                    "const": "idlekit.experiment.v1"
+                },
+                estimatorVersion: {
+                    "const": "one-at-a-time-local-v1"
+                },
+                algorithmVersion: {
+                    "const": "experiment-oat-v1"
+                },
+                method: {
+                    "const": "fixed-sweep-and-one-at-a-time"
+                },
+                globalSensitivity: {
+                    "const": false
+                },
+                sobol: {
+                    "const": false
+                },
+                scenario: {
+                    $ref: "#/components/schemas/Readonlyrefstringhashstring"
+                },
+                originalSpecHash: {
+                    type: "string"
+                },
+                effectiveSpecHash: {
+                    type: "string"
+                },
+                effectiveRunHash: {
+                    type: "string"
+                },
+                budget: {
+                    $ref: "#/components/schemas/ReadonlycandidatesnumberseedsnumberusedCandidatesnumberusedSeedsnumber"
+                },
+                tasks: {
+                    type: "array",
+                    items: {
+                        $ref: "#/components/schemas/ReadonlytaskIdstringcandidateIdstringlogicalSeednumberengineIdstringengineVersionstringmodelIdstringmodelVersionnumberstrategyIdstringnullmodelParamsstring---7more---valuestringnull"
+                    }
+                },
+                candidates: {
+                    type: "array",
+                    items: {
+                        $ref: "#/components/schemas/ReadonlyidstringmetricsreadonlyReadonlymetricIdExperimentMetricIdstatusExperimentMetricStatusvaluestringnullconstraintViolationsreadonlystring"
+                    }
+                },
+                elasticities: {
+                    type: "array",
+                    items: {
+                        $ref: "#/components/schemas/ReadonlydimensionIdstringcandidateIdstringmetricIdExperimentMetricIdmethodone-at-a-time-localmethodVersion1globalSensitivityfalsesobolfalsestatusobservedunavailableelasticitystringnullabsoluteChangestringnulldirectionflat---2more---unavailable---"
+                    }
+                },
+                pareto: {
+                    $ref: "#/components/schemas/Readonlysenseper-metricnonDominatedreadonlystringuncomparedreadonlystring"
+                },
+                warnings: {
+                    type: "array",
+                    items: {
+                        type: "string"
+                    }
+                }
+            },
+            required: [
+                "schemaVersion",
+                "contract",
+                "estimatorVersion",
+                "algorithmVersion",
+                "method",
+                "globalSensitivity",
+                "sobol",
+                "scenario",
+                "originalSpecHash",
+                "effectiveSpecHash",
+                "effectiveRunHash",
+                "budget",
+                "tasks",
+                "candidates",
+                "elasticities",
+                "pareto",
+                "warnings"
+            ],
+            additionalProperties: false
+        },
+        version: "3.1"
+    };
+}
+let experimentJsonSchemaUnit;
+/**
+ * @evidence docs/requirements/active/parameter-experiments.md#req-pr14-tune-signature The structural schema is OpenAPI 3.1 from typia.
+ * @evidenceReview docs/requirements/active/parameter-experiments.md#req-pr14-tune-signature #365035c Re-read the section: schema version is 3.1 and the contract id is idlekit.experiment.v1.
+ */
+export function experimentJsonSchema() {
+    experimentJsonSchemaUnit ??= buildExperimentJsonSchema();
+    return experimentJsonSchemaUnit;
+}
+let validateExperimentSpecValidator;
+export const validateExperimentSpec = (input) => (validateExperimentSpecValidator ??= (() => {
+    const _ip0 = input => "endMoney" === input["metricId"] || "timeToMoney" === input["metricId"] || "varBenefit" === input["metricId"];
+    const _ip1 = input => "string" === typeof input["id"];
+    const _ip2 = input => "number" === typeof input["min"];
+    const _ip3 = input => "number" === typeof input["max"];
+    const _ve0 = "Readonly<{ schemaVersion: 1; scenario: Readonly<{ ref: string; hash: string; }>; model: Readonly<{ id: string; version: number; }>; strategy?: Readonly<{ id: string; }> | undefined; ... 10 more ...; session: Readonly<...>; }>";
+    const _vp0 = (input, _path, _exceptionable = true) => "endMoney" === input["metricId"] || "timeToMoney" === input["metricId"] || "varBenefit" === input["metricId"] || _report(_exceptionable, {
+        path: _path + ".metricId",
+        expected: "(\"endMoney\" | \"timeToMoney\" | \"varBenefit\")",
+        value: input["metricId"]
+    });
+    const _ve1 = "Readonly<{ id: string; target: \"model\" | \"session\" | \"strategy\"; path: string; space: ExperimentParamSpace; baseline: ExperimentScalar; probes?: readonly ExperimentScalar[] | undefined; }>";
+    const _ve2 = "ReadonlyArray<Readonly<{ id: string; target: \"model\" | \"session\" | \"strategy\"; path: string; space: ExperimentParamSpace; baseline: ExperimentScalar; probes?: readonly ExperimentScalar[] | undefined; }>>";
+    const _ve3 = "(ReadonlyArray<Readonly<{ id: string; assignments: readonly Readonly<{ dimensionId: string; value: ExperimentScalar; }>[]; }>> | undefined)";
+    const _vp1 = (input, _path, _exceptionable = true) => "string" === typeof input["id"] || _report(_exceptionable, {
+        path: _path + ".id",
+        expected: "string",
+        value: input["id"]
+    });
+    const _ve4 = "(Readonly<{ kind: \"bool\"; }> | Readonly<{ kind: \"choice\"; values: readonly ExperimentScalar[]; }> | Readonly<{ kind: \"int\"; min: number; max: number; }> | Readonly<{ kind: \"number\"; min: number; max: number; scale?: \"linear\" | \"log\" | undefined; }>)";
+    const _vp2 = (input, _path, _exceptionable = true) => "number" === typeof input["min"] || _report(_exceptionable, {
+        path: _path + ".min",
+        expected: "number",
+        value: input["min"]
+    });
+    const _vp3 = (input, _path, _exceptionable = true) => "number" === typeof input["max"] || _report(_exceptionable, {
+        path: _path + ".max",
+        expected: "number",
+        value: input["max"]
+    });
+    const _ve5 = "(Readonly<{ kind: \"bool\"; }> | Readonly<{ kind: \"int\"; min: number; max: number; }> | Readonly<{ kind: \"number\"; min: number; max: number; scale?: \"linear\" | \"log\" | undefined; }> | Readonly<{ kind: \"choice\"; values: readonly ExperimentScalar[]; }>)";
+    const _io0 = input => 1 === input.schemaVersion && ("object" === typeof input.scenario && null !== input.scenario && _io1(input.scenario)) && ("object" === typeof input.model && null !== input.model && _io2(input.model)) && (undefined === input.strategy || "object" === typeof input.strategy && null !== input.strategy && _io3(input.strategy)) && _ip0(input) && (undefined === input.goal || "object" === typeof input.goal && null !== input.goal && _io4(input.goal)) && (undefined === input.objectives || Array.isArray(input.objectives) && input.objectives.every(elem => "object" === typeof elem && null !== elem && _io5(elem))) && (undefined === input.constraints || Array.isArray(input.constraints) && input.constraints.every(elem => "object" === typeof elem && null !== elem && _io6(elem))) && (Array.isArray(input.dimensions) && input.dimensions.every(elem => "object" === typeof elem && null !== elem && _io7(elem))) && (undefined === input.candidates || Array.isArray(input.candidates) && input.candidates.every(elem => "object" === typeof elem && null !== elem && _io12(elem))) && ("object" === typeof input.budget && null !== input.budget && _io14(input.budget)) && (Array.isArray(input.seeds) && input.seeds.every(elem => "number" === typeof elem)) && "number" === typeof input.horizonSec && "number" === typeof input.stepSec && ("object" === typeof input.session && null !== input.session && _io15(input.session));
+    const _io1 = input => "string" === typeof input.ref && "string" === typeof input.hash;
+    const _io10 = input => "number" === input.kind && _ip2(input) && _ip3(input) && (undefined === input.scale || "linear" === input.scale || "log" === input.scale);
+    const _io11 = input => "choice" === input.kind && (Array.isArray(input.values) && input.values.every(elem => null === elem || "string" === typeof elem || "number" === typeof elem || "boolean" === typeof elem));
+    const _io12 = input => _ip1(input) && (Array.isArray(input.assignments) && input.assignments.every(elem => "object" === typeof elem && null !== elem && _io13(elem)));
+    const _io13 = input => "string" === typeof input.dimensionId && (null === input.value || "string" === typeof input.value || "number" === typeof input.value || "boolean" === typeof input.value);
+    const _io14 = input => "number" === typeof input.candidates && "number" === typeof input.seeds;
+    const _io15 = input => "string" === typeof input.pattern && "number" === typeof input.days;
+    const _io2 = input => _ip1(input) && "number" === typeof input.version;
+    const _io3 = input => _ip1(input);
+    const _io4 = input => "number" === typeof input.target;
+    const _io5 = input => _ip1(input) && _ip0(input) && ("higher" === input.sense || "lower" === input.sense);
+    const _io6 = input => _ip1(input) && _ip0(input) && ("gte" === input.op || "lte" === input.op) && "number" === typeof input.limit;
+    const _io7 = input => _ip1(input) && ("model" === input.target || "session" === input.target || "strategy" === input.target) && "string" === typeof input.path && ("object" === typeof input.space && null !== input.space && _iu0(input.space)) && (null === input.baseline || "string" === typeof input.baseline || "number" === typeof input.baseline || "boolean" === typeof input.baseline) && (undefined === input.probes || Array.isArray(input.probes) && input.probes.every(elem => null === elem || "string" === typeof elem || "number" === typeof elem || "boolean" === typeof elem));
+    const _io8 = input => "bool" === input.kind;
+    const _io9 = input => "int" === input.kind && _ip2(input) && _ip3(input);
+    const _iu0 = input => (() => {
+        if ("bool" === input.kind)
+            return _io8(input);
+        else if ("int" === input.kind)
+            return _io9(input);
+        else if ("number" === input.kind)
+            return _io10(input);
+        else if ("choice" === input.kind)
+            return _io11(input);
+        else
+            return false;
+    })();
+    const _vo0 = (input, _path, _exceptionable = true) => [1 === input.schemaVersion || _report(_exceptionable, {
+            path: _path + ".schemaVersion",
+            expected: "1",
+            value: input.schemaVersion
+        }), ("object" === typeof input.scenario && null !== input.scenario || _report(_exceptionable, {
+            path: _path + ".scenario",
+            expected: "Readonly<{ ref: string; hash: string; }>",
+            value: input.scenario
+        })) && _vo1(input.scenario, _path + ".scenario", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".scenario",
+            expected: "Readonly<{ ref: string; hash: string; }>",
+            value: input.scenario
+        }), ("object" === typeof input.model && null !== input.model || _report(_exceptionable, {
+            path: _path + ".model",
+            expected: "Readonly<{ id: string; version: number; }>",
+            value: input.model
+        })) && _vo2(input.model, _path + ".model", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".model",
+            expected: "Readonly<{ id: string; version: number; }>",
+            value: input.model
+        }), undefined === input.strategy || ("object" === typeof input.strategy && null !== input.strategy || _report(_exceptionable, {
+            path: _path + ".strategy",
+            expected: "(Readonly<{ id: string; }> | undefined)",
+            value: input.strategy
+        })) && _vo3(input.strategy, _path + ".strategy", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".strategy",
+            expected: "(Readonly<{ id: string; }> | undefined)",
+            value: input.strategy
+        }), _vp0(input, _path, true && _exceptionable), undefined === input.goal || ("object" === typeof input.goal && null !== input.goal || _report(_exceptionable, {
+            path: _path + ".goal",
+            expected: "(Readonly<{ target: number; }> | undefined)",
+            value: input.goal
+        })) && _vo4(input.goal, _path + ".goal", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".goal",
+            expected: "(Readonly<{ target: number; }> | undefined)",
+            value: input.goal
+        }), undefined === input.objectives || (Array.isArray(input.objectives) || _report(_exceptionable, {
+            path: _path + ".objectives",
+            expected: "(ReadonlyArray<Readonly<{ id: string; metricId: ExperimentMetricId; sense: \"higher\" | \"lower\"; }>> | undefined)",
+            value: input.objectives
+        })) && input.objectives.map((elem, _index9) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+            path: _path + ".objectives[" + _index9 + "]",
+            expected: "Readonly<{ id: string; metricId: ExperimentMetricId; sense: \"higher\" | \"lower\"; }>",
+            value: elem
+        })) && _vo5(elem, _path + ".objectives[" + _index9 + "]", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".objectives[" + _index9 + "]",
+            expected: "Readonly<{ id: string; metricId: ExperimentMetricId; sense: \"higher\" | \"lower\"; }>",
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + ".objectives",
+            expected: "(ReadonlyArray<Readonly<{ id: string; metricId: ExperimentMetricId; sense: \"higher\" | \"lower\"; }>> | undefined)",
+            value: input.objectives
+        }), undefined === input.constraints || (Array.isArray(input.constraints) || _report(_exceptionable, {
+            path: _path + ".constraints",
+            expected: "(ReadonlyArray<Readonly<{ id: string; metricId: ExperimentMetricId; op: \"gte\" | \"lte\"; limit: number; }>> | undefined)",
+            value: input.constraints
+        })) && input.constraints.map((elem, _index10) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+            path: _path + ".constraints[" + _index10 + "]",
+            expected: "Readonly<{ id: string; metricId: ExperimentMetricId; op: \"gte\" | \"lte\"; limit: number; }>",
+            value: elem
+        })) && _vo6(elem, _path + ".constraints[" + _index10 + "]", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".constraints[" + _index10 + "]",
+            expected: "Readonly<{ id: string; metricId: ExperimentMetricId; op: \"gte\" | \"lte\"; limit: number; }>",
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + ".constraints",
+            expected: "(ReadonlyArray<Readonly<{ id: string; metricId: ExperimentMetricId; op: \"gte\" | \"lte\"; limit: number; }>> | undefined)",
+            value: input.constraints
+        }), (Array.isArray(input.dimensions) || _report(_exceptionable, {
+            path: _path + ".dimensions",
+            expected: _ve2,
+            value: input.dimensions
+        })) && input.dimensions.map((elem, _index11) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+            path: _path + ".dimensions[" + _index11 + "]",
+            expected: _ve1,
+            value: elem
+        })) && _vo7(elem, _path + ".dimensions[" + _index11 + "]", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".dimensions[" + _index11 + "]",
+            expected: _ve1,
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + ".dimensions",
+            expected: _ve2,
+            value: input.dimensions
+        }), undefined === input.candidates || (Array.isArray(input.candidates) || _report(_exceptionable, {
+            path: _path + ".candidates",
+            expected: _ve3,
+            value: input.candidates
+        })) && input.candidates.map((elem, _index12) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+            path: _path + ".candidates[" + _index12 + "]",
+            expected: "Readonly<{ id: string; assignments: readonly Readonly<{ dimensionId: string; value: ExperimentScalar; }>[]; }>",
+            value: elem
+        })) && _vo12(elem, _path + ".candidates[" + _index12 + "]", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".candidates[" + _index12 + "]",
+            expected: "Readonly<{ id: string; assignments: readonly Readonly<{ dimensionId: string; value: ExperimentScalar; }>[]; }>",
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + ".candidates",
+            expected: _ve3,
+            value: input.candidates
+        }), ("object" === typeof input.budget && null !== input.budget || _report(_exceptionable, {
+            path: _path + ".budget",
+            expected: "Readonly<{ candidates: number; seeds: number; }>",
+            value: input.budget
+        })) && _vo14(input.budget, _path + ".budget", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".budget",
+            expected: "Readonly<{ candidates: number; seeds: number; }>",
+            value: input.budget
+        }), (Array.isArray(input.seeds) || _report(_exceptionable, {
+            path: _path + ".seeds",
+            expected: "ReadonlyArray<number>",
+            value: input.seeds
+        })) && input.seeds.map((elem, _index13) => "number" === typeof elem || _report(_exceptionable, {
+            path: _path + ".seeds[" + _index13 + "]",
+            expected: "number",
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + ".seeds",
+            expected: "ReadonlyArray<number>",
+            value: input.seeds
+        }), "number" === typeof input.horizonSec || _report(_exceptionable, {
+            path: _path + ".horizonSec",
+            expected: "number",
+            value: input.horizonSec
+        }), "number" === typeof input.stepSec || _report(_exceptionable, {
+            path: _path + ".stepSec",
+            expected: "number",
+            value: input.stepSec
+        }), ("object" === typeof input.session && null !== input.session || _report(_exceptionable, {
+            path: _path + ".session",
+            expected: "Readonly<{ pattern: string; days: number; }>",
+            value: input.session
+        })) && _vo15(input.session, _path + ".session", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".session",
+            expected: "Readonly<{ pattern: string; days: number; }>",
+            value: input.session
+        })].every(flag => flag);
+    const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.ref || _report(_exceptionable, {
+            path: _path + ".ref",
+            expected: "string",
+            value: input.ref
+        }), "string" === typeof input.hash || _report(_exceptionable, {
+            path: _path + ".hash",
+            expected: "string",
+            value: input.hash
+        })].every(flag => flag);
+    const _vo10 = (input, _path, _exceptionable = true) => ["number" === input.kind || _report(_exceptionable, {
+            path: _path + ".kind",
+            expected: "\"number\"",
+            value: input.kind
+        }), _vp2(input, _path, true && _exceptionable), _vp3(input, _path, true && _exceptionable), undefined === input.scale || "linear" === input.scale || "log" === input.scale || _report(_exceptionable, {
+            path: _path + ".scale",
+            expected: "(\"linear\" | \"log\" | undefined)",
+            value: input.scale
+        })].every(flag => flag);
+    const _vo11 = (input, _path, _exceptionable = true) => ["choice" === input.kind || _report(_exceptionable, {
+            path: _path + ".kind",
+            expected: "\"choice\"",
+            value: input.kind
+        }), (Array.isArray(input.values) || _report(_exceptionable, {
+            path: _path + ".values",
+            expected: "ReadonlyArray<ExperimentScalar>",
+            value: input.values
+        })) && input.values.map((elem, _index15) => null === elem || "string" === typeof elem || "number" === typeof elem || "boolean" === typeof elem || _report(_exceptionable, {
+            path: _path + ".values[" + _index15 + "]",
+            expected: "(boolean | null | number | string)",
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + ".values",
+            expected: "ReadonlyArray<ExperimentScalar>",
+            value: input.values
+        })].every(flag => flag);
+    const _vo12 = (input, _path, _exceptionable = true) => [_vp1(input, _path, true && _exceptionable), (Array.isArray(input.assignments) || _report(_exceptionable, {
+            path: _path + ".assignments",
+            expected: "ReadonlyArray<Readonly<{ dimensionId: string; value: ExperimentScalar; }>>",
+            value: input.assignments
+        })) && input.assignments.map((elem, _index16) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+            path: _path + ".assignments[" + _index16 + "]",
+            expected: "Readonly<{ dimensionId: string; value: ExperimentScalar; }>",
+            value: elem
+        })) && _vo13(elem, _path + ".assignments[" + _index16 + "]", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".assignments[" + _index16 + "]",
+            expected: "Readonly<{ dimensionId: string; value: ExperimentScalar; }>",
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + ".assignments",
+            expected: "ReadonlyArray<Readonly<{ dimensionId: string; value: ExperimentScalar; }>>",
+            value: input.assignments
+        })].every(flag => flag);
+    const _vo13 = (input, _path, _exceptionable = true) => ["string" === typeof input.dimensionId || _report(_exceptionable, {
+            path: _path + ".dimensionId",
+            expected: "string",
+            value: input.dimensionId
+        }), null === input.value || "string" === typeof input.value || "number" === typeof input.value || "boolean" === typeof input.value || _report(_exceptionable, {
+            path: _path + ".value",
+            expected: "(boolean | null | number | string)",
+            value: input.value
+        })].every(flag => flag);
+    const _vo14 = (input, _path, _exceptionable = true) => ["number" === typeof input.candidates || _report(_exceptionable, {
+            path: _path + ".candidates",
+            expected: "number",
+            value: input.candidates
+        }), "number" === typeof input.seeds || _report(_exceptionable, {
+            path: _path + ".seeds",
+            expected: "number",
+            value: input.seeds
+        })].every(flag => flag);
+    const _vo15 = (input, _path, _exceptionable = true) => ["string" === typeof input.pattern || _report(_exceptionable, {
+            path: _path + ".pattern",
+            expected: "string",
+            value: input.pattern
+        }), "number" === typeof input.days || _report(_exceptionable, {
+            path: _path + ".days",
+            expected: "number",
+            value: input.days
+        })].every(flag => flag);
+    const _vo2 = (input, _path, _exceptionable = true) => [_vp1(input, _path, true && _exceptionable), "number" === typeof input.version || _report(_exceptionable, {
+            path: _path + ".version",
+            expected: "number",
+            value: input.version
+        })].every(flag => flag);
+    const _vo3 = (input, _path, _exceptionable = true) => [_vp1(input, _path, true && _exceptionable)].every(flag => flag);
+    const _vo4 = (input, _path, _exceptionable = true) => ["number" === typeof input.target || _report(_exceptionable, {
+            path: _path + ".target",
+            expected: "number",
+            value: input.target
+        })].every(flag => flag);
+    const _vo5 = (input, _path, _exceptionable = true) => [_vp1(input, _path, true && _exceptionable), _vp0(input, _path, true && _exceptionable), "higher" === input.sense || "lower" === input.sense || _report(_exceptionable, {
+            path: _path + ".sense",
+            expected: "(\"higher\" | \"lower\")",
+            value: input.sense
+        })].every(flag => flag);
+    const _vo6 = (input, _path, _exceptionable = true) => [_vp1(input, _path, true && _exceptionable), _vp0(input, _path, true && _exceptionable), "gte" === input.op || "lte" === input.op || _report(_exceptionable, {
+            path: _path + ".op",
+            expected: "(\"gte\" | \"lte\")",
+            value: input.op
+        }), "number" === typeof input.limit || _report(_exceptionable, {
+            path: _path + ".limit",
+            expected: "number",
+            value: input.limit
+        })].every(flag => flag);
+    const _vo7 = (input, _path, _exceptionable = true) => [_vp1(input, _path, true && _exceptionable), "model" === input.target || "session" === input.target || "strategy" === input.target || _report(_exceptionable, {
+            path: _path + ".target",
+            expected: "(\"model\" | \"session\" | \"strategy\")",
+            value: input.target
+        }), "string" === typeof input.path || _report(_exceptionable, {
+            path: _path + ".path",
+            expected: "string",
+            value: input.path
+        }), ("object" === typeof input.space && null !== input.space || _report(_exceptionable, {
+            path: _path + ".space",
+            expected: _ve4,
+            value: input.space
+        })) && _vu0(input.space, _path + ".space", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".space",
+            expected: _ve4,
+            value: input.space
+        }), null === input.baseline || "string" === typeof input.baseline || "number" === typeof input.baseline || "boolean" === typeof input.baseline || _report(_exceptionable, {
+            path: _path + ".baseline",
+            expected: "(boolean | null | number | string)",
+            value: input.baseline
+        }), undefined === input.probes || (Array.isArray(input.probes) || _report(_exceptionable, {
+            path: _path + ".probes",
+            expected: "(ReadonlyArray<ExperimentScalar> | undefined)",
+            value: input.probes
+        })) && input.probes.map((elem, _index14) => null === elem || "string" === typeof elem || "number" === typeof elem || "boolean" === typeof elem || _report(_exceptionable, {
+            path: _path + ".probes[" + _index14 + "]",
+            expected: "(boolean | null | number | string)",
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + ".probes",
+            expected: "(ReadonlyArray<ExperimentScalar> | undefined)",
+            value: input.probes
+        })].every(flag => flag);
+    const _vo8 = (input, _path, _exceptionable = true) => ["bool" === input.kind || _report(_exceptionable, {
+            path: _path + ".kind",
+            expected: "\"bool\"",
+            value: input.kind
+        })].every(flag => flag);
+    const _vo9 = (input, _path, _exceptionable = true) => ["int" === input.kind || _report(_exceptionable, {
+            path: _path + ".kind",
+            expected: "\"int\"",
+            value: input.kind
+        }), _vp2(input, _path, true && _exceptionable), _vp3(input, _path, true && _exceptionable)].every(flag => flag);
+    const _vu0 = (input, _path, _exceptionable = true) => (() => {
+        if ("bool" === input.kind)
+            return _vo8(input, _path, true && _exceptionable);
+        else if ("int" === input.kind)
+            return _vo9(input, _path, true && _exceptionable);
+        else if ("number" === input.kind)
+            return _vo10(input, _path, true && _exceptionable);
+        else if ("choice" === input.kind)
+            return _vo11(input, _path, true && _exceptionable);
+        else
+            return _report(_exceptionable, {
+                path: _path,
+                expected: _ve5,
+                value: input
+            });
+    })();
+    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);
+const IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+// Canonical JSON drops `__type`, so a parameter with that name would vanish from task descriptors and hashes.
+const BANNED_SEGMENT = new Set(["__proto__", "prototype", "constructor", "eval", "__type"]);
+function reject(message) {
+    throw new ExperimentRejected(`Experiment ${message}`);
+}
+export function assertRegisteredPath(path, target) {
+    if (typeof path !== "string" || path.length === 0 || path !== path.trim())
+        reject("parameter path is empty");
+    if (/[\$\[\]\(\)]/.test(path) || path.includes("..") || path.includes("/") || path.includes("\\") || path.includes(" ")) {
+        reject("parameter path is not a registered identifier");
+    }
+    const parts = path.split(".");
+    if (parts.length === 0 || parts.some((part) => !IDENTIFIER.test(part) || BANNED_SEGMENT.has(part))) {
+        reject("parameter path is not a registered identifier");
+    }
+    if (target === "session" && (parts.length !== 1 || (parts[0] !== "pattern" && parts[0] !== "days"))) {
+        reject("session path must be pattern or days");
+    }
+    return parts;
+}
+export function setRegisteredParam(root, path, value) {
+    const parts = assertRegisteredPath(path, "model");
+    // Copy only the objects on the assigned path, with their prototype and property descriptors.
+    // Every other value keeps its identity and exact number. A copied property is configurable, so a frozen
+    // or read-only source can still take the assigned value as a new own data property.
+    const copy = (source) => {
+        const descriptors = Object.getOwnPropertyDescriptors(source);
+        for (const descriptor of Object.values(descriptors))
+            descriptor.configurable = true;
+        return Object.create(Object.getPrototypeOf(source), descriptors);
+    };
+    const put = (target, key, entry) => {
+        Object.defineProperty(target, key, { value: entry, writable: true, enumerable: true, configurable: true });
+    };
+    const clone = copy(root);
+    let cursor = clone;
+    for (let index = 0; index < parts.length - 1; index += 1) {
+        const key = parts[index];
+        // assertRegisteredPath already bans these. The inline guard keeps the write visibly safe at the assignment.
+        if (key === "__proto__" || key === "constructor" || key === "prototype")
+            reject("parameter path is not a registered identifier");
+        const next = Object.prototype.hasOwnProperty.call(cursor, key) ? cursor[key] : undefined;
+        const copied = next === null || typeof next !== "object" || Array.isArray(next) ? {} : copy(next);
+        put(cursor, key, copied);
+        cursor = copied;
+    }
+    const leaf = parts[parts.length - 1];
+    if (leaf === "__proto__" || leaf === "constructor" || leaf === "prototype")
+        reject("parameter path is not a registered identifier");
+    put(cursor, leaf, value);
+    return clone;
+}
+function byText(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function normalizeSpec(spec) {
+    return {
+        ...spec,
+        dimensions: [...spec.dimensions].sort((left, right) => byText(left.id, right.id)),
+        ...(spec.candidates
+            ? {
+                candidates: [...spec.candidates]
+                    .map((candidate) => ({
+                    ...candidate,
+                    assignments: [...candidate.assignments].sort((left, right) => byText(left.dimensionId, right.dimensionId)),
+                }))
+                    .sort((left, right) => byText(left.id, right.id)),
+            }
+            : {}),
+    };
+}
+/** Two dimensions on one target overlap when one path equals the other or is a dotted prefix of it. */
+function pathsOverlap(left, right) {
+    return left === right || left.startsWith(`${right}.`) || right.startsWith(`${left}.`);
+}
+function requireSpec(input) {
+    const parsed = validateExperimentSpec(input);
+    if (!parsed.success) {
+        reject(`spec rejected: ${parsed.errors.map((error) => error.path).join(", ")}`);
+    }
+    const spec = parsed.data;
+    if (!Number.isFinite(spec.horizonSec) || spec.horizonSec <= 0)
+        reject("horizon must be a positive finite number");
+    // A JSON literal such as 1e400 parses to Infinity, which the artifact and canonical JSON cannot carry.
+    if (!Number.isFinite(spec.model.version) || Object.is(spec.model.version, -0))
+        reject("model version must be finite and not -0");
+    if (spec.strategy !== undefined && spec.strategy.id.length === 0)
+        reject("strategy id must not be empty");
+    if (!Number.isFinite(spec.stepSec) || spec.stepSec <= 0)
+        reject("step must be a positive finite number");
+    if (!Number.isInteger(spec.budget.candidates) || spec.budget.candidates < 1)
+        reject("candidate budget must be a positive integer");
+    if (!Number.isInteger(spec.budget.seeds) || spec.budget.seeds < 1)
+        reject("seed budget must be a positive integer");
+    if (spec.seeds.length === 0 || spec.seeds.some((seed) => !Number.isFinite(seed)))
+        reject("seeds must be finite");
+    if (new Set(spec.seeds).size !== spec.seeds.length)
+        reject("seeds must be unique logical seeds");
+    // Task ids, logical seeds, and canonical JSON write -0 as 0, while ctx.seed would still carry -0.
+    if (spec.seeds.some((seed) => Object.is(seed, -0)))
+        reject("seeds must not be -0");
+    if (spec.seeds.length > spec.budget.seeds)
+        reject("seed budget exceeded");
+    if (!Number.isFinite(spec.session.days) || spec.session.days <= 0)
+        reject("session days must be positive");
+    const ids = new Set();
+    for (const [index, dimension] of spec.dimensions.entries()) {
+        if (ids.has(dimension.id))
+            reject(`duplicate dimension ${dimension.id}`);
+        ids.add(dimension.id);
+        assertRegisteredPath(dimension.path, dimension.target);
+        // A JSON literal such as 1e400 parses to Infinity, and canonical JSON would hash it as null.
+        if (dimension.space.kind === "int" || dimension.space.kind === "number") {
+            if (!Number.isFinite(dimension.space.min) || !Number.isFinite(dimension.space.max))
+                reject(`space bounds for ${dimension.id} must be finite`);
+        }
+        else if (dimension.space.kind === "choice" && dimension.space.values.some((entry) => typeof entry === "number" && !Number.isFinite(entry))) {
+            reject(`choice values for ${dimension.id} must be finite`);
+        }
+        // Each candidate runs one continuous horizon. No session schedule is executed, so a session value would not reach the run.
+        if (dimension.target === "session")
+            reject(`session dimension ${dimension.id} is not executed: each candidate runs one continuous horizon`);
+        for (const other of spec.dimensions.slice(0, index)) {
+            if (other.target === dimension.target && pathsOverlap(other.path, dimension.path)) {
+                reject(`dimensions ${other.id} and ${dimension.id} target the same ${dimension.target} parameter`);
+            }
+        }
+        if (!assignmentFitsParamSpace(dimension.space, dimension.baseline))
+            reject(`baseline for ${dimension.id} is outside its parameter space`);
+        for (const probe of dimension.probes ?? []) {
+            if (!assignmentFitsParamSpace(dimension.space, probe))
+                reject(`probe for ${dimension.id} is outside its parameter space`);
+        }
+    }
+    // An objective id names one Pareto objective. A repeated id would be compared as two independent positions.
+    const objectiveIds = new Set();
+    for (const objective of spec.objectives ?? []) {
+        if (objectiveIds.has(objective.id))
+            reject(`duplicate objective ${objective.id}`);
+        objectiveIds.add(objective.id);
+    }
+    // A violation lists only the constraint id, so the id must name one constraint. A JSON literal such as 1e400 parses to Infinity.
+    const constraintIds = new Set();
+    for (const constraint of spec.constraints ?? []) {
+        if (constraintIds.has(constraint.id))
+            reject(`duplicate constraint ${constraint.id}`);
+        constraintIds.add(constraint.id);
+        if (!Number.isFinite(constraint.limit))
+            reject(`constraint ${constraint.id} limit must be finite`);
+    }
+    return spec;
+}
+/**
+ * Generated probe id. A string probe is written as JSON text, so `1` and `"1"`, or `true` and `"true"`, stay distinct.
+ * A number, boolean, or null probe is written as its plain text.
+ */
+function probeCandidateId(dimension, probe) {
+    return `oat:${dimension.id}:${typeof probe === "string" ? JSON.stringify(probe) : String(probe)}`;
+}
+function plannedCandidates(spec) {
+    const explicit = spec.candidates ?? [];
+    const probes = spec.dimensions.some((dimension) => (dimension.probes?.length ?? 0) > 0);
+    const generated = [];
+    if (explicit.length === 0 || probes) {
+        const baselineAssignments = spec.dimensions.map((dimension) => ({ dimensionId: dimension.id, value: dimension.baseline }));
+        generated.push({ id: "baseline", assignments: baselineAssignments });
+        for (const dimension of [...spec.dimensions].sort((left, right) => byText(left.id, right.id))) {
+            for (const probe of dimension.probes ?? []) {
+                generated.push({
+                    id: probeCandidateId(dimension, probe),
+                    assignments: spec.dimensions.map((item) => ({
+                        dimensionId: item.id,
+                        value: item.id === dimension.id ? probe : item.baseline,
+                    })),
+                });
+            }
+        }
+    }
+    const merged = [...explicit, ...generated].sort((left, right) => byText(left.id, right.id));
+    if (merged.length === 0)
+        reject("experiment requires at least one candidate");
+    if (merged.length > spec.budget.candidates)
+        reject("candidate budget exceeded");
+    const seen = new Set();
+    for (const candidate of merged) {
+        if (candidate.id.length === 0 || seen.has(candidate.id))
+            reject(`duplicate candidate ${candidate.id}`);
+        seen.add(candidate.id);
+    }
+    return merged;
+}
+function hasOwnPath(root, path) {
+    let cursor = root;
+    for (const part of path.split(".")) {
+        if (cursor === null || typeof cursor !== "object" || !Object.prototype.hasOwnProperty.call(cursor, part))
+            return false;
+        cursor = cursor[part];
+    }
+    return true;
+}
+/**
+ * Checks the candidate params like scenario compile does in legacy-raw mode. With a schema, its output only
+ * confirms that every assigned path is registered: a schema that strips that path would leave the run at its
+ * default while the task claims the assignment. Without a schema, the path must already be in the scenario or
+ * default params, so a typo is not added as a key the factory ignores. The candidate keeps the raw params, so
+ * unassigned fields stay as the scenario wrote them and `create` receives the same representation as a scenario run.
+ */
+function checkCandidateParams(schema, baseParams, params, assigned, label) {
+    if (!schema) {
+        for (const { dimension } of assigned) {
+            if (!hasOwnPath(baseParams, dimension.path)) {
+                reject(`${label} has no params schema and its scenario params do not register ${dimension.path} for ${dimension.id}`);
+            }
+        }
+        return;
+    }
+    // A detached copy: a schema that writes its input cannot reach the candidate, the base, or the caller.
+    const result = schema["~standard"].validate(cloneJsonData(params));
+    if (!result.success) {
+        reject(`${label} params rejected: ${result.issues.map((issue) => issue.message).join("; ")}`);
+    }
+    for (const { dimension } of assigned) {
+        if (!hasOwnPath(result.value, dimension.path))
+            reject(`${label} params schema does not register ${dimension.path} for ${dimension.id}`);
+    }
+}
+function asParamRecord(params, label) {
+    if (params === undefined)
+        return {};
+    if (params === null || typeof params !== "object" || Array.isArray(params)) {
+        reject(`${label} params of the scenario are not an object, so a path cannot be assigned`);
+    }
+    return params;
+}
+/**
+ * Task descriptors and hashes write params as canonical JSON, so the params must be JSON data: null, booleans,
+ * strings, finite numbers other than -0, arrays, and plain objects. A Date, a class instance, a function, or an
+ * undefined field would run as one value and be recorded as another, and could not be copied faithfully.
+ * An object reached twice (a shared reference or a cycle) and a `__type` key, which canonical JSON drops,
+ * are refused too.
+ */
+/** An enumerable, writable, configurable data property: the only kind JSON.parse creates. */
+function isOrdinaryData(descriptor) {
+    return (descriptor !== undefined &&
+        "value" in descriptor &&
+        descriptor.enumerable === true &&
+        descriptor.writable === true &&
+        descriptor.configurable === true);
+}
+/**
+ * `allowUndefined` lets an object field hold undefined. Canonical JSON drops that field and spec and scenario
+ * readers treat it as absent. Params do not get this allowance, because a factory can see the key.
+ */
+function isJsonData(value, seen = new Set(), allowUndefined = false) {
+    if (value === null || typeof value === "boolean" || typeof value === "string")
+        return true;
+    if (typeof value === "number")
+        return Number.isFinite(value) && !Object.is(value, -0);
+    if (typeof value !== "object" || seen.has(value))
+        return false;
+    // Visited objects stay recorded, so a shared reference fails like a cycle.
+    seen.add(value);
+    // A frozen, sealed, or non-extensible object is observable but writes the same JSON as an ordinary one.
+    if (!Object.isExtensible(value))
+        return false;
+    if (Array.isArray(value)) {
+        // Only a plain array of index slots: no subclass prototype, no named or symbol own property, no holes or accessors.
+        if (Object.getPrototypeOf(value) !== Array.prototype)
+            return false;
+        // Every slot 0..length-1 is an own enumerable data property, and there is no other own key but length.
+        if (Reflect.ownKeys(value).length !== value.length + 1)
+            return false;
+        for (let index = 0; index < value.length; index += 1) {
+            const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+            if (!isOrdinaryData(descriptor) || !isJsonData(descriptor.value, seen, allowUndefined))
+                return false;
+        }
+        return true;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null)
+        return false;
+    return Reflect.ownKeys(value).every((key) => {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        return (typeof key === "string" &&
+            key !== "__type" &&
+            isOrdinaryData(descriptor) &&
+            ((allowUndefined && descriptor.value === undefined) || isJsonData(descriptor.value, seen, allowUndefined)));
+    });
+}
+/** One visited set spans the model and strategy params, so an object shared between them is refused too. */
+function requireJsonParams(params, label, seen) {
+    // Task descriptors write absent params as null, so an explicit null root would share that record.
+    if (params === null)
+        reject(`${label} params must be an object or omitted, not null`);
+    if (params !== undefined && !isJsonData(params, seen))
+        reject(`${label} params must be JSON data, because task descriptors and hashes record them as JSON`);
+}
+/**
+ * The whole scenario is checked before it is hashed: every field the run reads must be one canonical JSON records.
+ * Canonical JSON writes Infinity as null and -0 as 0 and skips non-enumerable fields, so a constraint such as
+ * maxActionsPerStep or a hidden policy.mode could change the run but not the hash. Params and the initial state
+ * then get the stricter params rule.
+ */
+function requireScenarioData(scenario) {
+    const seen = new Set();
+    requireJsonParams(scenario.model.params, "model", seen);
+    requireJsonParams(scenario.strategy?.params, "strategy", seen);
+    // The initial state, vars included, reaches every run and the scenario hash. It must be JSON data too.
+    if (!isJsonData(scenario.initial, seen))
+        reject("scenario initial state must be JSON data, because the scenario hash records it as JSON");
+    if (!isJsonData(scenario, new Set(), true))
+        reject("scenario must be JSON data, because the scenario hash records it as JSON");
+}
+/**
+ * A private copy of JSON data with object keys in canonical order. A factory that mutates its params cannot reach
+ * another run or the caller, and two params with one canonical JSON reach a factory with one key order.
+ */
+function cloneJsonData(value) {
+    return value === undefined ? value : JSON.parse(canonicalJson(value));
+}
+function candidateBase(spec, scenario, registries) {
+    if (scenario.model.id !== spec.model.id || scenario.model.version !== spec.model.version) {
+        reject(`model ${spec.model.id}@${spec.model.version} does not match the scenario model ${scenario.model.id}@${scenario.model.version}`);
+    }
+    const scenarioStrategy = scenario.strategy;
+    if (spec.strategy && scenarioStrategy && scenarioStrategy.id !== spec.strategy.id) {
+        reject(`strategy ${spec.strategy.id} does not match the scenario strategy ${scenarioStrategy.id}`);
+    }
+    const strategyId = spec.strategy?.id ?? scenarioStrategy?.id ?? null;
+    // An empty id is falsy, so the run plan would build no strategy while the task names one.
+    if (strategyId === "")
+        reject("strategy id must not be empty");
+    if (strategyId === null) {
+        if (spec.dimensions.some((dimension) => dimension.target === "strategy"))
+            reject("strategy id is required");
+        return { modelParams: scenario.model.params, strategyId: null, strategyParams: {} };
+    }
+    const strategyFactory = registries.strategyRegistry.get(strategyId);
+    if (!strategyFactory)
+        reject(`strategy not found: ${strategyId}`);
+    const strategyParams = scenarioStrategy?.params ?? strategyFactory.defaultParams ?? {};
+    // Factory defaults are checked on their own: they are not part of the scenario object.
+    if (scenarioStrategy?.params === undefined)
+        requireJsonParams(strategyParams, "strategy", new Set());
+    return { modelParams: scenario.model.params, strategyId, strategyParams };
+}
+function prepareCandidate(spec, base, candidate, registries) {
+    const dimensions = new Map(spec.dimensions.map((dimension) => [dimension.id, dimension]));
+    const modelAssigned = [];
+    const strategyAssigned = [];
+    const applied = new Set();
+    for (const assignment of candidate.assignments) {
+        const dimension = dimensions.get(assignment.dimensionId);
+        if (!dimension)
+            reject(`unknown dimension ${assignment.dimensionId}`);
+        if (applied.has(dimension.id))
+            reject(`duplicate assignment ${dimension.id}`);
+        applied.add(dimension.id);
+        assertRegisteredPath(dimension.path, dimension.target);
+        if (!assignmentFitsParamSpace(dimension.space, assignment.value)) {
+            reject(`value for ${dimension.id} is outside its parameter space`);
+        }
+        if (dimension.target === "model")
+            modelAssigned.push({ dimension, value: assignment.value });
+        else if (dimension.target === "strategy")
+            strategyAssigned.push({ dimension, value: assignment.value });
+        else
+            reject(`session dimension ${dimension.id} is not executed`);
+    }
+    for (const dimension of spec.dimensions) {
+        if (!applied.has(dimension.id))
+            reject(`candidate ${candidate.id} omits ${dimension.id}`);
+    }
+    // Assignments apply in dimension id order, the order behind the effective spec hash, so a factory sees one key order.
+    const assign = (params, assigned, label) => assigned.length === 0
+        ? params
+        : [...assigned].sort((left, right) => byText(left.dimension.id, right.dimension.id)).reduce((acc, { dimension, value }) => setRegisteredParam(acc, dimension.path, value), 
+        // setRegisteredParam copies the root with its prototype, so the scenario object is not spread here.
+        asParamRecord(params, label));
+    const modelFactory = registries.modelRegistry.get(spec.model.id, spec.model.version);
+    if (!modelFactory)
+        reject(`model not found: ${spec.model.id}@${spec.model.version}`);
+    const modelParams = assign(base.modelParams, modelAssigned, "model");
+    checkCandidateParams(modelFactory.paramsSchema, base.modelParams, modelParams, modelAssigned, "model");
+    let strategyParams = {};
+    if (base.strategyId !== null) {
+        const strategyFactory = registries.strategyRegistry.get(base.strategyId);
+        if (!strategyFactory)
+            reject(`strategy not found: ${base.strategyId}`);
+        strategyParams = assign(base.strategyParams, strategyAssigned, "strategy");
+        checkCandidateParams(strategyFactory.paramsSchema, base.strategyParams, strategyParams, strategyAssigned, "strategy");
+    }
+    // Private snapshots: the task records exactly these, and every run gets its own copy of them.
+    return {
+        id: candidate.id,
+        modelParams: cloneJsonData(modelParams),
+        strategyParams: cloneJsonData(strategyParams),
+        sessionPattern: spec.session.pattern,
+        sessionDays: spec.session.days,
+    };
+}
+function metricIds(spec) {
+    const ids = new Set([spec.metricId]);
+    for (const objective of spec.objectives ?? [])
+        ids.add(objective.metricId);
+    for (const constraint of spec.constraints ?? [])
+        ids.add(constraint.metricId);
+    return [...ids];
+}
+function readBenefit(vars) {
+    if (vars === null || typeof vars !== "object")
+        return null;
+    const value = vars.benefit;
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+/** Metrics at the horizon. The reach time is the first committed state at or above the target, read on the way. */
+function observeMetrics(E, spec, end, startT, reachedAt, 
+/** The runner elapsed clock. A censored reach time is later than it. */
+elapsedSec) {
+    const amount = end.wallet.money.amount;
+    const benefit = readBenefit(end.vars);
+    return metricIds(spec).map((metricId) => {
+        if (metricId === "timeToMoney") {
+            if (reachedAt === undefined) {
+                return { metricId, status: "censored", value: null, lowerBound: { sec: elapsedSec, strict: true } };
+            }
+            const elapsed = reachedAt - startT;
+            return { metricId, status: "observed", value: String(elapsed), num: elapsed };
+        }
+        if (metricId === "endMoney") {
+            if (!E.isFinite(amount))
+                return { metricId, status: "censored", value: null };
+            return { metricId, status: "observed", value: E.toString(amount), amount };
+        }
+        if (benefit === null)
+            return { metricId, status: "censored", value: null };
+        return { metricId, status: "observed", value: String(benefit), num: benefit };
+    });
+}
+function failedMetrics(spec) {
+    return metricIds(spec).map((metricId) => ({ metricId, status: "failed", value: null }));
+}
+/**
+ * Arithmetic mean over every seed. One failed seed fails the candidate metric and one censored seed censors it,
+ * so a mean never mixes a missing draw with observed ones. Money is averaged in the engine.
+ */
+function aggregate(E, rows, metricId) {
+    const picked = rows.map((row) => row.metrics.find((metric) => metric.metricId === metricId));
+    if (picked.some((metric) => metric === undefined || metric.status === "failed")) {
+        return { metricId, status: "failed", value: null };
+    }
+    if (picked.some((metric) => metric.status !== "observed" || metric.value === null)) {
+        // Every seed is either observed or censored with a known lower bound, so the mean has a lower bound too.
+        const bounded = picked.every((metric) => metric.num !== undefined || metric.lowerBound !== undefined);
+        if (metricId !== "timeToMoney" || !bounded)
+            return { metricId, status: "censored", value: null };
+        const bounds = picked.map((metric) => metric.num ?? metric.lowerBound.sec);
+        const total = bounds.reduce((sum, bound) => sum + bound, 0);
+        const sec = Number.isFinite(total) ? total / bounds.length : scaledMean(bounds);
+        const strict = picked.some((metric) => metric.lowerBound?.strict === true);
+        return { metricId, status: "censored", value: null, lowerBound: { sec, strict } };
+    }
+    const observed = picked;
+    const count = observed.length;
+    if (metricId === "endMoney") {
+        // Sum, then divide, so subnormal amounts keep their mean. Only when the sum leaves the engine range,
+        // divide before adding, so large finite amounts keep a finite mean.
+        const sum = observed.reduce((total, metric) => E.add(total, metric.amount), E.zero());
+        const mean = E.isFinite(sum) ? E.div(sum, count) : scaledEngineMean(E, observed.map((metric) => metric.amount));
+        if (!E.isFinite(mean))
+            return { metricId, status: "censored", value: null };
+        return { metricId, status: "observed", value: E.toString(mean), amount: mean };
+    }
+    // Sum, then divide, so subnormal values keep their mean. Only when the sum overflows, divide before adding,
+    // so two finite values near the double limit keep a finite mean.
+    const values = observed.map((metric) => metric.num);
+    const sum = values.reduce((total, value) => total + value, 0);
+    const mean = Number.isFinite(sum) ? sum / count : scaledMean(values);
+    if (!Number.isFinite(mean))
+        return { metricId, status: "censored", value: null };
+    return { metricId, status: "observed", value: String(mean), num: mean };
+}
+/**
+ * Mean of finite values whose sum overflows. Each value is divided by the largest magnitude, so every scaled
+ * term is at most 1 and the scaled sum stays finite. The mean of the scaled terms is then scaled back.
+ */
+function scaledMean(values) {
+    const scale = values.reduce((largest, value) => Math.max(largest, Math.abs(value)), 0);
+    return scale * (values.reduce((total, value) => total + value / scale, 0) / values.length);
+}
+function scaledEngineMean(E, values) {
+    const scale = values.reduce((largest, value) => (E.absLog10(value) > E.absLog10(largest) ? value : largest), values[0]);
+    const magnitude = E.cmp(scale, E.zero()) < 0 ? E.sub(E.zero(), scale) : scale;
+    const scaled = values.reduce((total, value) => E.add(total, E.divN(value, magnitude)), E.zero());
+    return E.mulN(magnitude, E.div(scaled, values.length));
+}
+function isObserved(reading) {
+    return reading !== undefined && reading.status === "observed" && (reading.amount !== undefined || reading.num !== undefined);
+}
+function compareReadings(E, left, right) {
+    if (left.amount !== undefined && right.amount !== undefined)
+        return E.cmp(left.amount, right.amount);
+    const a = left.num;
+    const b = right.num;
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+function violates(E, reading, constraint) {
+    const order = reading.amount !== undefined
+        ? E.cmp(reading.amount, E.from(constraint.limit))
+        : reading.num < constraint.limit ? -1 : reading.num > constraint.limit ? 1 : 0;
+    return constraint.op === "lte" ? order > 0 : order < 0;
+}
+function readingElasticity(E, baselineP, probeP, baseline, probe) {
+    if (!isObserved(baseline) || !isObserved(probe))
+        return localElasticity({ baselineP, probeP, baselineY: null, probeY: null });
+    if (baseline.amount !== undefined && probe.amount !== undefined) {
+        const delta = E.sub(probe.amount, baseline.amount);
+        // Two finite amounts of opposite sign can differ by more than the engine range. Their ratio stays finite.
+        const finiteDelta = E.isFinite(delta);
+        const order = E.cmp(probe.amount, baseline.amount);
+        const unavailable = elasticityFromChange({
+            baselineP,
+            probeP,
+            absoluteChange: finiteDelta ? E.toString(delta) : null,
+            direction: order > 0 ? "higher" : order < 0 ? "lower" : "flat",
+            relativeChange: null,
+        });
+        const pChanged = Number.isFinite(baselineP) && Number.isFinite(probeP) && probeP !== baselineP;
+        if (!(E.cmp(baseline.amount, E.zero()) > 0) || !(baselineP > 0) || !pChanged)
+            return unavailable;
+        // The ratio of two engine amounts can leave the double range, so the elasticity stays in the engine until it is text.
+        const relative = finiteDelta ? E.divN(delta, baseline.amount) : E.sub(E.divN(probe.amount, baseline.amount), E.from(1));
+        // A tiny positive baseline can make the parameter change overflow. Dividing by it would report a false 0.
+        const parameterChange = relativeParameterChange(baselineP, probeP);
+        if (!Number.isFinite(parameterChange) || parameterChange === 0)
+            return unavailable;
+        const elasticity = E.div(relative, parameterChange);
+        if (!E.isFinite(elasticity))
+            return unavailable;
+        return { ...unavailable, status: "observed", elasticity: E.toString(elasticity) };
+    }
+    return localElasticity({ baselineP, probeP, baselineY: baseline.num ?? null, probeY: probe.num ?? null });
+}
+/**
+ * Run options every candidate inherits from the compiled scenario.
+ * A scenario stop condition or step budget would end a candidate before the spec horizon, and a report trace
+ * would keep every state of every candidate and seed while the experiment reads only the end state.
+ *
+ * @evidence docs/requirements/active/parameter-experiments.md#req-pr14-censored-horizon Removes the scenario stop condition, step budget, and trace, so each candidate runs to the horizon without retaining states.
+ * @evidenceReview docs/requirements/active/parameter-experiments.md#req-pr14-censored-horizon #befcebb Re-read the section: until, maxSteps, and trace are removed and the rest of the run options stay.
+ */
+export function experimentRunBase(run) {
+    const { until: _until, maxSteps: _maxSteps, trace: _trace, ...horizonRun } = run;
+    return horizonRun;
+}
+/** Every rejection that does not need a model instance. No factory `create` runs here. */
+function prepareExperiment(request) {
+    // Validate the spec shape and the execution state first, so an untyped caller gets ExperimentRejected
+    // rather than a TypeError from hashing, for example on a bigint.
+    const spec = requireSpec(request.spec);
+    const metrics = metricIds(spec);
+    // A JSON literal such as 1e400 parses to Infinity, and canonical JSON would hash it as null.
+    if (spec.goal !== undefined && !Number.isFinite(spec.goal.target))
+        reject("goal target must be finite");
+    if (metrics.includes("timeToMoney") && spec.goal === undefined)
+        reject("timeToMoney requires a finite goal target");
+    // Every spec field the run reads must be one both spec hashes record.
+    if (!isJsonData(request.spec, new Set(), true))
+        reject("spec must be JSON data, because the spec hashes record it as JSON");
+    requireScenarioData(request.scenario);
+    let scenarioHash;
+    try {
+        scenarioHash = sha256Text(canonicalJson(request.scenario));
+    }
+    catch {
+        reject("scenario cannot be written as canonical JSON");
+    }
+    if (scenarioHash !== spec.scenario.hash)
+        reject("scenario hash does not match the experiment spec");
+    // Both spec hashes are taken now, so a field canonical JSON cannot write fails before any model is created.
+    let specHashes;
+    try {
+        specHashes = { original: sha256Text(canonicalJson(request.spec)), effective: sha256Text(canonicalJson(normalizeSpec(spec))) };
+    }
+    catch {
+        reject("spec cannot be written as canonical JSON");
+    }
+    const base = candidateBase(spec, request.scenario, request);
+    const prepared = plannedCandidates(spec).map((candidate) => prepareCandidate(spec, base, candidate, request));
+    return { spec, metrics, base, prepared, specHashes };
+}
+/**
+ * Runs every spec, scenario-hash, path, and parameter check of `runExperiment` without creating a model.
+ * A caller that compiles or opens a run first calls this, so a rejected spec never reaches a factory.
+ *
+ * @evidence docs/requirements/active/parameter-experiments.md#req-pr14-registered-setter Throws the same rejections as runExperiment before any model create.
+ * @evidenceReview docs/requirements/active/parameter-experiments.md#req-pr14-registered-setter #847f7d0 Re-read the section: the hash, spec, path, and schema checks run and no factory create is called.
+ */
+export function checkExperimentSpec(request) {
+    prepareExperiment(request);
+}
+export function runExperiment(request) {
+    const { spec, metrics, base, prepared, specHashes } = prepareExperiment(request);
+    const measuresReach = metrics.includes("timeToMoney");
+    const E = request.engine;
+    // The plan builds the strategy, so compile does not build the scenario one.
+    const { strategy: _scenarioStrategy, ...withoutStrategy } = request.scenario;
+    // Compile reads copies, so its model create cannot write the caller's params or initial state.
+    const compiled = compileScenario({
+        E,
+        scenario: {
+            ...withoutStrategy,
+            model: { ...withoutStrategy.model, params: cloneJsonData(withoutStrategy.model.params) },
+            initial: cloneJsonData(withoutStrategy.initial),
+        },
+        registry: request.modelRegistry,
+        strategyRegistry: request.strategyRegistry,
+        opts: { allowSuffixNotation: true },
+    });
+    const shared = { ...compiled, run: experimentRunBase(compiled.run) };
+    const bindingFor = createRunFactory({
+        models: request.modelRegistry,
+        strategies: request.strategyRegistry,
+    });
+    const target = measuresReach && spec.goal !== undefined ? E.from(spec.goal.target) : undefined;
+    // Stopping at the goal is safe only when no other metric reads the horizon state.
+    const stopAtReach = metrics.every((metricId) => metricId === "timeToMoney");
+    const tasks = [];
+    const perCandidate = [];
+    for (const candidate of prepared) {
+        const rows = [];
+        for (const seed of spec.seeds) {
+            // Each seed binds its own copy of the params, so a factory that mutates them cannot change a later seed.
+            const binding = bindingFor.bind(shared, {
+                statefulModel: true,
+                model: { id: spec.model.id, version: spec.model.version, params: cloneJsonData(candidate.modelParams) },
+            });
+            const taskId = `${candidate.id}#${seed}`;
+            const plan = {
+                contract: "idlekit.execution-plan",
+                version: 1,
+                stepSec: spec.stepSec,
+                durationSec: spec.horizonSec,
+                seed,
+                ...(base.strategyId !== null ? { strategyId: base.strategyId, strategyParams: cloneJsonData(candidate.strategyParams) } : {}),
+                eventLog: { enabled: false, maxEvents: 0 },
+            };
+            let readings;
+            try {
+                const opened = binding.fresh({ trialId: taskId, seed, plan });
+                const scenario = opened.scenario;
+                let reachedAt;
+                const result = runScenario({
+                    ...scenario,
+                    run: {
+                        ...scenario.run,
+                        ...(target !== undefined
+                            ? {
+                                until: (state) => {
+                                    if (reachedAt === undefined && E.cmp(state.wallet.money.amount, target) >= 0)
+                                        reachedAt = state.t;
+                                    return stopAtReach && reachedAt !== undefined;
+                                },
+                            }
+                            : {}),
+                    },
+                });
+                readings = observeMetrics(E, spec, result.end, result.start.t, reachedAt, runElapsedSec(result));
+            }
+            catch {
+                readings = failedMetrics(spec);
+            }
+            const primary = readings.find((metric) => metric.metricId === spec.metricId) ?? failedMetrics(spec)[0];
+            tasks.push({
+                taskId,
+                candidateId: candidate.id,
+                logicalSeed: seed,
+                engineId: request.engineId,
+                engineVersion: request.engineVersion,
+                modelId: spec.model.id,
+                modelVersion: spec.model.version,
+                strategyId: base.strategyId,
+                modelParams: canonicalJson(candidate.modelParams ?? null),
+                strategyParams: canonicalJson(candidate.strategyParams ?? null),
+                sessionPattern: candidate.sessionPattern,
+                sessionDays: candidate.sessionDays,
+                horizonSec: spec.horizonSec,
+                stepSec: spec.stepSec,
+                metricId: spec.metricId,
+                status: primary.status,
+                value: primary.value,
+            });
+            rows.push({ seed, metrics: readings });
+        }
+        perCandidate.push({ id: candidate.id, rows });
+    }
+    const measured = perCandidate.map((candidate) => {
+        const readings = metrics.map((metricId) => aggregate(E, candidate.rows, metricId));
+        const constraintViolations = (spec.constraints ?? [])
+            .filter((constraint) => {
+            const reading = readings.find((metric) => metric.metricId === constraint.metricId);
+            // A censored reach time is later than its lower bound. That proves an lte violation once the bound passes the limit.
+            const bound = reading !== undefined && reading.status === "censored" ? reading.lowerBound : undefined;
+            if (isObserved(reading))
+                return violates(E, reading, constraint);
+            return constraint.op === "lte" && bound !== undefined && (bound.sec > constraint.limit || (bound.strict && bound.sec >= constraint.limit));
+        })
+            .map((constraint) => constraint.id);
+        return { id: candidate.id, readings, constraintViolations };
+    });
+    const baseline = measured.find((candidate) => candidate.id === "baseline");
+    const elasticities = baseline
+        ? // The normalized order, so reordered dimensions with one effective hash give one artifact.
+            [...spec.dimensions].sort((left, right) => byText(left.id, right.id)).flatMap((dimension) => (dimension.probes ?? []).flatMap((probe) => {
+                const candidateId = probeCandidateId(dimension, probe);
+                const probeCandidate = measured.find((candidate) => candidate.id === candidateId);
+                if (!probeCandidate)
+                    return [];
+                return metrics.map((metricId) => {
+                    const local = readingElasticity(E, typeof dimension.baseline === "number" ? dimension.baseline : Number.NaN, typeof probe === "number" ? probe : Number.NaN, baseline.readings.find((metric) => metric.metricId === metricId), probeCandidate.readings.find((metric) => metric.metricId === metricId));
+                    return {
+                        dimensionId: dimension.id,
+                        candidateId,
+                        metricId,
+                        method: "one-at-a-time-local",
+                        methodVersion: 1,
+                        globalSensitivity: false,
+                        sobol: false,
+                        status: local.status,
+                        elasticity: local.elasticity,
+                        absoluteChange: local.absoluteChange,
+                        direction: local.direction,
+                    };
+                });
+            }))
+        : [];
+    const objectives = spec.objectives ?? [];
+    // Each pair of candidates is compared in the engine. Ranks would chain the engine tolerance through a third value.
+    const pareto = objectives.length === 0
+        ? { sense: "per-metric", nonDominated: [], uncompared: [] }
+        : paretoFrontBy(measured.map((candidate) => ({
+            id: candidate.id,
+            objectives: objectives.map((objective) => {
+                const reading = candidate.readings.find((metric) => metric.metricId === objective.metricId);
+                return { sense: objective.sense, value: isObserved(reading) ? reading : null };
+            }),
+        })), (left, right) => compareReadings(E, left, right));
+    const candidates = measured.map((candidate) => ({
+        id: candidate.id,
+        metrics: candidate.readings.map(({ metricId, status, value }) => ({ metricId, status, value })),
+        constraintViolations: candidate.constraintViolations,
+    }));
+    tasks.sort((left, right) => byText(left.candidateId, right.candidateId) || left.logicalSeed - right.logicalSeed);
+    const artifact = {
+        schemaVersion: 1,
+        contract: "idlekit.experiment.v1",
+        estimatorVersion: EXPERIMENT_ESTIMATOR_VERSION,
+        algorithmVersion: EXPERIMENT_ALGORITHM_VERSION,
+        method: EXPERIMENT_METHOD,
+        globalSensitivity: false,
+        sobol: false,
+        scenario: spec.scenario,
+        originalSpecHash: specHashes.original,
+        effectiveSpecHash: specHashes.effective,
+        effectiveRunHash: request.effectiveRunHash,
+        budget: {
+            candidates: spec.budget.candidates,
+            seeds: spec.budget.seeds,
+            usedCandidates: prepared.length,
+            usedSeeds: spec.seeds.length,
+        },
+        tasks,
+        candidates: [...candidates].sort((left, right) => byText(left.id, right.id)),
+        elasticities,
+        pareto,
+        warnings: WARNINGS,
+    };
+    const checked = validateExperimentArtifact(artifact);
+    if (!checked.success)
+        reject("artifact failed its own structural validator");
+    return artifact;
+}
+//# sourceMappingURL=experiment.js.map