@idlekit/core 0.2.0 → 0.3.0

package/dist/sim/analysis/resetOptimization.js

@@ -0,0 +1,2187 @@
+import * as _validateReport_1 from "typia/lib/internal/_validateReport";
+import * as _createStandardSchema_1 from "typia/lib/internal/_createStandardSchema";
+import typia, {} from "typia";
+import { recordPrestigeReset } from "../constraints";
+import { shareObservation } from "../goalRead";
+import { emitActionFacts, emitCommittedResets } from "../observation";
+import { offlineAbsenceForCredit } from "../offlineCredit";
+import { applyOfflineSeconds } from "../offline";
+import { sessionActiveBlocks } from "../session";
+import { runScenario } from "../simulator";
+import { applyDecisions } from "../step";
+import { runElapsedSec, } from "../types";
+import { executeResetCycles, resetAdapterFor, } from "./resetCycle";
+import { withoutResetActions } from "./resetActions";
+import { deepClonePreservingPrototype } from "../../utils/deepClone";
+/**
+ * Reset policy comparison v1.
+ * `analyzePrestigeCycle` stays the legacy interval scan.
+ * This artifact does not copy `breakEvenSec` or `stability`.
+ */
+const RESET_POLICY_ALGORITHM_VERSION = "reset-policy-v1";
+const RESET_POLICY_SCHEMA_ID = "https://idlekit.dev/schemas/reset.policy.v1.schema.json";
+const MAX_CANDIDATES = 10000;
+/** The runner treats a duration at or below this as already complete, as `executeResetCycles` rejects it. */
+const RUNNER_MIN_DURATION_SEC = 1e-12;
+/** Rounding slack in ULPs of the magnitudes involved, as `executeResetCycles` admits an interval at the horizon. */
+const HORIZON_ULPS = 64;
+/** Rounding dust of a wall or elapsed sum near the horizon: a few ULPs, never a share of the horizon. */
+function horizonDust(horizonSec, reached) {
+    return HORIZON_ULPS * Number.EPSILON * Math.max(Math.abs(horizonSec), Math.abs(reached));
+}
+/**
+ * @evidence docs/requirements/active/reset-cycle-analysis.md#req-pr11-reward-rate Realized reward is the committed deltas. The rate uses completed cycle time.
+ * @evidenceReview docs/requirements/active/reset-cycle-analysis.md#req-pr11-reward-rate #9ef48a3 Re-read the section: opening points stay out of the delta, and the 5 second tail is not realized reward.
+ */
+export const resetPolicyRewardRate = "completed-cycle-time-denominator";
+/**
+ * @evidence docs/requirements/active/reset-cycle-analysis.md#req-pr11-empirical-stability Stable requires the requested windows and both tolerances. A cycle count is not enough.
+ * @evidenceReview docs/requirements/active/reset-cycle-analysis.md#req-pr11-empirical-stability #3acf06e Re-read the section: a rising multiplier is drifting, an alternating reward is oscillating, and two cycles stay insufficient.
+ */
+export const resetPolicyEmpiricalStability = "window-tolerance-not-cycle-count";
+/**
+ * @evidence docs/requirements/active/reset-cycle-analysis.md#req-pr11-recovery-crossing Recovery time is the threshold crossing. A miss inside the horizon is censored.
+ * @evidenceReview docs/requirements/active/reset-cycle-analysis.md#req-pr11-recovery-crossing #28b60db Re-read the section: the climb crosses at 25 seconds, and the short horizon does not substitute min(interval, horizon).
+ */
+export const resetPolicyRecoveryCrossing = "threshold-crossing-or-censored";
+/**
+ * @evidence docs/requirements/active/reset-cycle-analysis.md#req-pr11-session-reset A manual reset is committed only inside an active session block.
+ * @evidenceReview docs/requirements/active/reset-cycle-analysis.md#req-pr11-session-reset #0ea6f15 Re-read the section: wall 2000 is not a reset, and the caller delay moves the later morning resets.
+ */
+export const resetPolicySessionReset = "manual-reset-only-while-active";
+/**
+ * @evidence docs/requirements/active/reset-cycle-analysis.md#req-pr11-scan-rank Candidates are ranked with Engine.cmp inside the scanned range only.
+ * @evidenceReview docs/requirements/active/reset-cycle-analysis.md#req-pr11-scan-rank #468d46d Re-read the section: infinite toNumber values still rank the larger reward, and a missed goal stays null.
+ */
+export const resetPolicyScanRank = "engine-compare-scan-range";
+export function resetPolicySchemaId() {
+    return RESET_POLICY_SCHEMA_ID;
+}
+export function resetPolicyAlgorithmVersion() {
+    return RESET_POLICY_ALGORITHM_VERSION;
+}
+export class ResetPolicyRejected extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ResetPolicyRejected";
+    }
+}
+/*
+ * 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 validateResetPolicyArtifactValidator;
+/**
+ * @evidence docs/requirements/active/reset-cycle-analysis.md#req-pr11-scan-rank The generated validator accepts this artifact and rejects a missing scope.
+ * @evidenceReview docs/requirements/active/reset-cycle-analysis.md#req-pr11-scan-rank #468d46d Re-read the section: the wire object is reset policy v1 and globalOptimum stays false.
+ */
+export const validateResetPolicyArtifact = (input) => (validateResetPolicyArtifactValidator ??= (() => {
+    const _ip0 = input => "scan-range" === input["scope"];
+    const _ip1 = input => false === input["globalOptimum"];
+    const _ip2 = input => "number" === typeof input["intervalSec"];
+    const _ip3 = input => "number" === typeof input["horizonSec"];
+    const _ip4 = input => "drifting" === input["status"] || "insufficient-data" === input["status"] || "non-stationary" === input["status"] || "oscillating" === input["status"] || "stable" === input["status"];
+    const _ip5 = input => false === input["provedSteadyState"];
+    const _ip6 = input => "censored" === input["status"] || "incomplete" === input["status"] || "ok" === input["status"] || "unsupported" === input["status"];
+    const _ip7 = input => "number" === typeof input["completedCycles"];
+    const _ip8 = input => "string" === typeof input["realizedReward"];
+    const _ip9 = input => "string" === typeof input["unrealizedReward"];
+    const _ip10 = input => "string" === typeof input["finalPoints"];
+    const _ip11 = input => "string" === typeof input["finalNetWorth"];
+    const _ip12 = input => null === input["rewardRate"] || "string" === typeof input["rewardRate"];
+    const _ip13 = input => "completed-cycle-time" === input["rewardRateDenominator"];
+    const _ip14 = input => null === input["incomplete"] || "object" === typeof input["incomplete"] && null !== input["incomplete"] && _io7(input["incomplete"]);
+    const _ip15 = input => null === input["goalReachSec"] || "number" === typeof input["goalReachSec"];
+    const _ip16 = input => "censored" === input["goalStatus"] || "not-requested" === input["goalStatus"] || "observed" === input["goalStatus"];
+    const _ip17 = input => "object" === typeof input["recovery"] && null !== input["recovery"] && _io8(input["recovery"]);
+    const _ip18 = input => "object" === typeof input["stability"] && null !== input["stability"] && _io9(input["stability"]);
+    const _ip19 = input => "string" === typeof input["objectiveValue"];
+    const _ip20 = input => "flow" === input["objectiveReading"] || "stock" === input["objectiveReading"] || "time" === input["objectiveReading"];
+    const _ip21 = input => Array.isArray(input["resetWallTimes"]) && input["resetWallTimes"].every(elem => "number" === typeof elem);
+    const _ve0 = "Readonly<{ schemaVersion: 1; algorithmVersion: \"reset-policy-v1\"; status: \"censored\" | \"incomplete\" | \"insufficient-data\" | \"ok\" | \"unsupported\"; objective: ResetObjectiveKind; ... 6 more ...; warnings: readonly string[]; }>";
+    const _vp0 = (input, _path, _exceptionable = true) => "scan-range" === input["scope"] || _report(_exceptionable, {
+        path: _path + ".scope",
+        expected: "\"scan-range\"",
+        value: input["scope"]
+    });
+    const _vp1 = (input, _path, _exceptionable = true) => false === input["globalOptimum"] || _report(_exceptionable, {
+        path: _path + ".globalOptimum",
+        expected: "false",
+        value: input["globalOptimum"]
+    });
+    const _ve1 = "Readonly<{ intervalSec: number; objective: Readonly<{ kind: ResetObjectiveKind; reading: ObjectiveReading; value: string; }>; comparison: Readonly<{ ...; }>; session: Readonly<...>; observation: Readonly<...>; }>";
+    const _ve2 = "Readonly<{ intervalSec: number; status: \"censored\" | \"incomplete\" | \"ok\" | \"unsupported\"; completedCycles: number; realizedReward: string; unrealizedReward: string; finalPoints: string; finalNetWorth: string; ... 9 more ...; resetWallTimes: readonly number[]; }>";
+    const _ve3 = "ReadonlyArray<Readonly<{ intervalSec: number; status: \"censored\" | \"incomplete\" | \"ok\" | \"unsupported\"; completedCycles: number; realizedReward: string; unrealizedReward: string; finalPoints: string; finalNetWorth: string; ... 9 more ...; resetWallTimes: readonly number[]; }>>";
+    const _vp2 = (input, _path, _exceptionable = true) => "number" === typeof input["intervalSec"] || _report(_exceptionable, {
+        path: _path + ".intervalSec",
+        expected: "number",
+        value: input["intervalSec"]
+    });
+    const _ve4 = "Readonly<{ fromSec: number; toSec: number; stepSec: number; horizonSec: number; candidateCount: number; scope: \"scan-range\"; globalOptimum: false; }>";
+    const _ve5 = "Readonly<{ status: EmpiricalStability; stability: EmpiricalStability; provedSteadyState: false; recovery: \"censored\" | \"observed\" | \"unsupported\"; }>";
+    const _vp3 = (input, _path, _exceptionable = true) => "number" === typeof input["horizonSec"] || _report(_exceptionable, {
+        path: _path + ".horizonSec",
+        expected: "number",
+        value: input["horizonSec"]
+    });
+    const _vp4 = (input, _path, _exceptionable = true) => "drifting" === input["status"] || "insufficient-data" === input["status"] || "non-stationary" === input["status"] || "oscillating" === input["status"] || "stable" === input["status"] || _report(_exceptionable, {
+        path: _path + ".status",
+        expected: "(\"drifting\" | \"insufficient-data\" | \"non-stationary\" | \"oscillating\" | \"stable\")",
+        value: input["status"]
+    });
+    const _vp5 = (input, _path, _exceptionable = true) => false === input["provedSteadyState"] || _report(_exceptionable, {
+        path: _path + ".provedSteadyState",
+        expected: "false",
+        value: input["provedSteadyState"]
+    });
+    const _vp6 = (input, _path, _exceptionable = true) => "censored" === input["status"] || "incomplete" === input["status"] || "ok" === input["status"] || "unsupported" === input["status"] || _report(_exceptionable, {
+        path: _path + ".status",
+        expected: "(\"censored\" | \"incomplete\" | \"ok\" | \"unsupported\")",
+        value: input["status"]
+    });
+    const _vp7 = (input, _path, _exceptionable = true) => "number" === typeof input["completedCycles"] || _report(_exceptionable, {
+        path: _path + ".completedCycles",
+        expected: "number",
+        value: input["completedCycles"]
+    });
+    const _vp8 = (input, _path, _exceptionable = true) => "string" === typeof input["realizedReward"] || _report(_exceptionable, {
+        path: _path + ".realizedReward",
+        expected: "string",
+        value: input["realizedReward"]
+    });
+    const _vp9 = (input, _path, _exceptionable = true) => "string" === typeof input["unrealizedReward"] || _report(_exceptionable, {
+        path: _path + ".unrealizedReward",
+        expected: "string",
+        value: input["unrealizedReward"]
+    });
+    const _vp10 = (input, _path, _exceptionable = true) => "string" === typeof input["finalPoints"] || _report(_exceptionable, {
+        path: _path + ".finalPoints",
+        expected: "string",
+        value: input["finalPoints"]
+    });
+    const _vp11 = (input, _path, _exceptionable = true) => "string" === typeof input["finalNetWorth"] || _report(_exceptionable, {
+        path: _path + ".finalNetWorth",
+        expected: "string",
+        value: input["finalNetWorth"]
+    });
+    const _vp12 = (input, _path, _exceptionable = true) => null === input["rewardRate"] || "string" === typeof input["rewardRate"] || _report(_exceptionable, {
+        path: _path + ".rewardRate",
+        expected: "(null | string)",
+        value: input["rewardRate"]
+    });
+    const _vp13 = (input, _path, _exceptionable = true) => "completed-cycle-time" === input["rewardRateDenominator"] || _report(_exceptionable, {
+        path: _path + ".rewardRateDenominator",
+        expected: "\"completed-cycle-time\"",
+        value: input["rewardRateDenominator"]
+    });
+    const _vp14 = (input, _path, _exceptionable = true) => null === input["incomplete"] || ("object" === typeof input["incomplete"] && null !== input["incomplete"] || _report(_exceptionable, {
+        path: _path + ".incomplete",
+        expected: "(Readonly<{ startSec: number; endSec: number; durationSec: number; }> | null)",
+        value: input["incomplete"]
+    })) && _vo7(input["incomplete"], _path + ".incomplete", true && _exceptionable) || _report(_exceptionable, {
+        path: _path + ".incomplete",
+        expected: "(Readonly<{ startSec: number; endSec: number; durationSec: number; }> | null)",
+        value: input["incomplete"]
+    });
+    const _vp15 = (input, _path, _exceptionable = true) => null === input["goalReachSec"] || "number" === typeof input["goalReachSec"] || _report(_exceptionable, {
+        path: _path + ".goalReachSec",
+        expected: "(null | number)",
+        value: input["goalReachSec"]
+    });
+    const _vp16 = (input, _path, _exceptionable = true) => "censored" === input["goalStatus"] || "not-requested" === input["goalStatus"] || "observed" === input["goalStatus"] || _report(_exceptionable, {
+        path: _path + ".goalStatus",
+        expected: "(\"censored\" | \"not-requested\" | \"observed\")",
+        value: input["goalStatus"]
+    });
+    const _vp17 = (input, _path, _exceptionable = true) => ("object" === typeof input["recovery"] && null !== input["recovery"] || _report(_exceptionable, {
+        path: _path + ".recovery",
+        expected: _ve6,
+        value: input["recovery"]
+    })) && _vo8(input["recovery"], _path + ".recovery", true && _exceptionable) || _report(_exceptionable, {
+        path: _path + ".recovery",
+        expected: _ve6,
+        value: input["recovery"]
+    });
+    const _ve6 = "Readonly<{ metric: RecoveryMetricKind; status: \"censored\" | \"observed\" | \"unsupported\"; seconds: number | null; threshold: string; }>";
+    const _vp18 = (input, _path, _exceptionable = true) => ("object" === typeof input["stability"] && null !== input["stability"] || _report(_exceptionable, {
+        path: _path + ".stability",
+        expected: _ve7,
+        value: input["stability"]
+    })) && _vo9(input["stability"], _path + ".stability", true && _exceptionable) || _report(_exceptionable, {
+        path: _path + ".stability",
+        expected: _ve7,
+        value: input["stability"]
+    });
+    const _ve7 = "Readonly<{ kind: \"empirical\"; provedSteadyState: false; status: EmpiricalStability; observedCycles: number; minObservedCycles: number; windows: readonly number[]; absoluteTolerance: string; relativeTolerance: number; horizonSec: number; }>";
+    const _vp19 = (input, _path, _exceptionable = true) => "string" === typeof input["objectiveValue"] || _report(_exceptionable, {
+        path: _path + ".objectiveValue",
+        expected: "string",
+        value: input["objectiveValue"]
+    });
+    const _vp20 = (input, _path, _exceptionable = true) => "flow" === input["objectiveReading"] || "stock" === input["objectiveReading"] || "time" === input["objectiveReading"] || _report(_exceptionable, {
+        path: _path + ".objectiveReading",
+        expected: "(\"flow\" | \"stock\" | \"time\")",
+        value: input["objectiveReading"]
+    });
+    const _vp21 = (input, _path, _exceptionable = true) => (Array.isArray(input["resetWallTimes"]) || _report(_exceptionable, {
+        path: _path + ".resetWallTimes",
+        expected: "ReadonlyArray<number>",
+        value: input["resetWallTimes"]
+    })) && input["resetWallTimes"].map((elem, _index9) => "number" === typeof elem || _report(_exceptionable, {
+        path: _path + ".resetWallTimes[" + _index9 + "]",
+        expected: "number",
+        value: elem
+    })).every(flag => flag) || _report(_exceptionable, {
+        path: _path + ".resetWallTimes",
+        expected: "ReadonlyArray<number>",
+        value: input["resetWallTimes"]
+    });
+    const _io0 = input => 1 === input.schemaVersion && "reset-policy-v1" === input.algorithmVersion && ("censored" === input.status || "incomplete" === input.status || "insufficient-data" === input.status || "ok" === input.status || "unsupported" === input.status) && ("cumulative-reset-reward" === input.objective || "final-net-worth" === input.objective || "goal-reach-sec" === input.objective) && _ip0(input) && _ip1(input) && ("object" === typeof input.best && null !== input.best && _io1(input.best)) && (Array.isArray(input.candidates) && input.candidates.every(elem => "object" === typeof elem && null !== elem && _io6(elem))) && (null === input.knownSolution || "object" === typeof input.knownSolution && null !== input.knownSolution && _io10(input.knownSolution)) && (Array.isArray(input.assumptions) && input.assumptions.every(elem => "string" === typeof elem)) && (Array.isArray(input.warnings) && input.warnings.every(elem => "string" === typeof elem));
+    const _io1 = input => _ip2(input) && ("object" === typeof input.objective && null !== input.objective && _io2(input.objective)) && ("object" === typeof input.comparison && null !== input.comparison && _io3(input.comparison)) && ("object" === typeof input.session && null !== input.session && _io4(input.session)) && ("object" === typeof input.observation && null !== input.observation && _io5(input.observation));
+    const _io10 = input => "string" === typeof input.fixtureId && "string" === typeof input.expectedRate && "string" === typeof input.observedRate && "boolean" === typeof input.matches;
+    const _io2 = input => ("cumulative-reset-reward" === input.kind || "final-net-worth" === input.kind || "goal-reach-sec" === input.kind) && ("flow" === input.reading || "stock" === input.reading || "time" === input.reading) && "string" === typeof input.value;
+    const _io3 = input => "number" === typeof input.fromSec && "number" === typeof input.toSec && "number" === typeof input.stepSec && _ip3(input) && "number" === typeof input.candidateCount && _ip0(input) && _ip1(input);
+    const _io4 = input => ("always-active" === input.assumed || "scheduled" === input.assumed) && (null === input.patternId || "string" === typeof input.patternId) && (null === input.resetDelaySec || "number" === typeof input.resetDelaySec);
+    const _io5 = input => _ip4(input) && ("drifting" === input.stability || "insufficient-data" === input.stability || "non-stationary" === input.stability || "oscillating" === input.stability || "stable" === input.stability) && _ip5(input) && ("censored" === input.recovery || "observed" === input.recovery || "unsupported" === input.recovery);
+    const _io6 = input => _ip2(input) && _ip6(input) && _ip7(input) && _ip8(input) && _ip9(input) && _ip10(input) && _ip11(input) && _ip12(input) && _ip13(input) && _ip14(input) && _ip15(input) && _ip16(input) && _ip17(input) && _ip18(input) && _ip19(input) && _ip20(input) && _ip21(input);
+    const _io7 = input => "number" === typeof input.startSec && "number" === typeof input.endSec && "number" === typeof input.durationSec;
+    const _io8 = input => ("pre-reset-income" === input.metric || "pre-reset-net-worth" === input.metric) && ("censored" === input.status || "observed" === input.status || "unsupported" === input.status) && (null === input.seconds || "number" === typeof input.seconds) && "string" === typeof input.threshold;
+    const _io9 = input => "empirical" === input.kind && _ip5(input) && _ip4(input) && "number" === typeof input.observedCycles && "number" === typeof input.minObservedCycles && (Array.isArray(input.windows) && input.windows.every(elem => "number" === typeof elem)) && "string" === typeof input.absoluteTolerance && "number" === typeof input.relativeTolerance && _ip3(input);
+    const _vo0 = (input, _path, _exceptionable = true) => [1 === input.schemaVersion || _report(_exceptionable, {
+            path: _path + ".schemaVersion",
+            expected: "1",
+            value: input.schemaVersion
+        }), "reset-policy-v1" === input.algorithmVersion || _report(_exceptionable, {
+            path: _path + ".algorithmVersion",
+            expected: "\"reset-policy-v1\"",
+            value: input.algorithmVersion
+        }), "censored" === input.status || "incomplete" === input.status || "insufficient-data" === input.status || "ok" === input.status || "unsupported" === input.status || _report(_exceptionable, {
+            path: _path + ".status",
+            expected: "(\"censored\" | \"incomplete\" | \"insufficient-data\" | \"ok\" | \"unsupported\")",
+            value: input.status
+        }), "cumulative-reset-reward" === input.objective || "final-net-worth" === input.objective || "goal-reach-sec" === input.objective || _report(_exceptionable, {
+            path: _path + ".objective",
+            expected: "(\"cumulative-reset-reward\" | \"final-net-worth\" | \"goal-reach-sec\")",
+            value: input.objective
+        }), _vp0(input, _path, true && _exceptionable), _vp1(input, _path, true && _exceptionable), ("object" === typeof input.best && null !== input.best || _report(_exceptionable, {
+            path: _path + ".best",
+            expected: _ve1,
+            value: input.best
+        })) && _vo1(input.best, _path + ".best", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".best",
+            expected: _ve1,
+            value: input.best
+        }), (Array.isArray(input.candidates) || _report(_exceptionable, {
+            path: _path + ".candidates",
+            expected: _ve3,
+            value: input.candidates
+        })) && input.candidates.map((elem, _index6) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+            path: _path + ".candidates[" + _index6 + "]",
+            expected: _ve2,
+            value: elem
+        })) && _vo6(elem, _path + ".candidates[" + _index6 + "]", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".candidates[" + _index6 + "]",
+            expected: _ve2,
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + ".candidates",
+            expected: _ve3,
+            value: input.candidates
+        }), null === input.knownSolution || ("object" === typeof input.knownSolution && null !== input.knownSolution || _report(_exceptionable, {
+            path: _path + ".knownSolution",
+            expected: "(Readonly<{ fixtureId: string; expectedRate: string; observedRate: string; matches: boolean; }> | null)",
+            value: input.knownSolution
+        })) && _vo10(input.knownSolution, _path + ".knownSolution", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".knownSolution",
+            expected: "(Readonly<{ fixtureId: string; expectedRate: string; observedRate: string; matches: boolean; }> | null)",
+            value: input.knownSolution
+        }), (Array.isArray(input.assumptions) || _report(_exceptionable, {
+            path: _path + ".assumptions",
+            expected: "ReadonlyArray<string>",
+            value: input.assumptions
+        })) && input.assumptions.map((elem, _index7) => "string" === typeof elem || _report(_exceptionable, {
+            path: _path + ".assumptions[" + _index7 + "]",
+            expected: "string",
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + ".assumptions",
+            expected: "ReadonlyArray<string>",
+            value: input.assumptions
+        }), (Array.isArray(input.warnings) || _report(_exceptionable, {
+            path: _path + ".warnings",
+            expected: "ReadonlyArray<string>",
+            value: input.warnings
+        })) && input.warnings.map((elem, _index8) => "string" === typeof elem || _report(_exceptionable, {
+            path: _path + ".warnings[" + _index8 + "]",
+            expected: "string",
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + ".warnings",
+            expected: "ReadonlyArray<string>",
+            value: input.warnings
+        })].every(flag => flag);
+    const _vo1 = (input, _path, _exceptionable = true) => [_vp2(input, _path, true && _exceptionable), ("object" === typeof input.objective && null !== input.objective || _report(_exceptionable, {
+            path: _path + ".objective",
+            expected: "Readonly<{ kind: ResetObjectiveKind; reading: ObjectiveReading; value: string; }>",
+            value: input.objective
+        })) && _vo2(input.objective, _path + ".objective", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".objective",
+            expected: "Readonly<{ kind: ResetObjectiveKind; reading: ObjectiveReading; value: string; }>",
+            value: input.objective
+        }), ("object" === typeof input.comparison && null !== input.comparison || _report(_exceptionable, {
+            path: _path + ".comparison",
+            expected: _ve4,
+            value: input.comparison
+        })) && _vo3(input.comparison, _path + ".comparison", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".comparison",
+            expected: _ve4,
+            value: input.comparison
+        }), ("object" === typeof input.session && null !== input.session || _report(_exceptionable, {
+            path: _path + ".session",
+            expected: "Readonly<{ assumed: \"always-active\" | \"scheduled\"; patternId: string | null; resetDelaySec: number | null; }>",
+            value: input.session
+        })) && _vo4(input.session, _path + ".session", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".session",
+            expected: "Readonly<{ assumed: \"always-active\" | \"scheduled\"; patternId: string | null; resetDelaySec: number | null; }>",
+            value: input.session
+        }), ("object" === typeof input.observation && null !== input.observation || _report(_exceptionable, {
+            path: _path + ".observation",
+            expected: _ve5,
+            value: input.observation
+        })) && _vo5(input.observation, _path + ".observation", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".observation",
+            expected: _ve5,
+            value: input.observation
+        })].every(flag => flag);
+    const _vo10 = (input, _path, _exceptionable = true) => ["string" === typeof input.fixtureId || _report(_exceptionable, {
+            path: _path + ".fixtureId",
+            expected: "string",
+            value: input.fixtureId
+        }), "string" === typeof input.expectedRate || _report(_exceptionable, {
+            path: _path + ".expectedRate",
+            expected: "string",
+            value: input.expectedRate
+        }), "string" === typeof input.observedRate || _report(_exceptionable, {
+            path: _path + ".observedRate",
+            expected: "string",
+            value: input.observedRate
+        }), "boolean" === typeof input.matches || _report(_exceptionable, {
+            path: _path + ".matches",
+            expected: "boolean",
+            value: input.matches
+        })].every(flag => flag);
+    const _vo2 = (input, _path, _exceptionable = true) => ["cumulative-reset-reward" === input.kind || "final-net-worth" === input.kind || "goal-reach-sec" === input.kind || _report(_exceptionable, {
+            path: _path + ".kind",
+            expected: "(\"cumulative-reset-reward\" | \"final-net-worth\" | \"goal-reach-sec\")",
+            value: input.kind
+        }), "flow" === input.reading || "stock" === input.reading || "time" === input.reading || _report(_exceptionable, {
+            path: _path + ".reading",
+            expected: "(\"flow\" | \"stock\" | \"time\")",
+            value: input.reading
+        }), "string" === typeof input.value || _report(_exceptionable, {
+            path: _path + ".value",
+            expected: "string",
+            value: input.value
+        })].every(flag => flag);
+    const _vo3 = (input, _path, _exceptionable = true) => ["number" === typeof input.fromSec || _report(_exceptionable, {
+            path: _path + ".fromSec",
+            expected: "number",
+            value: input.fromSec
+        }), "number" === typeof input.toSec || _report(_exceptionable, {
+            path: _path + ".toSec",
+            expected: "number",
+            value: input.toSec
+        }), "number" === typeof input.stepSec || _report(_exceptionable, {
+            path: _path + ".stepSec",
+            expected: "number",
+            value: input.stepSec
+        }), _vp3(input, _path, true && _exceptionable), "number" === typeof input.candidateCount || _report(_exceptionable, {
+            path: _path + ".candidateCount",
+            expected: "number",
+            value: input.candidateCount
+        }), _vp0(input, _path, true && _exceptionable), _vp1(input, _path, true && _exceptionable)].every(flag => flag);
+    const _vo4 = (input, _path, _exceptionable = true) => ["always-active" === input.assumed || "scheduled" === input.assumed || _report(_exceptionable, {
+            path: _path + ".assumed",
+            expected: "(\"always-active\" | \"scheduled\")",
+            value: input.assumed
+        }), null === input.patternId || "string" === typeof input.patternId || _report(_exceptionable, {
+            path: _path + ".patternId",
+            expected: "(null | string)",
+            value: input.patternId
+        }), null === input.resetDelaySec || "number" === typeof input.resetDelaySec || _report(_exceptionable, {
+            path: _path + ".resetDelaySec",
+            expected: "(null | number)",
+            value: input.resetDelaySec
+        })].every(flag => flag);
+    const _vo5 = (input, _path, _exceptionable = true) => [_vp4(input, _path, true && _exceptionable), "drifting" === input.stability || "insufficient-data" === input.stability || "non-stationary" === input.stability || "oscillating" === input.stability || "stable" === input.stability || _report(_exceptionable, {
+            path: _path + ".stability",
+            expected: "(\"drifting\" | \"insufficient-data\" | \"non-stationary\" | \"oscillating\" | \"stable\")",
+            value: input.stability
+        }), _vp5(input, _path, true && _exceptionable), "censored" === input.recovery || "observed" === input.recovery || "unsupported" === input.recovery || _report(_exceptionable, {
+            path: _path + ".recovery",
+            expected: "(\"censored\" | \"observed\" | \"unsupported\")",
+            value: input.recovery
+        })].every(flag => flag);
+    const _vo6 = (input, _path, _exceptionable = true) => [_vp2(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), _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)].every(flag => flag);
+    const _vo7 = (input, _path, _exceptionable = true) => ["number" === typeof input.startSec || _report(_exceptionable, {
+            path: _path + ".startSec",
+            expected: "number",
+            value: input.startSec
+        }), "number" === typeof input.endSec || _report(_exceptionable, {
+            path: _path + ".endSec",
+            expected: "number",
+            value: input.endSec
+        }), "number" === typeof input.durationSec || _report(_exceptionable, {
+            path: _path + ".durationSec",
+            expected: "number",
+            value: input.durationSec
+        })].every(flag => flag);
+    const _vo8 = (input, _path, _exceptionable = true) => ["pre-reset-income" === input.metric || "pre-reset-net-worth" === input.metric || _report(_exceptionable, {
+            path: _path + ".metric",
+            expected: "(\"pre-reset-income\" | \"pre-reset-net-worth\")",
+            value: input.metric
+        }), "censored" === input.status || "observed" === input.status || "unsupported" === input.status || _report(_exceptionable, {
+            path: _path + ".status",
+            expected: "(\"censored\" | \"observed\" | \"unsupported\")",
+            value: input.status
+        }), null === input.seconds || "number" === typeof input.seconds || _report(_exceptionable, {
+            path: _path + ".seconds",
+            expected: "(null | number)",
+            value: input.seconds
+        }), "string" === typeof input.threshold || _report(_exceptionable, {
+            path: _path + ".threshold",
+            expected: "string",
+            value: input.threshold
+        })].every(flag => flag);
+    const _vo9 = (input, _path, _exceptionable = true) => ["empirical" === input.kind || _report(_exceptionable, {
+            path: _path + ".kind",
+            expected: "\"empirical\"",
+            value: input.kind
+        }), _vp5(input, _path, true && _exceptionable), _vp4(input, _path, true && _exceptionable), "number" === typeof input.observedCycles || _report(_exceptionable, {
+            path: _path + ".observedCycles",
+            expected: "number",
+            value: input.observedCycles
+        }), "number" === typeof input.minObservedCycles || _report(_exceptionable, {
+            path: _path + ".minObservedCycles",
+            expected: "number",
+            value: input.minObservedCycles
+        }), (Array.isArray(input.windows) || _report(_exceptionable, {
+            path: _path + ".windows",
+            expected: "ReadonlyArray<number>",
+            value: input.windows
+        })) && input.windows.map((elem, _index10) => "number" === typeof elem || _report(_exceptionable, {
+            path: _path + ".windows[" + _index10 + "]",
+            expected: "number",
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + ".windows",
+            expected: "ReadonlyArray<number>",
+            value: input.windows
+        }), "string" === typeof input.absoluteTolerance || _report(_exceptionable, {
+            path: _path + ".absoluteTolerance",
+            expected: "string",
+            value: input.absoluteTolerance
+        }), "number" === typeof input.relativeTolerance || _report(_exceptionable, {
+            path: _path + ".relativeTolerance",
+            expected: "number",
+            value: input.relativeTolerance
+        }), _vp3(input, _path, true && _exceptionable)].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 buildResetPolicyJsonSchema() {
+    return {
+        components: {
+            schemas: {
+                "ReadonlyschemaVersion1algorithmVersionreset-policy-v1statuscensoredincompleteinsufficient-dataokunsupportedobjectiveResetObjectiveKind---6more---warningsreadonlystring": {
+                    type: "object",
+                    properties: {
+                        schemaVersion: {
+                            "const": 1
+                        },
+                        algorithmVersion: {
+                            "const": "reset-policy-v1"
+                        },
+                        status: {
+                            oneOf: [
+                                {
+                                    "const": "censored"
+                                },
+                                {
+                                    "const": "incomplete"
+                                },
+                                {
+                                    "const": "insufficient-data"
+                                },
+                                {
+                                    "const": "ok"
+                                },
+                                {
+                                    "const": "unsupported"
+                                }
+                            ]
+                        },
+                        objective: {
+                            $ref: "#/components/schemas/ResetObjectiveKind"
+                        },
+                        scope: {
+                            "const": "scan-range"
+                        },
+                        globalOptimum: {
+                            "const": false
+                        },
+                        best: {
+                            $ref: "#/components/schemas/ReadonlyintervalSecnumberobjectiveReadonlykindResetObjectiveKindreadingObjectiveReadingvaluestringcomparisonReadonly---sessionReadonly---observationReadonly---"
+                        },
+                        candidates: {
+                            type: "array",
+                            items: {
+                                $ref: "#/components/schemas/ReadonlyintervalSecnumberstatuscensoredincompleteokunsupportedcompletedCyclesnumberrealizedRewardstringunrealizedRewardstringfinalPointsstringfinalNetWorthstring---9more---resetWallTimesreadonlynumber"
+                            }
+                        },
+                        knownSolution: {
+                            oneOf: [
+                                {
+                                    type: "null"
+                                },
+                                {
+                                    $ref: "#/components/schemas/ReadonlyfixtureIdstringexpectedRatestringobservedRatestringmatchesboolean"
+                                }
+                            ]
+                        },
+                        assumptions: {
+                            type: "array",
+                            items: {
+                                type: "string"
+                            }
+                        },
+                        warnings: {
+                            type: "array",
+                            items: {
+                                type: "string"
+                            }
+                        }
+                    },
+                    required: [
+                        "schemaVersion",
+                        "algorithmVersion",
+                        "status",
+                        "objective",
+                        "scope",
+                        "globalOptimum",
+                        "best",
+                        "candidates",
+                        "knownSolution",
+                        "assumptions",
+                        "warnings"
+                    ],
+                    additionalProperties: false
+                },
+                ResetObjectiveKind: {
+                    oneOf: [
+                        {
+                            "const": "cumulative-reset-reward"
+                        },
+                        {
+                            "const": "final-net-worth"
+                        },
+                        {
+                            "const": "goal-reach-sec"
+                        }
+                    ]
+                },
+                "ReadonlyintervalSecnumberobjectiveReadonlykindResetObjectiveKindreadingObjectiveReadingvaluestringcomparisonReadonly---sessionReadonly---observationReadonly---": {
+                    type: "object",
+                    properties: {
+                        intervalSec: {
+                            type: "number"
+                        },
+                        objective: {
+                            $ref: "#/components/schemas/ReadonlykindResetObjectiveKindreadingObjectiveReadingvaluestring"
+                        },
+                        comparison: {
+                            $ref: "#/components/schemas/ReadonlyfromSecnumbertoSecnumberstepSecnumberhorizonSecnumbercandidateCountnumberscopescan-rangeglobalOptimumfalse"
+                        },
+                        session: {
+                            $ref: "#/components/schemas/Readonlyassumedalways-activescheduledpatternIdstringnullresetDelaySecnumbernull"
+                        },
+                        observation: {
+                            $ref: "#/components/schemas/ReadonlystatusEmpiricalStabilitystabilityEmpiricalStabilityprovedSteadyStatefalserecoverycensoredobservedunsupported"
+                        }
+                    },
+                    required: [
+                        "intervalSec",
+                        "objective",
+                        "comparison",
+                        "session",
+                        "observation"
+                    ],
+                    additionalProperties: false
+                },
+                ReadonlykindResetObjectiveKindreadingObjectiveReadingvaluestring: {
+                    type: "object",
+                    properties: {
+                        kind: {
+                            $ref: "#/components/schemas/ResetObjectiveKind"
+                        },
+                        reading: {
+                            $ref: "#/components/schemas/ObjectiveReading"
+                        },
+                        value: {
+                            type: "string"
+                        }
+                    },
+                    required: [
+                        "kind",
+                        "reading",
+                        "value"
+                    ],
+                    additionalProperties: false
+                },
+                ObjectiveReading: {
+                    oneOf: [
+                        {
+                            "const": "flow"
+                        },
+                        {
+                            "const": "stock"
+                        },
+                        {
+                            "const": "time"
+                        }
+                    ]
+                },
+                "ReadonlyfromSecnumbertoSecnumberstepSecnumberhorizonSecnumbercandidateCountnumberscopescan-rangeglobalOptimumfalse": {
+                    type: "object",
+                    properties: {
+                        fromSec: {
+                            type: "number"
+                        },
+                        toSec: {
+                            type: "number"
+                        },
+                        stepSec: {
+                            type: "number"
+                        },
+                        horizonSec: {
+                            type: "number"
+                        },
+                        candidateCount: {
+                            type: "number"
+                        },
+                        scope: {
+                            "const": "scan-range"
+                        },
+                        globalOptimum: {
+                            "const": false
+                        }
+                    },
+                    required: [
+                        "fromSec",
+                        "toSec",
+                        "stepSec",
+                        "horizonSec",
+                        "candidateCount",
+                        "scope",
+                        "globalOptimum"
+                    ],
+                    additionalProperties: false
+                },
+                "Readonlyassumedalways-activescheduledpatternIdstringnullresetDelaySecnumbernull": {
+                    type: "object",
+                    properties: {
+                        assumed: {
+                            oneOf: [
+                                {
+                                    "const": "always-active"
+                                },
+                                {
+                                    "const": "scheduled"
+                                }
+                            ]
+                        },
+                        patternId: {
+                            oneOf: [
+                                {
+                                    type: "null"
+                                },
+                                {
+                                    type: "string"
+                                }
+                            ]
+                        },
+                        resetDelaySec: {
+                            oneOf: [
+                                {
+                                    type: "null"
+                                },
+                                {
+                                    type: "number"
+                                }
+                            ]
+                        }
+                    },
+                    required: [
+                        "assumed",
+                        "patternId",
+                        "resetDelaySec"
+                    ],
+                    additionalProperties: false
+                },
+                ReadonlystatusEmpiricalStabilitystabilityEmpiricalStabilityprovedSteadyStatefalserecoverycensoredobservedunsupported: {
+                    type: "object",
+                    properties: {
+                        status: {
+                            $ref: "#/components/schemas/EmpiricalStability"
+                        },
+                        stability: {
+                            $ref: "#/components/schemas/EmpiricalStability"
+                        },
+                        provedSteadyState: {
+                            "const": false
+                        },
+                        recovery: {
+                            oneOf: [
+                                {
+                                    "const": "censored"
+                                },
+                                {
+                                    "const": "observed"
+                                },
+                                {
+                                    "const": "unsupported"
+                                }
+                            ]
+                        }
+                    },
+                    required: [
+                        "status",
+                        "stability",
+                        "provedSteadyState",
+                        "recovery"
+                    ],
+                    additionalProperties: false
+                },
+                EmpiricalStability: {
+                    oneOf: [
+                        {
+                            "const": "drifting"
+                        },
+                        {
+                            "const": "insufficient-data"
+                        },
+                        {
+                            "const": "non-stationary"
+                        },
+                        {
+                            "const": "oscillating"
+                        },
+                        {
+                            "const": "stable"
+                        }
+                    ]
+                },
+                "ReadonlyintervalSecnumberstatuscensoredincompleteokunsupportedcompletedCyclesnumberrealizedRewardstringunrealizedRewardstringfinalPointsstringfinalNetWorthstring---9more---resetWallTimesreadonlynumber": {
+                    type: "object",
+                    properties: {
+                        intervalSec: {
+                            type: "number"
+                        },
+                        status: {
+                            oneOf: [
+                                {
+                                    "const": "censored"
+                                },
+                                {
+                                    "const": "incomplete"
+                                },
+                                {
+                                    "const": "ok"
+                                },
+                                {
+                                    "const": "unsupported"
+                                }
+                            ]
+                        },
+                        completedCycles: {
+                            type: "number"
+                        },
+                        realizedReward: {
+                            type: "string"
+                        },
+                        unrealizedReward: {
+                            type: "string"
+                        },
+                        finalPoints: {
+                            type: "string"
+                        },
+                        finalNetWorth: {
+                            type: "string"
+                        },
+                        rewardRate: {
+                            oneOf: [
+                                {
+                                    type: "null"
+                                },
+                                {
+                                    type: "string"
+                                }
+                            ]
+                        },
+                        rewardRateDenominator: {
+                            "const": "completed-cycle-time"
+                        },
+                        incomplete: {
+                            oneOf: [
+                                {
+                                    type: "null"
+                                },
+                                {
+                                    $ref: "#/components/schemas/ReadonlystartSecnumberendSecnumberdurationSecnumber"
+                                }
+                            ]
+                        },
+                        goalReachSec: {
+                            oneOf: [
+                                {
+                                    type: "null"
+                                },
+                                {
+                                    type: "number"
+                                }
+                            ]
+                        },
+                        goalStatus: {
+                            oneOf: [
+                                {
+                                    "const": "censored"
+                                },
+                                {
+                                    "const": "not-requested"
+                                },
+                                {
+                                    "const": "observed"
+                                }
+                            ]
+                        },
+                        recovery: {
+                            $ref: "#/components/schemas/ReadonlymetricRecoveryMetricKindstatuscensoredobservedunsupportedsecondsnumbernullthresholdstring"
+                        },
+                        stability: {
+                            $ref: "#/components/schemas/ReadonlykindempiricalprovedSteadyStatefalsestatusEmpiricalStabilityobservedCyclesnumberminObservedCyclesnumberwindowsreadonlynumberabsoluteTolerancestringrelativeTolerancenumberhorizonSecnumber"
+                        },
+                        objectiveValue: {
+                            type: "string"
+                        },
+                        objectiveReading: {
+                            $ref: "#/components/schemas/ObjectiveReading"
+                        },
+                        resetWallTimes: {
+                            type: "array",
+                            items: {
+                                type: "number"
+                            }
+                        }
+                    },
+                    required: [
+                        "intervalSec",
+                        "status",
+                        "completedCycles",
+                        "realizedReward",
+                        "unrealizedReward",
+                        "finalPoints",
+                        "finalNetWorth",
+                        "rewardRate",
+                        "rewardRateDenominator",
+                        "incomplete",
+                        "goalReachSec",
+                        "goalStatus",
+                        "recovery",
+                        "stability",
+                        "objectiveValue",
+                        "objectiveReading",
+                        "resetWallTimes"
+                    ],
+                    additionalProperties: false
+                },
+                ReadonlystartSecnumberendSecnumberdurationSecnumber: {
+                    type: "object",
+                    properties: {
+                        startSec: {
+                            type: "number"
+                        },
+                        endSec: {
+                            type: "number"
+                        },
+                        durationSec: {
+                            type: "number"
+                        }
+                    },
+                    required: [
+                        "startSec",
+                        "endSec",
+                        "durationSec"
+                    ],
+                    additionalProperties: false
+                },
+                ReadonlymetricRecoveryMetricKindstatuscensoredobservedunsupportedsecondsnumbernullthresholdstring: {
+                    type: "object",
+                    properties: {
+                        metric: {
+                            $ref: "#/components/schemas/RecoveryMetricKind"
+                        },
+                        status: {
+                            oneOf: [
+                                {
+                                    "const": "censored"
+                                },
+                                {
+                                    "const": "observed"
+                                },
+                                {
+                                    "const": "unsupported"
+                                }
+                            ]
+                        },
+                        seconds: {
+                            oneOf: [
+                                {
+                                    type: "null"
+                                },
+                                {
+                                    type: "number"
+                                }
+                            ]
+                        },
+                        threshold: {
+                            type: "string"
+                        }
+                    },
+                    required: [
+                        "metric",
+                        "status",
+                        "seconds",
+                        "threshold"
+                    ],
+                    additionalProperties: false
+                },
+                RecoveryMetricKind: {
+                    oneOf: [
+                        {
+                            "const": "pre-reset-income"
+                        },
+                        {
+                            "const": "pre-reset-net-worth"
+                        }
+                    ]
+                },
+                ReadonlykindempiricalprovedSteadyStatefalsestatusEmpiricalStabilityobservedCyclesnumberminObservedCyclesnumberwindowsreadonlynumberabsoluteTolerancestringrelativeTolerancenumberhorizonSecnumber: {
+                    type: "object",
+                    properties: {
+                        kind: {
+                            "const": "empirical"
+                        },
+                        provedSteadyState: {
+                            "const": false
+                        },
+                        status: {
+                            $ref: "#/components/schemas/EmpiricalStability"
+                        },
+                        observedCycles: {
+                            type: "number"
+                        },
+                        minObservedCycles: {
+                            type: "number"
+                        },
+                        windows: {
+                            type: "array",
+                            items: {
+                                type: "number"
+                            }
+                        },
+                        absoluteTolerance: {
+                            type: "string"
+                        },
+                        relativeTolerance: {
+                            type: "number"
+                        },
+                        horizonSec: {
+                            type: "number"
+                        }
+                    },
+                    required: [
+                        "kind",
+                        "provedSteadyState",
+                        "status",
+                        "observedCycles",
+                        "minObservedCycles",
+                        "windows",
+                        "absoluteTolerance",
+                        "relativeTolerance",
+                        "horizonSec"
+                    ],
+                    additionalProperties: false
+                },
+                ReadonlyfixtureIdstringexpectedRatestringobservedRatestringmatchesboolean: {
+                    type: "object",
+                    properties: {
+                        fixtureId: {
+                            type: "string"
+                        },
+                        expectedRate: {
+                            type: "string"
+                        },
+                        observedRate: {
+                            type: "string"
+                        },
+                        matches: {
+                            type: "boolean"
+                        }
+                    },
+                    required: [
+                        "fixtureId",
+                        "expectedRate",
+                        "observedRate",
+                        "matches"
+                    ],
+                    additionalProperties: false
+                }
+            }
+        },
+        schema: {
+            type: "object",
+            properties: {
+                schemaVersion: {
+                    "const": 1
+                },
+                algorithmVersion: {
+                    "const": "reset-policy-v1"
+                },
+                status: {
+                    oneOf: [
+                        {
+                            "const": "censored"
+                        },
+                        {
+                            "const": "incomplete"
+                        },
+                        {
+                            "const": "insufficient-data"
+                        },
+                        {
+                            "const": "ok"
+                        },
+                        {
+                            "const": "unsupported"
+                        }
+                    ]
+                },
+                objective: {
+                    $ref: "#/components/schemas/ResetObjectiveKind"
+                },
+                scope: {
+                    "const": "scan-range"
+                },
+                globalOptimum: {
+                    "const": false
+                },
+                best: {
+                    $ref: "#/components/schemas/ReadonlyintervalSecnumberobjectiveReadonlykindResetObjectiveKindreadingObjectiveReadingvaluestringcomparisonReadonly---sessionReadonly---observationReadonly---"
+                },
+                candidates: {
+                    type: "array",
+                    items: {
+                        $ref: "#/components/schemas/ReadonlyintervalSecnumberstatuscensoredincompleteokunsupportedcompletedCyclesnumberrealizedRewardstringunrealizedRewardstringfinalPointsstringfinalNetWorthstring---9more---resetWallTimesreadonlynumber"
+                    }
+                },
+                knownSolution: {
+                    oneOf: [
+                        {
+                            type: "null"
+                        },
+                        {
+                            $ref: "#/components/schemas/ReadonlyfixtureIdstringexpectedRatestringobservedRatestringmatchesboolean"
+                        }
+                    ]
+                },
+                assumptions: {
+                    type: "array",
+                    items: {
+                        type: "string"
+                    }
+                },
+                warnings: {
+                    type: "array",
+                    items: {
+                        type: "string"
+                    }
+                }
+            },
+            required: [
+                "schemaVersion",
+                "algorithmVersion",
+                "status",
+                "objective",
+                "scope",
+                "globalOptimum",
+                "best",
+                "candidates",
+                "knownSolution",
+                "assumptions",
+                "warnings"
+            ],
+            additionalProperties: false
+        },
+        version: "3.1"
+    };
+}
+let resetPolicyJsonSchemaUnit;
+/**
+ * @evidence docs/requirements/active/reset-cycle-analysis.md#req-pr11-scan-rank The structural schema is OpenAPI 3.1 from typia.
+ * @evidenceReview docs/requirements/active/reset-cycle-analysis.md#req-pr11-scan-rank #468d46d Re-read the section: schema version is 3.1.
+ */
+export function resetPolicyJsonSchema() {
+    resetPolicyJsonSchemaUnit ??= buildResetPolicyJsonSchema();
+    return resetPolicyJsonSchemaUnit;
+}
+/** Goal ids this analysis adds to a run's goals, so the runner reports the first committed state that meets them. */
+const GOAL_WATCH_ID = "reset-policy.goal";
+const RECOVERY_WATCH_ID = "reset-policy.recovery";
+function assertFinite(label, value) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new ResetPolicyRejected(`reset policy ${label} must be a finite number`);
+    }
+}
+function assertStep(value) {
+    assertFinite("scan.stepSec", value);
+    if (!(value > 0))
+        throw new ResetPolicyRejected("reset policy scan.stepSec must be a finite number > 0");
+}
+function scanIntervals(scan) {
+    assertFinite("scan.fromSec", scan.fromSec);
+    assertFinite("scan.toSec", scan.toSec);
+    assertStep(scan.stepSec);
+    if (!(scan.fromSec > 0) || scan.toSec < scan.fromSec) {
+        throw new ResetPolicyRejected("reset policy scan range must be finite and fromSec > 0");
+    }
+    // Intervals ascend from fromSec. One at or below the runner resolution would commit resets without playing time.
+    if (scan.fromSec <= RUNNER_MIN_DURATION_SEC) {
+        throw new ResetPolicyRejected(`reset policy scan.fromSec must be greater than the runner's ${RUNNER_MIN_DURATION_SEC} second resolution`);
+    }
+    const steps = (scan.toSec - scan.fromSec) / scan.stepSec;
+    if (!Number.isFinite(steps))
+        throw new ResetPolicyRejected("reset policy scan range is not finite");
+    // A provisional count bounds the loop. The limit applies to the intervals that survive the upper-bound check.
+    const provisional = Math.floor(steps + 1e-9) + 1;
+    if (!Number.isSafeInteger(provisional) || provisional < 1 || provisional > MAX_CANDIDATES + 1) {
+        throw new ResetPolicyRejected("reset policy scan candidate count must be a safe integer from 1 to 10000");
+    }
+    const intervals = [];
+    for (let index = 0; index < provisional; index += 1) {
+        const interval = scan.fromSec + index * scan.stepSec;
+        // Rounding dust only: a share of a large step could admit an interval well past toSec.
+        const dust = 8 * Number.EPSILON * Math.max(Math.abs(scan.toSec), Math.abs(interval));
+        if (interval > scan.toSec + dust)
+            break;
+        // A step below the spacing of floats at this interval repeats a candidate instead of scanning a new one.
+        const previous = intervals[intervals.length - 1];
+        if (previous !== undefined && !(interval > previous)) {
+            throw new ResetPolicyRejected("reset policy scan.stepSec must advance every scanned interval");
+        }
+        intervals.push(interval);
+    }
+    if (intervals.length === 0)
+        throw new ResetPolicyRejected("reset policy scan produced no candidates");
+    if (intervals.length > MAX_CANDIDATES) {
+        throw new ResetPolicyRejected("reset policy scan candidate count must be a safe integer from 1 to 10000");
+    }
+    return intervals;
+}
+const OBJECTIVE_KINDS = ["cumulative-reset-reward", "final-net-worth", "goal-reach-sec"];
+const RECOVERY_METRICS = ["pre-reset-income", "pre-reset-net-worth"];
+function assertRequest(request) {
+    if (typeof request.createScenario !== "function") {
+        throw new ResetPolicyRejected("reset policy createScenario must be a function");
+    }
+    // An unchecked caller can pass any string. An unknown kind would fall back to another ranking or metric.
+    if (!OBJECTIVE_KINDS.includes(request.objective)) {
+        throw new ResetPolicyRejected(`reset policy objective must be one of ${OBJECTIVE_KINDS.join(", ")}`);
+    }
+    if (!RECOVERY_METRICS.includes(request.recovery?.metric)) {
+        throw new ResetPolicyRejected(`reset policy recovery.metric must be one of ${RECOVERY_METRICS.join(", ")}`);
+    }
+    scanIntervals(request.scan);
+    assertFinite("horizonSec", request.horizonSec);
+    if (!(request.horizonSec > 0))
+        throw new ResetPolicyRejected("reset policy horizonSec must be a finite number > 0");
+    // Every wall or elapsed time is at most the horizon. When the shortest interval still advances the horizon, it
+    // advances every earlier time too, so no two resets share an instant.
+    if (!(request.horizonSec + request.scan.fromSec > request.horizonSec)) {
+        throw new ResetPolicyRejected("reset policy scan.fromSec must advance a time at horizonSec");
+    }
+    if (!Number.isInteger(request.cycleBudget) || request.cycleBudget < 1) {
+        throw new ResetPolicyRejected("reset policy cycleBudget must be a positive integer");
+    }
+    // A goal-time objective without a goal has nothing to rank.
+    if (request.objective === "goal-reach-sec" && typeof request.goal !== "function") {
+        throw new ResetPolicyRejected("reset policy goal-reach-sec needs a goal predicate");
+    }
+    if (!Number.isInteger(request.stability.minObservedCycles) || request.stability.minObservedCycles < 1) {
+        throw new ResetPolicyRejected("reset policy minObservedCycles must be a positive integer");
+    }
+    if (request.stability.windows.length < 2) {
+        throw new ResetPolicyRejected("reset policy stability requires at least two trailing windows");
+    }
+    for (const window of request.stability.windows) {
+        if (!Number.isInteger(window) || window < 2) {
+            throw new ResetPolicyRejected("reset policy stability windows must be integers >= 2");
+        }
+    }
+    // Two copies of one window inspect the same samples twice. Agreement needs two distinct windows.
+    if (new Set(request.stability.windows).size !== request.stability.windows.length) {
+        throw new ResetPolicyRejected("reset policy stability windows must be distinct");
+    }
+    if (request.stability.absoluteTolerance.trim() === "") {
+        throw new ResetPolicyRejected("reset policy absoluteTolerance must be a non-empty amount");
+    }
+    assertFinite("relativeTolerance", request.stability.relativeTolerance);
+    if (request.stability.relativeTolerance < 0) {
+        throw new ResetPolicyRejected("reset policy relativeTolerance must be >= 0");
+    }
+    if (request.session) {
+        assertFinite("resetDelaySec", request.session.resetDelaySec);
+        // An unknown preset id from an unchecked caller builds no block. That is not an all-offline schedule.
+        if (sessionActiveBlocks(horizonPattern(request)).length === 0) {
+            throw new ResetPolicyRejected(`reset policy session pattern ${String(request.session.pattern.id)} has no active block`);
+        }
+        if (request.session.resetDelaySec < 0) {
+            throw new ResetPolicyRejected("reset policy resetDelaySec must be a finite number >= 0");
+        }
+    }
+}
+/**
+ * The pattern's days that can reach the horizon. Every preset has a block on each day, and days past the horizon
+ * play nothing, so a long day count does not expand blocks the analysis never reaches. A schedule is used as given.
+ */
+function horizonPattern(request) {
+    const pattern = request.session?.pattern;
+    if (!pattern)
+        throw new ResetPolicyRejected("reset policy session is missing");
+    if (pattern.schedule || !Number.isInteger(pattern.days) || pattern.days <= 0)
+        return pattern;
+    return { ...pattern, days: Math.min(pattern.days, Math.floor(request.horizonSec / 86400) + 1) };
+}
+/** Blocks inside the horizon, built once per request and shared by every candidate and probe. */
+const horizonBlockCache = new WeakMap();
+function horizonBlocks(request) {
+    const cached = horizonBlockCache.get(request);
+    if (cached)
+        return cached;
+    const blocks = sessionActiveBlocks(horizonPattern(request))
+        .map((block) => {
+        const start = block.day * 86400 + block.startOffsetSec;
+        // Playback stops at the horizon, but a reset at the horizon is still inside the block's natural span.
+        const natural = start + block.durationSec;
+        return { start, natural, end: Math.min(natural, request.horizonSec) };
+    })
+        // A block that starts exactly at the horizon still admits a reset at the horizon, inside its natural span.
+        .filter((block) => block.end > block.start || (block.start === request.horizonSec && block.natural > block.start));
+    horizonBlockCache.set(request, blocks);
+    return blocks;
+}
+/** The absolute tolerance in the scenario's engine. It must be a finite amount >= 0. */
+function absoluteToleranceOf(E, text) {
+    let amount;
+    try {
+        amount = E.from(text);
+    }
+    catch {
+        throw new ResetPolicyRejected("reset policy absoluteTolerance must be a finite amount >= 0");
+    }
+    if (!E.isFinite(amount) || E.cmp(amount, E.zero()) < 0) {
+        throw new ResetPolicyRejected("reset policy absoluteTolerance must be a finite amount >= 0");
+    }
+    return amount;
+}
+function magnitude(E, value) {
+    return E.cmp(value, E.zero()) < 0 ? E.sub(E.zero(), value) : value;
+}
+function within(E, left, right, absolute, relative) {
+    const delta = magnitude(E, E.sub(left, right));
+    if (E.cmp(delta, absolute) <= 0)
+        return true;
+    const leftMag = magnitude(E, left);
+    const rightMag = magnitude(E, right);
+    const scale = E.cmp(leftMag, rightMag) >= 0 ? leftMag : rightMag;
+    return E.cmp(delta, E.mul(scale, relative)) <= 0;
+}
+function diffs(E, values) {
+    const out = [];
+    for (let index = 1; index < values.length; index += 1) {
+        const current = values[index];
+        const previous = values[index - 1];
+        if (current === undefined || previous === undefined)
+            continue;
+        out.push(E.sub(current, previous));
+    }
+    return out;
+}
+function moves(E, step, base, absolute, relative) {
+    return !within(E, E.add(base, step), base, absolute, relative);
+}
+function isOscillating(E, values, absolute, relative) {
+    const steps = diffs(E, values);
+    if (steps.length < 3)
+        return false;
+    let sign = 0;
+    for (let index = 0; index < steps.length; index += 1) {
+        const step = steps[index];
+        const base = values[index];
+        if (step === undefined || base === undefined)
+            return false;
+        if (!moves(E, step, base, absolute, relative))
+            return false;
+        const next = E.cmp(step, E.zero());
+        if (next === 0 || (sign !== 0 && next === sign))
+            return false;
+        sign = next;
+    }
+    return true;
+}
+function isDrifting(E, values, absolute, relative) {
+    const steps = diffs(E, values);
+    if (steps.length < 2)
+        return false;
+    let sign = 0;
+    for (let index = 0; index < steps.length; index += 1) {
+        const step = steps[index];
+        const base = values[index];
+        if (step === undefined || base === undefined)
+            return false;
+        if (!moves(E, step, base, absolute, relative))
+            return false;
+        const next = E.cmp(step, E.zero());
+        if (next === 0 || (sign !== 0 && next !== sign))
+            return false;
+        sign = next;
+    }
+    return true;
+}
+function stationary(E, values, absolute, relative) {
+    const anchor = values[values.length - 1];
+    if (anchor === undefined)
+        return false;
+    return values.every((value) => within(E, value, anchor, absolute, relative));
+}
+function classify(E, reward, condition, spec, absolute) {
+    if (reward.length < spec.minObservedCycles || condition.length < spec.minObservedCycles)
+        return "insufficient-data";
+    const usable = spec.windows.filter((window) => window <= reward.length && window <= condition.length);
+    if (usable.length < 2)
+        return "insufficient-data";
+    const rewardStable = usable.every((window) => stationary(E, reward.slice(-window), absolute, spec.relativeTolerance));
+    const conditionStable = usable.every((window) => stationary(E, condition.slice(-window), absolute, spec.relativeTolerance));
+    if (rewardStable && conditionStable)
+        return "stable";
+    if (isOscillating(E, reward, absolute, spec.relativeTolerance) ||
+        isOscillating(E, condition, absolute, spec.relativeTolerance)) {
+        return "oscillating";
+    }
+    if (isDrifting(E, reward, absolute, spec.relativeTolerance) || isDrifting(E, condition, absolute, spec.relativeTolerance)) {
+        return "drifting";
+    }
+    return "non-stationary";
+}
+/** The scenario context with the live constraints, as runScenario builds it for a step. */
+function liveCtx(scenario, constraints) {
+    return { ...scenario.ctx, ...(constraints ? { constraints } : {}) };
+}
+/**
+ * A measurement-only copy: no observer, reset hook, event emitter, or caller goal. A probe run is not the candidate
+ * run, so none of its steps, actions, goals, milestones, or resets reach the caller, and no caller predicate runs.
+ */
+function silent(scenario) {
+    const { observer: _observer, onPrestigeReset: _onPrestigeReset, goals: _goals, ...run } = scenario.run;
+    const { emit: _emit, ...ctx } = scenario.ctx;
+    return { ...scenario, ctx, run };
+}
+/** Net worth read with the context the simulation used: live constraints, and clocks on a schedule. */
+function netWorth(scenario, state, ctx) {
+    return scenario.model.netWorth?.(ctx, state)?.amount ?? state.wallet.money.amount;
+}
+function incomeOf(scenario, state, ctx) {
+    return scenario.model.income(ctx, state).amount;
+}
+function recoveryMetric(request, scenario, state, ctx) {
+    return request.recovery.metric === "pre-reset-income" ? incomeOf(scenario, state, ctx) : netWorth(scenario, state, ctx);
+}
+/** The adapter where a reset would happen: the request's, or one discovered at this state and context. */
+function adapterAt(request, scenario, state, constraints, clocks) {
+    const ctx = liveCtx(scenario, constraints);
+    return request.adapter ?? resetAdapterFor(scenario, undefined, state, clocks ? { ...ctx, clocks } : ctx);
+}
+function observationShare(scenario) {
+    return {
+        observation: shareObservation({ ...scenario.run.observation, enabled: true }).observation,
+        reachedGoals: new Set(),
+        reachedWatchers: new Set(),
+    };
+}
+/**
+ * The scenario a policy run plays: the caller's open goals plus this analysis' open watchers, read by the runner on
+ * every committed state, and an observer that routes a watcher's first crossing back here. Recording is on while a
+ * watcher is open, since the runner reads goals only while it records. A caller that disabled observation keeps it
+ * disabled when no watcher is open, and hears no fact while a watcher forces recording on.
+ */
+function watched(scenario, watchers, share) {
+    const open = watchers.filter((watcher) => !share.reachedWatchers.has(watcher));
+    const callerDisabled = scenario.run.observation?.enabled === false;
+    if (callerDisabled && open.length === 0)
+        return scenario;
+    // A disabled caller has no goal the runner would read and no observer that hears facts.
+    const callerGoals = callerDisabled ? [] : (scenario.run.goals ?? []).filter((goal) => !share.reachedGoals.has(goal.id));
+    const observer = callerDisabled ? undefined : scenario.run.observer;
+    // A caller goal can use any id. Each watcher takes an id no caller goal uses, so a caller goal is never
+    // routed to a watcher and a watcher is never marked reached by a caller goal.
+    const taken = new Set((scenario.run.goals ?? []).map((goal) => goal.id));
+    const byId = new Map();
+    for (const watcher of open) {
+        let id = watcher.id;
+        for (let suffix = 1; taken.has(id); suffix += 1)
+            id = `${watcher.id}#${suffix}`;
+        taken.add(id);
+        byId.set(id, watcher);
+    }
+    const { observer: _callerObserver, ...run } = scenario.run;
+    return {
+        ...scenario,
+        run: {
+            ...run,
+            observation: share.observation,
+            goals: [...callerGoals, ...[...byId].map(([id, watcher]) => ({ id, met: watcher.met }))],
+            observer: {
+                ...observer,
+                onGoal: (fact) => {
+                    const watcher = byId.get(fact.goalId);
+                    if (watcher) {
+                        // The first crossing is the answer. Later runs of this candidate do not read the predicate again.
+                        share.reachedWatchers.add(watcher);
+                        watcher.onMet(fact.t);
+                        return;
+                    }
+                    share.reachedGoals.add(fact.goalId);
+                    observer?.onGoal?.(fact);
+                },
+            },
+        },
+    };
+}
+/**
+ * Read the caller's open goals on a committed boundary reset state, which no runner records, and tell the observer
+ * about each first crossing once. A caller that disabled observation reads no goal.
+ */
+function readCallerGoals(scenario, state, share) {
+    if (scenario.run.observation?.enabled === false)
+        return;
+    for (const goal of scenario.run.goals ?? []) {
+        if (share.reachedGoals.has(goal.id))
+            continue;
+        if (!goal.met(deepClonePreservingPrototype(state)))
+            continue;
+        share.reachedGoals.add(goal.id);
+        scenario.run.observer?.onGoal?.({ t: state.t, goalId: goal.id });
+    }
+}
+/**
+ * Play without a reset. The reset action is hidden from the strategy, as `executeResetCycles` hides it, so only
+ * this analysis commits resets. The run sees the live constraints and, when the model reads them, session clocks.
+ */
+function play(scenario, state, constraints, adapter, durationSec, until, clocks) {
+    const { maxSteps: _maxSteps, until: _until, trace: _trace, ...runRest } = scenario.run;
+    return runScenario({
+        ...scenario,
+        ...(clocks ? { ctx: { ...scenario.ctx, clocks } } : {}),
+        model: withoutResetActions(scenario.model, adapter),
+        initial: state,
+        ...(constraints ? { constraints } : {}),
+        run: {
+            ...runRest,
+            durationSec,
+            ...(until ? { until } : {}),
+        },
+    });
+}
+function commitReset(scenario, state, constraints, adapter, emit, clocks) {
+    const { E } = scenario.ctx;
+    // The adapter and the action see the live constraints, as the reset-cycle executor passes them, and on a
+    // schedule the session clocks of the block the reset happens in.
+    const live = liveCtx(scenario, constraints);
+    const ctx = clocks ? { ...live, clocks } : live;
+    const before = adapter.reward(ctx, state);
+    const action = adapter.action(ctx, state);
+    const kinds = new Set();
+    if (action && (action.kind === "prestige" || action.kind === "custom"))
+        kinds.add(action.kind);
+    const applied = applyDecisions({
+        ctx,
+        model: scenario.model,
+        state,
+        decisions: action ? [{ action }] : [],
+        ...(constraints ? { constraints } : {}),
+        resetKinds: kinds,
+        // The adapter built this action for this state. A spec or custom adapter action is not in model.actions.
+        resolveAgainstModel: false,
+    });
+    if (emit) {
+        // The boundary decision, applied or refused, is an action fact and an emitted event, as in the executor.
+        emitActionFacts(scenario.run.observer, state.t, applied.events);
+        if (applied.events.length > 0)
+            ctx.emit?.(applied.events);
+    }
+    const skipped = applied.events.find((event) => event.type === "action.skipped");
+    const fact = applied.committedResets[0];
+    if (!fact || skipped)
+        return { ok: false, state };
+    let next = applied.state;
+    // stepOnce keeps maxMoneyEver at or above the wallet. The boundary action does not pass through it.
+    if (E.cmp(next.wallet.money.amount, next.maxMoneyEver.amount) > 0)
+        next = { ...next, maxMoneyEver: next.wallet.money };
+    const delta = E.sub(adapter.reward(ctx, next), before);
+    const nextConstraints = action?.kind === "prestige"
+        ? recordPrestigeReset(constraints, fact.t, emit ? scenario.run.onPrestigeReset : undefined)
+        : constraints;
+    if (emit)
+        emitCommittedResets(scenario.run.observer, [{ ...fact, rewardDelta: E.toString(delta) }]);
+    return { ok: true, state: next, ...(nextConstraints ? { constraints: nextConstraints } : {}), delta, t: fact.t };
+}
+function sumAmounts(E, amounts) {
+    return amounts.reduce((total, amount) => E.add(total, amount), E.zero());
+}
+function stabilityReport(scenario, snaps, request) {
+    const { E } = scenario.ctx;
+    const absolute = absoluteToleranceOf(E, request.stability.absoluteTolerance);
+    const status = classify(E, snaps.map((snap) => E.from(snap.reward)), snaps.map((snap) => E.from(snap.multiplier)), request.stability, absolute);
+    return {
+        kind: "empirical",
+        provedSteadyState: false,
+        status,
+        observedCycles: snaps.length,
+        minObservedCycles: request.stability.minObservedCycles,
+        windows: request.stability.windows,
+        absoluteTolerance: request.stability.absoluteTolerance,
+        relativeTolerance: request.stability.relativeTolerance,
+        horizonSec: request.horizonSec,
+    };
+}
+/** Recovery for an always-active candidate: one reset at intervalSec, then play without resets to the horizon. */
+function recover(request, intervalSec) {
+    // A probe: its runs are measurement only and emit nothing to the caller's observer.
+    const scenario = silent(request.createScenario());
+    const { E } = scenario.ctx;
+    const blank = E.toString(E.zero());
+    // horizonSec is elapsed time from the scenario origin, as executeResetCycles reads it.
+    if (!(intervalSec <= request.horizonSec)) {
+        return { metric: request.recovery.metric, status: "censored", seconds: null, threshold: blank };
+    }
+    const constraints = scenario.constraints;
+    const lead = play(scenario, scenario.initial, constraints, adapterAt(request, scenario, scenario.initial, constraints), intervalSec);
+    const threshold = recoveryMetric(request, scenario, lead.end, liveCtx(scenario, constraints));
+    // Resolve the adapter where the reset happens. A prestige action can appear only after the lead.
+    const adapter = adapterAt(request, scenario, lead.end, constraints);
+    if (!adapter)
+        return { metric: request.recovery.metric, status: "unsupported", seconds: null, threshold: blank };
+    const committed = commitReset(scenario, lead.end, constraints, adapter, false);
+    if (!committed.ok) {
+        return { metric: request.recovery.metric, status: "unsupported", seconds: null, threshold: E.toString(threshold) };
+    }
+    const remaining = request.horizonSec - runElapsedSec(lead);
+    const afterCtx = liveCtx(scenario, committed.constraints);
+    if (!(remaining > 0)) {
+        if (E.cmp(recoveryMetric(request, scenario, committed.state, afterCtx), threshold) >= 0) {
+            return { metric: request.recovery.metric, status: "observed", seconds: 0, threshold: E.toString(threshold) };
+        }
+        return { metric: request.recovery.metric, status: "censored", seconds: null, threshold: E.toString(threshold) };
+    }
+    const search = play(scenario, committed.state, committed.constraints, adapter, remaining, (state) => E.cmp(recoveryMetric(request, scenario, state, afterCtx), threshold) >= 0);
+    if (E.cmp(recoveryMetric(request, scenario, search.end, afterCtx), threshold) < 0) {
+        return { metric: request.recovery.metric, status: "censored", seconds: null, threshold: E.toString(threshold) };
+    }
+    return {
+        metric: request.recovery.metric,
+        status: "observed",
+        // The runner's accumulated duration. Absolute clocks round each addition at a large origin.
+        seconds: runElapsedSec(search),
+        threshold: E.toString(threshold),
+    };
+}
+function unrealizedAt(request, scenario, state, constraints, clocks) {
+    // The dry run sees the constraints the committed resets left, so a cooldown still blocks it.
+    const adapter = adapterAt(request, scenario, state, constraints, clocks);
+    if (!adapter)
+        return scenario.ctx.E.zero();
+    const committed = commitReset(scenario, state, constraints, adapter, false, clocks);
+    return committed.ok ? committed.delta : scenario.ctx.E.zero();
+}
+function objectiveOf(kind, realized, worth, goalReachSec, goalStatus) {
+    if (kind === "final-net-worth")
+        return { value: worth, reading: "stock" };
+    if (kind === "goal-reach-sec") {
+        return goalStatus === "observed" && goalReachSec !== null
+            ? { value: String(goalReachSec), reading: "time" }
+            : { value: "censored", reading: "time" };
+    }
+    return { value: realized, reading: "flow" };
+}
+function candidateFrom(request, scenario, intervalSec, status, snaps, end, incomplete, unrealized, goalReachSec, walls, recovery, endCtx) {
+    const { E } = scenario.ctx;
+    const completed = snaps;
+    const realized = sumAmounts(E, completed.map((snap) => E.from(snap.reward)));
+    const cycleTime = completed.reduce((total, snap) => total + snap.durationSec, 0);
+    const rewardRate = cycleTime > 0 ? E.toString(E.div(realized, cycleTime)) : null;
+    const goalStatus = request.goal
+        ? goalReachSec === null
+            ? "censored"
+            : "observed"
+        : "not-requested";
+    const worth = netWorth(scenario, end, endCtx);
+    const objective = objectiveOf(request.objective, E.toString(realized), E.toString(worth), goalReachSec, goalStatus);
+    return {
+        intervalSec,
+        status,
+        completedCycles: completed.length,
+        realizedReward: E.toString(realized),
+        unrealizedReward: E.toString(unrealized),
+        finalPoints: E.toString(end.prestige.points),
+        finalNetWorth: E.toString(worth),
+        rewardRate,
+        rewardRateDenominator: "completed-cycle-time",
+        incomplete,
+        goalReachSec,
+        goalStatus,
+        recovery,
+        stability: stabilityReport(scenario, completed, request),
+        objectiveValue: objective.value,
+        objectiveReading: objective.reading,
+        resetWallTimes: walls,
+    };
+}
+/** A goal watcher that keeps the first reward time the goal holds on a committed state. */
+function goalWatcher(request, ctxNow, onMet) {
+    const goal = request.goal;
+    if (!goal)
+        return [];
+    return [{ id: GOAL_WATCH_ID, met: (state) => goal(ctxNow(), state), onMet }];
+}
+function evaluateAlwaysActive(request, intervalSec) {
+    const scenario = request.createScenario();
+    const { E } = scenario.ctx;
+    absoluteToleranceOf(E, request.stability.absoluteTolerance);
+    const recovery = recover(request, intervalSec);
+    // Goal times are seconds from the scenario origin, as horizonSec is.
+    const originT = scenario.initial.t;
+    const reached = { t: null };
+    let constraints = scenario.constraints;
+    // Constraints change only at a boundary, so the context of the next interval is known before it runs.
+    let metricCtx = liveCtx(scenario, constraints);
+    // The runner reads the goal on every committed state, so a crossing between resets keeps its own time.
+    const watchers = goalWatcher(request, () => metricCtx, (t) => {
+        if (reached.t === null)
+            reached.t = Math.min(t - originT, request.horizonSec);
+    });
+    // Every run of this candidate shares one ledger and the caller goals already reached.
+    const share = observationShare(scenario);
+    const observed = () => watched(scenario, watchers, share);
+    const snaps = [];
+    let resume;
+    let state = scenario.initial;
+    let elapsed = 0;
+    // The span after the last committed reset is not a completed cycle, refused intervals included.
+    // Reset times are elapsed seconds from the scenario origin, as horizonSec and scheduled reset walls are.
+    const resetTimes = [];
+    let elapsedAtLastReset = 0;
+    let refused = false;
+    let unsupported = false;
+    while (snaps.length < request.cycleBudget) {
+        metricCtx = liveCtx(scenario, constraints);
+        // The executor resolves the adapter at each boundary, so a prestige action unlocked during the interval counts.
+        const step = executeResetCycles({
+            scenario: observed(),
+            policy: { kind: "fixed-interval", intervalSec, cycles: 1 },
+            horizonSec: request.horizonSec,
+            ...(request.adapter ? { adapter: request.adapter } : {}),
+            ...(resume ? { resume } : {}),
+        });
+        const row = step.artifact.cycles[0];
+        state = step.state;
+        constraints = step.constraints;
+        resume = step.checkpoint;
+        elapsed = step.artifact.globalElapsedSec;
+        if (step.artifact.status === "unsupported") {
+            unsupported = true;
+            break;
+        }
+        if (!row || row.resetAtSec === null) {
+            refused = row?.resetSkippedReason !== undefined;
+            break;
+        }
+        snaps.push({ reward: row.rewardDelta, durationSec: row.durationSec, multiplier: row.carried.multiplier });
+        // The executor admits a boundary a few ULPs past the horizon. Its position is the horizon.
+        elapsedAtLastReset = Math.min(elapsed, request.horizonSec);
+        resetTimes.push(elapsedAtLastReset);
+        // The executor's interval run recorded the state before the reset. The reset state can meet a caller goal first.
+        readCallerGoals(scenario, state, share);
+    }
+    metricCtx = liveCtx(scenario, constraints);
+    // horizonSec is elapsed time from the scenario origin. The tail is what the cycles did not play.
+    // Only rounding dust of the elapsed sum is skipped, so a long horizon still plays a real remainder.
+    const tail = request.horizonSec - elapsed;
+    if (tail > Math.max(RUNNER_MIN_DURATION_SEC, horizonDust(request.horizonSec, elapsed))) {
+        const played = play(observed(), state, constraints, adapterAt(request, scenario, state, constraints), tail);
+        state = played.end;
+        elapsed += runElapsedSec(played);
+    }
+    const openSec = elapsed - elapsedAtLastReset;
+    const incomplete = openSec > Math.max(RUNNER_MIN_DURATION_SEC, horizonDust(request.horizonSec, elapsed)) ? { startSec: elapsedAtLastReset, endSec: elapsed, durationSec: openSec } : null;
+    // A goal met only by the last committed reset has no later run to read it.
+    // Read on a copy, as the runner reads goals, so a predicate that writes its argument cannot change the result.
+    if (request.goal && reached.t === null && request.goal(metricCtx, deepClonePreservingPrototype(state))) {
+        reached.t = Math.min(state.t - originT, request.horizonSec);
+    }
+    const unrealized = incomplete ? unrealizedAt(request, scenario, state, constraints) : E.zero();
+    const status = unsupported && snaps.length === 0
+        ? "unsupported"
+        : refused || unsupported
+            ? "incomplete"
+            : snaps.length === 0
+                ? "censored"
+                : "ok";
+    return {
+        engine: E,
+        report: candidateFrom(request, scenario, intervalSec, status, snaps, state, incomplete, unrealized, reached.t, resetTimes, recovery, metricCtx),
+    };
+}
+/**
+ * Play the session schedule once. Active blocks run with clocks when the model reads them, a manual reset commits
+ * only inside a block, and the gaps between blocks apply the scenario's offline progression, as
+ * `simulateSessionPattern` does. Reaching the cycle budget, a refusal, or a missing adapter stops further resets,
+ * not the schedule, so every candidate is played to the same horizon.
+ */
+function playSchedule(request, scenario, intervalSec, options) {
+    const session = request.session;
+    if (!session)
+        throw new ResetPolicyRejected("reset policy session is missing");
+    const { E } = scenario.ctx;
+    const originT = scenario.initial.t;
+    const blocks = horizonBlocks(request);
+    let state = scenario.initial;
+    let constraints = scenario.constraints;
+    let wall = 0;
+    let activeSec = 0;
+    let lastResetWall = 0;
+    // Where active play last reached. A reset delay advances wall time but is not active play.
+    let activeReach = 0;
+    let resetsOpen = true;
+    let refused = false;
+    let unsupported = false;
+    const snaps = [];
+    const walls = [];
+    const reached = { t: null };
+    let recovery = null;
+    // The running segment, so a watcher's reward time maps back to wall time. Active play advances both clocks
+    // together. An offline gap credits reward by its cap and decay, so its wall position is the absence that earned it.
+    let segment = {
+        wallStart: 0,
+        rewardStart: state.t,
+        offlineRequested: null,
+    };
+    const wallOf = (t) => {
+        const credited = Math.max(0, t - segment.rewardStart);
+        return (segment.wallStart +
+            (segment.offlineRequested === null
+                ? credited
+                : offlineAbsenceForCredit(credited, segment.offlineRequested, scenario.run.offline)));
+    };
+    const clocksFor = (wallStart, wallEnd) => (scenario.model.clocks?.respondsTo?.length ?? 0) > 0
+        ? { wallT: originT + wallStart, wallEndT: originT + wallEnd, rewardT: state.t, activeT: activeSec }
+        : undefined;
+    // The context a segment starting at this wall time would see. Watchers read the context of the running segment.
+    // Inside an active block the model sees that block's clocks, as simulateSessionPattern plays a block as one segment.
+    // A reset or a delay splits the block for this analysis only, so it does not move the clocks.
+    let blockClocks = null;
+    const ctxAt = (wallEnd) => {
+        const clocks = blockClocks ? blockClocks.clocks : clocksFor(wall, wallEnd);
+        return { ...liveCtx(scenario, constraints), ...(clocks ? { clocks } : {}) };
+    };
+    let segmentCtx = ctxAt(wall);
+    // Segments share one ledger and the caller goals already reached, as simulateSessionPattern's segments do.
+    const share = observationShare(scenario);
+    const goalWatchers = options.watchGoal
+        ? goalWatcher(request, () => segmentCtx, (t) => {
+            if (reached.t === null)
+                reached.t = wallOf(t);
+        })
+        : [];
+    const watchers = [...goalWatchers];
+    // A goal first met on a boundary read closes its watcher too, so later runs do not read the predicate again.
+    const reachGoalAt = (wallAt) => {
+        reached.t = wallAt;
+        for (const watcher of goalWatchers)
+            share.reachedWatchers.add(watcher);
+    };
+    const runActive = (durationSec) => {
+        segmentCtx = ctxAt(wall + durationSec);
+        segment = { wallStart: wall, rewardStart: state.t, offlineRequested: null };
+        const played = play(watched(scenario, watchers, share), state, constraints, adapterAt(request, scenario, state, constraints), durationSec, undefined, blockClocks ? blockClocks.clocks : clocksFor(wall, wall + durationSec));
+        activeSec += runElapsedSec(played);
+        state = played.end;
+        wall += durationSec;
+        activeReach = wall;
+    };
+    const runOffline = (toWall) => {
+        if (!(wall < toWall))
+            return;
+        segmentCtx = ctxAt(toWall);
+        segment = { wallStart: wall, rewardStart: state.t, offlineRequested: toWall - wall };
+        const clocks = clocksFor(wall, toWall);
+        const base = watched(scenario, watchers, share);
+        const offline = applyOfflineSeconds({
+            scenario: {
+                ...base,
+                ...(clocks ? { ctx: { ...base.ctx, clocks } } : {}),
+                model: withoutResetActions(base.model, adapterAt(request, scenario, state, constraints)),
+                ...(constraints ? { constraints } : {}),
+            },
+            seconds: toWall - wall,
+            options: {
+                fromState: state,
+                actions: scenario.run.offline?.actions ?? { mode: "legacy-all" },
+                fast: scenario.run.fast,
+                policy: scenario.run.offline,
+            },
+        });
+        state = offline.end;
+        wall = toWall;
+    };
+    for (const block of blocks) {
+        runOffline(block.start);
+        if (wall < block.start)
+            wall = block.start;
+        blockClocks = { clocks: clocksFor(block.start, block.end) };
+        while (resetsOpen && snaps.length < options.budget) {
+            const next = Math.max(lastResetWall + intervalSec, wall);
+            // A sum of intervals can round a few ULPs past the horizon. That boundary is the horizon, as the executor admits it.
+            if (!(next < block.natural && next <= request.horizonSec + horizonDust(request.horizonSec, next)))
+                break;
+            const at = Math.min(next, request.horizonSec);
+            if (at > wall)
+                runActive(at - wall);
+            const boundaryCtx = ctxAt(block.end);
+            const adapter = adapterAt(request, scenario, state, constraints, boundaryCtx.clocks);
+            if (!adapter) {
+                unsupported = true;
+                resetsOpen = false;
+                break;
+            }
+            const threshold = recoveryMetric(request, scenario, state, boundaryCtx);
+            // With no runner since the previous reset, as after a delay that covers the interval, the boundary state has
+            // not been read at this wall time. A clock-aware goal can first hold here, before the reset changes the state.
+            const boundaryGoal = request.goal;
+            if (options.watchGoal && boundaryGoal && reached.t === null && boundaryGoal(boundaryCtx, deepClonePreservingPrototype(state))) {
+                reachGoalAt(at);
+            }
+            const committed = commitReset(scenario, state, constraints, adapter, options.emit, boundaryCtx.clocks);
+            if (!committed.ok) {
+                refused = true;
+                resetsOpen = false;
+                break;
+            }
+            // Reset eligibility and the horizon are wall time, so a cycle lasts from the previous reset wall to this one,
+            // reset delay and capped offline time included.
+            snaps.push({
+                reward: E.toString(committed.delta),
+                durationSec: at - lastResetWall,
+                multiplier: E.toString(committed.state.prestige.multiplier),
+            });
+            state = committed.state;
+            constraints = committed.constraints;
+            walls.push(at);
+            activeReach = at;
+            // The reset is the latest segment of the block. With no runner after it, as at a horizon-start block, the final
+            // reads keep the block's clocks.
+            segmentCtx = ctxAt(block.end);
+            // The reset state can be the first to meet a caller goal. A reset at the horizon has no later run to read it.
+            if (options.emit)
+                readCallerGoals(scenario, state, share);
+            // Two resets can follow each other with no runner in between when the delay covers the interval, so the
+            // goal is read on the committed reset state too, on a copy as the runner reads it.
+            const goal = request.goal;
+            if (options.watchGoal && goal && reached.t === null && goal(ctxAt(block.end), deepClonePreservingPrototype(state))) {
+                reachGoalAt(at);
+            }
+            if (options.watchRecovery && recovery === null) {
+                const found = { threshold, resetWall: at, crossedWall: null };
+                recovery = found;
+                if (E.cmp(recoveryMetric(request, scenario, state, ctxAt(block.end)), threshold) >= 0)
+                    found.crossedWall = at;
+                else {
+                    watchers.push({
+                        id: RECOVERY_WATCH_ID,
+                        met: (next) => E.cmp(recoveryMetric(request, scenario, next, segmentCtx), threshold) >= 0,
+                        onMet: (t) => {
+                            if (found.crossedWall === null)
+                                found.crossedWall = wallOf(t);
+                        },
+                    });
+                }
+            }
+            lastResetWall = at;
+            // The caller's delay advances wall time and grants no income.
+            wall = at + session.resetDelaySec;
+        }
+        if (wall < block.end)
+            runActive(block.end - wall);
+        blockClocks = null;
+    }
+    const activeWallEnd = activeReach;
+    // The rest of the horizon is away time and applies the offline progression.
+    runOffline(request.horizonSec);
+    // A reset delay can carry the wall cursor past the horizon. The final reads happen at the horizon.
+    if (wall > request.horizonSec)
+        wall = request.horizonSec;
+    // The final reads see the clocks of the last segment played, the active block's when the horizon falls inside one,
+    // with the constraints the resets left.
+    const endClocks = segmentCtx.clocks;
+    const endCtx = { ...liveCtx(scenario, constraints), ...(endClocks ? { clocks: endClocks } : {}) };
+    const goal = request.goal;
+    if (options.watchGoal && goal && reached.t === null && goal(endCtx, deepClonePreservingPrototype(state))) {
+        reachGoalAt(wall);
+    }
+    // A delay past the horizon leaves no runner after the reset, so an open recovery crossing is read here too.
+    const openRecovery = recovery;
+    if (openRecovery &&
+        openRecovery.crossedWall === null &&
+        E.cmp(recoveryMetric(request, scenario, state, endCtx), openRecovery.threshold) >= 0) {
+        openRecovery.crossedWall = wall;
+    }
+    return {
+        snaps,
+        walls,
+        state,
+        constraints,
+        refused,
+        unsupported,
+        activeWallEnd,
+        lastResetWall: walls.length > 0 ? lastResetWall : 0,
+        endCtx,
+        goalReachSec: reached.t,
+        recovery,
+    };
+}
+function evaluateSession(request, intervalSec) {
+    const scenario = request.createScenario();
+    const { E } = scenario.ctx;
+    absoluteToleranceOf(E, request.stability.absoluteTolerance);
+    // Recovery is measured on this candidate's own schedule: its first committed reset, then no further resets.
+    // The probe is measurement only: its runs emit nothing to the caller's observer.
+    const probe = playSchedule(request, silent(request.createScenario()), intervalSec, {
+        budget: 1,
+        emit: false,
+        watchRecovery: true,
+        watchGoal: false,
+    });
+    const blank = E.toString(E.zero());
+    const recovery = probe.recovery
+        ? {
+            metric: request.recovery.metric,
+            status: probe.recovery.crossedWall === null ? "censored" : "observed",
+            // Wall seconds, as the interval and horizon are, so a reset delay or a capped absence counts in full.
+            seconds: probe.recovery.crossedWall === null ? null : probe.recovery.crossedWall - probe.recovery.resetWall,
+            threshold: E.toString(probe.recovery.threshold),
+        }
+        : {
+            metric: request.recovery.metric,
+            status: probe.refused || probe.unsupported ? "unsupported" : "censored",
+            seconds: null,
+            threshold: blank,
+        };
+    const outcome = playSchedule(request, scenario, intervalSec, {
+        budget: request.cycleBudget,
+        emit: true,
+        watchRecovery: false,
+        watchGoal: true,
+    });
+    // The span after the last committed reset is not a completed cycle, as on the always-active path.
+    const incomplete = outcome.lastResetWall + horizonDust(request.horizonSec, outcome.lastResetWall) < request.horizonSec
+        ? { startSec: outcome.lastResetWall, endSec: request.horizonSec, durationSec: request.horizonSec - outcome.lastResetWall }
+        : null;
+    // A manual reset needs active play at the horizon. An offline span or a reset delay there has nothing to realize,
+    // and a reset committed at the horizon leaves no incomplete span to realize after.
+    const activeAtHorizon = outcome.activeWallEnd + horizonDust(request.horizonSec, outcome.activeWallEnd) >= request.horizonSec;
+    const unrealized = incomplete && activeAtHorizon
+        ? unrealizedAt(request, scenario, outcome.state, outcome.constraints, outcome.endCtx.clocks)
+        : E.zero();
+    const status = outcome.unsupported && outcome.snaps.length === 0
+        ? "unsupported"
+        : outcome.refused || outcome.unsupported
+            ? "incomplete"
+            : outcome.snaps.length === 0
+                ? "censored"
+                : "ok";
+    return {
+        engine: E,
+        report: candidateFrom(request, scenario, intervalSec, status, outcome.snaps, outcome.state, incomplete, unrealized, outcome.goalReachSec, outcome.walls, recovery, outcome.endCtx),
+    };
+}
+function better(kind, left, right, E) {
+    if (left.status === "unsupported")
+        return false;
+    if (right.status === "unsupported")
+        return true;
+    if (kind === "goal-reach-sec") {
+        if (left.goalStatus !== "observed" || left.goalReachSec === null)
+            return false;
+        if (right.goalStatus !== "observed" || right.goalReachSec === null)
+            return true;
+        return left.goalReachSec < right.goalReachSec;
+    }
+    if (left.objectiveValue === "censored")
+        return false;
+    if (right.objectiveValue === "censored")
+        return true;
+    return E.cmp(E.from(left.objectiveValue), E.from(right.objectiveValue)) > 0;
+}
+/**
+ * Compare reset intervals on one horizon.
+ * Each candidate starts from `createScenario`. Completed resets stay separate from the trailing uncommitted span.
+ *
+ * @evidence docs/requirements/active/reset-cycle-analysis.md#req-pr11-reward-rate The comparison ranks committed reward and leaves the tail unrealized.
+ * @evidenceReview docs/requirements/active/reset-cycle-analysis.md#req-pr11-reward-rate #9ef48a3 Re-read the section: four resets realize 4, and the unfinished span does not join that total.
+ */
+export function analyzeResetPolicies(request) {
+    assertRequest(request);
+    const intervals = scanIntervals(request.scan);
+    const evaluated = intervals.map((interval) => request.session ? evaluateSession(request, interval) : evaluateAlwaysActive(request, interval));
+    const first = evaluated[0];
+    if (!first)
+        throw new ResetPolicyRejected("reset policy scan produced no candidates");
+    let bestIndex = 0;
+    for (let index = 1; index < evaluated.length; index += 1) {
+        const candidate = evaluated[index];
+        const winner = evaluated[bestIndex];
+        if (!candidate || !winner)
+            continue;
+        if (better(request.objective, candidate.report, winner.report, first.engine))
+            bestIndex = index;
+    }
+    const bestEval = evaluated[bestIndex] ?? first;
+    const bestReport = bestEval.report;
+    const known = request.knownSolution
+        ? {
+            fixtureId: request.knownSolution.fixtureId,
+            expectedRate: request.knownSolution.expectedRate,
+            observedRate: bestReport.rewardRate ?? "",
+            matches: bestReport.rewardRate !== null &&
+                bestEval.engine.cmp(bestEval.engine.from(bestReport.rewardRate), bestEval.engine.from(request.knownSolution.expectedRate)) ===
+                    0,
+        }
+        : null;
+    const assumptions = [
+        "realized reward sums committed reset deltas and excludes stock already held",
+        "reward rate divides that sum by completed cycle time, not by stock or the horizon",
+        "unrealized reward is the uncommitted reset after the incomplete span and is not ranked",
+        "recovery seconds are the first threshold crossing inside the horizon, otherwise censored",
+        "each candidate starts from createScenario",
+        "empirical window agreement is not a proof of a steady state",
+    ];
+    if (request.session) {
+        assumptions.push("manual reset is committed only inside an active session block");
+        assumptions.push("resetDelaySec is the caller input, advances wall time, and grants no income");
+        assumptions.push("offline gaps apply the scenario's offline progression and do not commit a reset");
+        assumptions.push("the cycle budget or a refused reset stops further resets, not the schedule");
+    }
+    const censoredGoal = request.objective === "goal-reach-sec" && bestReport.goalStatus === "censored";
+    // A winner that stopped on a refusal did not finish its requested evaluation, so the artifact is not ok.
+    const status = evaluated.every((entry) => entry.report.status === "unsupported")
+        ? "unsupported"
+        : bestReport.status === "censored" || censoredGoal
+            ? "censored"
+            : bestReport.status === "incomplete"
+                ? "incomplete"
+                : bestReport.stability.status === "insufficient-data"
+                    ? "insufficient-data"
+                    : "ok";
+    return {
+        schemaVersion: 1,
+        algorithmVersion: RESET_POLICY_ALGORITHM_VERSION,
+        status,
+        objective: request.objective,
+        scope: "scan-range",
+        globalOptimum: false,
+        best: {
+            intervalSec: bestReport.intervalSec,
+            objective: {
+                kind: request.objective,
+                reading: bestReport.objectiveReading,
+                value: bestReport.objectiveValue,
+            },
+            comparison: {
+                fromSec: request.scan.fromSec,
+                toSec: request.scan.toSec,
+                stepSec: request.scan.stepSec,
+                horizonSec: request.horizonSec,
+                candidateCount: evaluated.length,
+                scope: "scan-range",
+                globalOptimum: false,
+            },
+            session: {
+                assumed: request.session ? "scheduled" : "always-active",
+                patternId: request.session?.pattern.id ?? null,
+                resetDelaySec: request.session?.resetDelaySec ?? null,
+            },
+            observation: {
+                status: bestReport.stability.status,
+                stability: bestReport.stability.status,
+                provedSteadyState: false,
+                recovery: bestReport.recovery.status,
+            },
+        },
+        candidates: evaluated.map((entry) => entry.report),
+        knownSolution: known,
+        assumptions,
+        warnings: [
+            "legacy breakEvenSec and stability are not this artifact",
+            "empirical window agreement is not a mathematical steady state",
+            "the best candidate is the scan-range winner, not a global optimum",
+        ],
+    };
+}
+//# sourceMappingURL=resetOptimization.js.map