@sipemu/anofox-forecast 0.4.5 → 0.4.6

package/anofox_forecast_js.js

@@ -188,6 +188,10 @@ const AutoEnsembleForecasterFinalization = (typeof FinalizationRegistry === 'und
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_autoensembleforecaster_free(ptr >>> 0, 1));
 
+const AutoForecastBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_autoforecastbuilder_free(ptr >>> 0, 1));
+
 const AutoForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_autoforecaster_free(ptr >>> 0, 1));
@@ -256,6 +260,10 @@ const JsConformalResultFinalization = (typeof FinalizationRegistry === 'undefine
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_jsconformalresult_free(ptr >>> 0, 1));
 
+const JsDataProfileFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jsdataprofile_free(ptr >>> 0, 1));
+
 const JsHistoricalSimResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_jshistoricalsimresult_free(ptr >>> 0, 1));
@@ -264,6 +272,10 @@ const JsHistoricalSimulatorFinalization = (typeof FinalizationRegistry === 'unde
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_jshistoricalsimulator_free(ptr >>> 0, 1));
 
+const JsModelDiagnosticsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jsmodeldiagnostics_free(ptr >>> 0, 1));
+
 const JsNormalPredictorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_jsnormalpredictor_free(ptr >>> 0, 1));
@@ -272,6 +284,18 @@ const JsNormalResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_jsnormalresult_free(ptr >>> 0, 1));
 
+const JsPipelineBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jspipelinebuilder_free(ptr >>> 0, 1));
+
+const JsPipelineReportFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jspipelinereport_free(ptr >>> 0, 1));
+
+const JsPipelineResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jspipelineresult_free(ptr >>> 0, 1));
+
 const JsPointForecastsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_jspointforecasts_free(ptr >>> 0, 1));
@@ -288,6 +312,10 @@ const JsTrainedModelFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_jstrainedmodel_free(ptr >>> 0, 1));
 
+const KalmanForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_kalmanforecaster_free(ptr >>> 0, 1));
+
 const MFLESForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_mflesforecaster_free(ptr >>> 0, 1));
@@ -352,6 +380,10 @@ const TimeSeriesFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_timeseries_free(ptr >>> 0, 1));
 
+const VARForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_varforecaster_free(ptr >>> 0, 1));
+
 const WindowAverageForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_windowaverageforecaster_free(ptr >>> 0, 1));
@@ -825,6 +857,113 @@ export class AutoEnsembleForecaster {
 }
 if (Symbol.dispose) AutoEnsembleForecaster.prototype[Symbol.dispose] = AutoEnsembleForecaster.prototype.free;
 
+/**
+ * Builder for constructing an AutoForecaster with custom parameters.
+ *
+ * Uses a fluent API: chain setter methods and call `build()` to produce
+ * an `AutoForecaster`.
+ */
+export class AutoForecastBuilder {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(AutoForecastBuilder.prototype);
+        obj.__wbg_ptr = ptr;
+        AutoForecastBuilderFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AutoForecastBuilderFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_autoforecastbuilder_free(ptr, 0);
+    }
+    /**
+     * Include or exclude AutoETS from the candidate set.
+     *
+     * @param include - Whether to include AutoETS (default: true)
+     * @param {boolean} include
+     * @returns {AutoForecastBuilder}
+     */
+    includeEts(include) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.autoforecastbuilder_includeEts(ptr, include);
+        return AutoForecastBuilder.__wrap(ret);
+    }
+    /**
+     * Include or exclude AutoARIMA from the candidate set.
+     *
+     * @param include - Whether to include AutoARIMA (default: true)
+     * @param {boolean} include
+     * @returns {AutoForecastBuilder}
+     */
+    includeArima(include) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.autoforecastbuilder_includeArima(ptr, include);
+        return AutoForecastBuilder.__wrap(ret);
+    }
+    /**
+     * Include or exclude AutoTheta from the candidate set.
+     *
+     * @param include - Whether to include AutoTheta (default: true)
+     * @param {boolean} include
+     * @returns {AutoForecastBuilder}
+     */
+    includeTheta(include) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.autoforecastbuilder_includeTheta(ptr, include);
+        return AutoForecastBuilder.__wrap(ret);
+    }
+    /**
+     * Set the seasonal period.
+     *
+     * @param period - Seasonal period (e.g., 12 for monthly data)
+     * @param {number} period
+     * @returns {AutoForecastBuilder}
+     */
+    seasonalPeriod(period) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.autoforecastbuilder_seasonalPeriod(ptr, period);
+        return AutoForecastBuilder.__wrap(ret);
+    }
+    /**
+     * Use cross-validation instead of in-sample MSE for model selection.
+     *
+     * @param useCv - Whether to use cross-validation (default: false)
+     * @param {boolean} use_cv
+     * @returns {AutoForecastBuilder}
+     */
+    useCrossValidation(use_cv) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.autoforecastbuilder_useCrossValidation(ptr, use_cv);
+        return AutoForecastBuilder.__wrap(ret);
+    }
+    /**
+     * Create a new builder with all defaults enabled.
+     */
+    constructor() {
+        const ret = wasm.autoforecastbuilder_new();
+        this.__wbg_ptr = ret >>> 0;
+        AutoForecastBuilderFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Build the AutoForecaster with the configured parameters.
+     *
+     * @returns A new AutoForecaster ready to fit
+     * @returns {AutoForecaster}
+     */
+    build() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.autoforecastbuilder_build(ptr);
+        return AutoForecaster.__wrap(ret);
+    }
+}
+if (Symbol.dispose) AutoForecastBuilder.prototype[Symbol.dispose] = AutoForecastBuilder.prototype.free;
+
 /**
  * Automatic model selection across ARIMA, ETS, and Theta families.
  *
@@ -1688,6 +1827,23 @@ export class EnsembleForecaster {
     setMedian() {
         wasm.ensembleforecaster_setMedian(this.__wbg_ptr);
     }
+    /**
+     * Set the combination method by name string.
+     *
+     * Supported values: "mean", "median", "weighted_mse", "inverse_aic",
+     * "stacking", "horizon_adaptive".
+     *
+     * @param method - Combination method name
+     * @param {string} method
+     */
+    setMethod(method) {
+        const ptr0 = passStringToWasm0(method, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ensembleforecaster_setMethod(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * Get the number of models in the ensemble.
      * @returns {number}
@@ -1709,12 +1865,40 @@ export class EnsembleForecaster {
         const len0 = WASM_VECTOR_LEN;
         wasm.ensembleforecaster_setWeights(this.__wbg_ptr, ptr0, len0);
     }
+    /**
+     * Set the combination method to stacking (projected gradient descent).
+     *
+     * Trains non-negative weights that sum to one on validation data.
+     *
+     * @param folds - Number of folds (default: 5)
+     * @param {number | null} [folds]
+     */
+    setStacking(folds) {
+        wasm.ensembleforecaster_setStacking(this.__wbg_ptr, isLikeNone(folds) ? 0x100000001 : (folds) >>> 0);
+    }
+    /**
+     * Set the combination method to inverse AIC weighting.
+     *
+     * Computes Akaike weights from in-sample residuals.
+     */
+    setInverseAic() {
+        wasm.ensembleforecaster_setInverseAic(this.__wbg_ptr);
+    }
     /**
      * Set the combination method to weighted MSE.
      */
     setWeightedMse() {
         wasm.ensembleforecaster_setWeightedMse(this.__wbg_ptr);
     }
+    /**
+     * Set the combination method to per-horizon adaptive weighting.
+     *
+     * Computes separate weight vectors for each forecast horizon step
+     * based on rolling-origin evaluation.
+     */
+    setHorizonAdaptive() {
+        wasm.ensembleforecaster_setHorizonAdaptive(this.__wbg_ptr);
+    }
     /**
      * Predict with prediction intervals.
      *
@@ -1822,6 +2006,36 @@ export class Forecast {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_forecast_free(ptr, 0);
     }
+    /**
+     * Return a new forecast with all values clamped to be non-negative.
+     * @returns {Forecast}
+     */
+    nonNegative() {
+        const ret = wasm.forecast_nonNegative(this.__wbg_ptr);
+        return Forecast.__wrap(ret);
+    }
+    /**
+     * Return a new forecast with point values rounded to the nearest integer,
+     * lower intervals floored, and upper intervals ceiled.
+     * @returns {Forecast}
+     */
+    roundToInteger() {
+        const ret = wasm.forecast_roundToInteger(this.__wbg_ptr);
+        return Forecast.__wrap(ret);
+    }
+    /**
+     * Return a new forecast with all values clamped to `[lower, upper]`.
+     *
+     * @param lower - Lower bound
+     * @param upper - Upper bound
+     * @param {number} lower
+     * @param {number} upper
+     * @returns {Forecast}
+     */
+    clamp(lower, upper) {
+        const ret = wasm.forecast_clamp(this.__wbg_ptr, lower, upper);
+        return Forecast.__wrap(ret);
+    }
     /**
      * Get lower prediction interval bounds.
      *
@@ -2513,256 +2727,1205 @@ export class JsConformalResult {
 if (Symbol.dispose) JsConformalResult.prototype[Symbol.dispose] = JsConformalResult.prototype.free;
 
 /**
- * Historical simulation result — stores the empirical error distribution.
+ * Automated data profile — stationarity, trend, seasonality, quality score.
+ *
+ * Profile a time series to understand its characteristics before model selection.
  */
-export class JsHistoricalSimResult {
+export class JsDataProfile {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(JsHistoricalSimResult.prototype);
+        const obj = Object.create(JsDataProfile.prototype);
         obj.__wbg_ptr = ptr;
-        JsHistoricalSimResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        JsDataProfileFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        JsHistoricalSimResultFinalization.unregister(this);
+        JsDataProfileFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_jshistoricalsimresult_free(ptr, 0);
+        wasm.__wbg_jsdataprofile_free(ptr, 0);
     }
     /**
-     * Get the quantile values.
-     * @returns {Float64Array}
+     * Whether every finite value is integer-valued.
+     * @returns {boolean}
      */
-    quantileValues() {
-        const ret = wasm.jshistoricalsimresult_quantileValues(this.__wbg_ptr);
-        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v1;
+    get isInteger() {
+        const ret = wasm.jsdataprofile_isInteger(this.__wbg_ptr);
+        return ret !== 0;
     }
     /**
-     * Get the sorted errors.
-     * @returns {Float64Array}
+     * Lempel-Ziv complexity (normalized).
+     * @returns {number}
      */
-    errors() {
-        const ret = wasm.jshistoricalsimresult_errors(this.__wbg_ptr);
-        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v1;
-    }
-}
-if (Symbol.dispose) JsHistoricalSimResult.prototype[Symbol.dispose] = JsHistoricalSimResult.prototype.free;
-
-/**
- * Historical simulator — non-parametric prediction intervals
- * based on the empirical error distribution.
- */
-export class JsHistoricalSimulator {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(JsHistoricalSimulator.prototype);
-        obj.__wbg_ptr = ptr;
-        JsHistoricalSimulatorFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        JsHistoricalSimulatorFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_jshistoricalsimulator_free(ptr, 0);
+    get lempelZiv() {
+        const ret = wasm.jsdataprofile_lempelZiv(this.__wbg_ptr);
+        return ret;
     }
     /**
-     * Create a simulator with a rolling window.
-     *
-     * @param quantiles - Sorted quantile levels in (0,1)
-     * @param window - Number of recent observations to use
-     * @param {Float64Array} quantiles
-     * @param {number} window
-     * @returns {JsHistoricalSimulator}
+     * ADF p-value.
+     * @returns {number}
      */
-    static withWindow(quantiles, window) {
-        const ptr0 = passArrayF64ToWasm0(quantiles, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.jshistoricalsimulator_withWindow(ptr0, len0, window);
-        return JsHistoricalSimulator.__wrap(ret);
+    get adfPValue() {
+        const ret = wasm.jsdataprofile_adfPValue(this.__wbg_ptr);
+        return ret;
     }
     /**
-     * Generate prediction intervals for new point forecasts.
+     * Profile a time series.
      *
-     * @param result - A fitted JsHistoricalSimResult from simulate()
-     * @param pointForecasts - New point forecast values
-     * @param {JsHistoricalSimResult} result
-     * @param {Float64Array} point_forecasts
-     * @returns {JsPredictionIntervals}
+     * @param series - TimeSeries to profile
+     * @returns A comprehensive data profile
+     * @param {TimeSeries} series
+     * @returns {JsDataProfile}
      */
-    predictIntervals(result, point_forecasts) {
-        _assertClass(result, JsHistoricalSimResult);
-        const ptr0 = passArrayF64ToWasm0(point_forecasts, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.jshistoricalsimulator_predictIntervals(this.__wbg_ptr, result.__wbg_ptr, ptr0, len0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return JsPredictionIntervals.__wrap(ret[0]);
+    static fromSeries(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.jsdataprofile_fromSeries(series.__wbg_ptr);
+        return JsDataProfile.__wrap(ret);
     }
     /**
-     * Create a new historical simulator.
+     * Profile raw values (without timestamps).
      *
-     * @param quantiles - Sorted quantile levels in (0,1), e.g. [0.1, 0.5, 0.9]
-     * @param {Float64Array} quantiles
+     * @param values - Array of numeric values
+     * @returns A data profile
+     * @param {Float64Array} values
+     * @returns {JsDataProfile}
      */
-    constructor(quantiles) {
-        const ptr0 = passArrayF64ToWasm0(quantiles, wasm.__wbindgen_malloc);
+    static fromValues(values) {
+        const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.jshistoricalsimulator_new(ptr0, len0);
-        this.__wbg_ptr = ret >>> 0;
-        JsHistoricalSimulatorFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+        const ret = wasm.jsdataprofile_fromValues(ptr0, len0);
+        return JsDataProfile.__wrap(ret);
     }
     /**
-     * Fit the simulator on historical forecasts and actuals.
-     *
-     * @param forecasts - Historical point forecast values
-     * @param actuals - Corresponding actual observed values
-     * @param {Float64Array} forecasts
-     * @param {Float64Array} actuals
-     * @returns {JsHistoricalSimResult}
+     * Slope of the linear trend.
+     * @returns {number}
      */
-    simulate(forecasts, actuals) {
-        const ptr0 = passArrayF64ToWasm0(forecasts, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArrayF64ToWasm0(actuals, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.jshistoricalsimulator_simulate(this.__wbg_ptr, ptr0, len0, ptr1, len1);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return JsHistoricalSimResult.__wrap(ret[0]);
-    }
-}
-if (Symbol.dispose) JsHistoricalSimulator.prototype[Symbol.dispose] = JsHistoricalSimulator.prototype.free;
-
-/**
- * Normal predictor — assumes Gaussian forecast errors.
- *
- * Generates quantile-based prediction intervals from the estimated
- * error mean and standard deviation.
- */
-export class JsNormalPredictor {
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        JsNormalPredictorFinalization.unregister(this);
-        return ptr;
+    get trendSlope() {
+        const ret = wasm.jsdataprofile_trendSlope(this.__wbg_ptr);
+        return ret;
     }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_jsnormalpredictor_free(ptr, 0);
+    /**
+     * KPSS p-value.
+     * @returns {number}
+     */
+    get kpssPValue() {
+        const ret = wasm.jsdataprofile_kpssPValue(this.__wbg_ptr);
+        return ret;
     }
     /**
-     * Generate prediction intervals for new point forecasts.
-     *
-     * Returns intervals using the first and last quantile as bounds.
-     *
-     * @param result - A fitted JsNormalResult from fit()
-     * @param pointForecasts - New point forecast values
-     * @param {JsNormalResult} result
-     * @param {Float64Array} point_forecasts
-     * @returns {JsPredictionIntervals}
+     * Full profile as a formatted string.
+     * @returns {string}
      */
-    predictIntervals(result, point_forecasts) {
-        _assertClass(result, JsNormalResult);
-        const ptr0 = passArrayF64ToWasm0(point_forecasts, wasm.__wbindgen_malloc);
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsdataprofile_toString(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * ADF test statistic.
+     * @returns {number}
+     */
+    get adfStatistic() {
+        const ret = wasm.jsdataprofile_adfStatistic(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Whether any value is negative.
+     * @returns {boolean}
+     */
+    get hasNegatives() {
+        const ret = wasm.jsdataprofile_hasNegatives(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Combined stationarity (ADF stationary AND KPSS stationary).
+     * @returns {boolean}
+     */
+    get isStationary() {
+        const ret = wasm.jsdataprofile_isStationary(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Count of NaN or infinite values.
+     * @returns {number}
+     */
+    get missingCount() {
+        const ret = wasm.jsdataprofile_missingCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Heuristic data-quality score in [0.0, 1.0].
+     * @returns {number}
+     */
+    get qualityScore() {
+        const ret = wasm.jsdataprofile_qualityScore(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Fraction of values that are exactly zero.
+     * @returns {number}
+     */
+    get zeroFraction() {
+        const ret = wasm.jsdataprofile_zeroFraction(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * KPSS test statistic.
+     * @returns {number}
+     */
+    get kpssStatistic() {
+        const ret = wasm.jsdataprofile_kpssStatistic(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Number of observations.
+     * @returns {number}
+     */
+    get nObservations() {
+        const ret = wasm.jsdataprofile_nObservations(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Trend strength (R-squared, 0.0 to 1.0).
+     * @returns {number}
+     */
+    get trendStrength() {
+        const ret = wasm.jsdataprofile_trendStrength(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Whether the series is classified as intermittent.
+     * @returns {boolean}
+     */
+    get isIntermittent() {
+        const ret = wasm.jsdataprofile_isIntermittent(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Trend direction: "Rising", "Falling", or "Flat".
+     * @returns {string}
+     */
+    get trendDirection() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsdataprofile_trendDirection(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Partial autocorrelation at lag 1.
+     * @returns {number}
+     */
+    get partialAcfLag1() {
+        const ret = wasm.jsdataprofile_partialAcfLag1(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Whether ADF concludes stationarity at 5%.
+     * @returns {boolean}
+     */
+    get adfIsStationary() {
+        const ret = wasm.jsdataprofile_adfIsStationary(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Whether KPSS concludes stationarity at 5%.
+     * @returns {boolean}
+     */
+    get kpssIsStationary() {
+        const ret = wasm.jsdataprofile_kpssIsStationary(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Approximate entropy (undefined if series is too short).
+     * @returns {number | undefined}
+     */
+    get approximateEntropy() {
+        const ret = wasm.jsdataprofile_approximateEntropy(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+    /**
+     * Maximum value.
+     * @returns {number}
+     */
+    get max() {
+        const ret = wasm.jsdataprofile_max(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Minimum value.
+     * @returns {number}
+     */
+    get min() {
+        const ret = wasm.jsdataprofile_min(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Arithmetic mean.
+     * @returns {number}
+     */
+    get mean() {
+        const ret = wasm.jsconformalresult_quantileValue(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Standard deviation.
+     * @returns {number}
+     */
+    get stdDev() {
+        const ret = wasm.jsconformalresult_coverage(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Human-readable summary string.
+     * @returns {string}
+     */
+    summary() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsdataprofile_summary(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Profile as a JSON-serializable object.
+     * @returns {any}
+     */
+    toJSON() {
+        const ret = wasm.jsdataprofile_toJSON(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Autocorrelation at lag 1.
+     * @returns {number}
+     */
+    get acfLag1() {
+        const ret = wasm.jsdataprofile_acfLag1(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Autocorrelation at lag 2.
+     * @returns {number}
+     */
+    get acfLag2() {
+        const ret = wasm.jsdataprofile_acfLag2(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Excess kurtosis.
+     * @returns {number}
+     */
+    get kurtosis() {
+        const ret = wasm.jsdataprofile_kurtosis(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Skewness.
+     * @returns {number}
+     */
+    get skewness() {
+        const ret = wasm.jsdataprofile_skewness(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) JsDataProfile.prototype[Symbol.dispose] = JsDataProfile.prototype.free;
+
+/**
+ * Historical simulation result — stores the empirical error distribution.
+ */
+export class JsHistoricalSimResult {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(JsHistoricalSimResult.prototype);
+        obj.__wbg_ptr = ptr;
+        JsHistoricalSimResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsHistoricalSimResultFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jshistoricalsimresult_free(ptr, 0);
+    }
+    /**
+     * Get the quantile values.
+     * @returns {Float64Array}
+     */
+    quantileValues() {
+        const ret = wasm.jshistoricalsimresult_quantileValues(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Get the sorted errors.
+     * @returns {Float64Array}
+     */
+    errors() {
+        const ret = wasm.jshistoricalsimresult_errors(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+}
+if (Symbol.dispose) JsHistoricalSimResult.prototype[Symbol.dispose] = JsHistoricalSimResult.prototype.free;
+
+/**
+ * Historical simulator — non-parametric prediction intervals
+ * based on the empirical error distribution.
+ */
+export class JsHistoricalSimulator {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(JsHistoricalSimulator.prototype);
+        obj.__wbg_ptr = ptr;
+        JsHistoricalSimulatorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsHistoricalSimulatorFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jshistoricalsimulator_free(ptr, 0);
+    }
+    /**
+     * Create a simulator with a rolling window.
+     *
+     * @param quantiles - Sorted quantile levels in (0,1)
+     * @param window - Number of recent observations to use
+     * @param {Float64Array} quantiles
+     * @param {number} window
+     * @returns {JsHistoricalSimulator}
+     */
+    static withWindow(quantiles, window) {
+        const ptr0 = passArrayF64ToWasm0(quantiles, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.jshistoricalsimulator_withWindow(ptr0, len0, window);
+        return JsHistoricalSimulator.__wrap(ret);
+    }
+    /**
+     * Generate prediction intervals for new point forecasts.
+     *
+     * @param result - A fitted JsHistoricalSimResult from simulate()
+     * @param pointForecasts - New point forecast values
+     * @param {JsHistoricalSimResult} result
+     * @param {Float64Array} point_forecasts
+     * @returns {JsPredictionIntervals}
+     */
+    predictIntervals(result, point_forecasts) {
+        _assertClass(result, JsHistoricalSimResult);
+        const ptr0 = passArrayF64ToWasm0(point_forecasts, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.jshistoricalsimulator_predictIntervals(this.__wbg_ptr, result.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return JsPredictionIntervals.__wrap(ret[0]);
+    }
+    /**
+     * Create a new historical simulator.
+     *
+     * @param quantiles - Sorted quantile levels in (0,1), e.g. [0.1, 0.5, 0.9]
+     * @param {Float64Array} quantiles
+     */
+    constructor(quantiles) {
+        const ptr0 = passArrayF64ToWasm0(quantiles, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.jshistoricalsimulator_new(ptr0, len0);
+        this.__wbg_ptr = ret >>> 0;
+        JsHistoricalSimulatorFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Fit the simulator on historical forecasts and actuals.
+     *
+     * @param forecasts - Historical point forecast values
+     * @param actuals - Corresponding actual observed values
+     * @param {Float64Array} forecasts
+     * @param {Float64Array} actuals
+     * @returns {JsHistoricalSimResult}
+     */
+    simulate(forecasts, actuals) {
+        const ptr0 = passArrayF64ToWasm0(forecasts, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(actuals, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.jshistoricalsimulator_simulate(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return JsHistoricalSimResult.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) JsHistoricalSimulator.prototype[Symbol.dispose] = JsHistoricalSimulator.prototype.free;
+
+/**
+ * Complete model diagnostics report.
+ *
+ * Includes Ljung-Box, Jarque-Bera, and Breusch-Pagan tests, plus
+ * residual ACF/PACF and summary statistics.
+ */
+export class JsModelDiagnostics {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(JsModelDiagnostics.prototype);
+        obj.__wbg_ptr = ptr;
+        JsModelDiagnosticsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsModelDiagnosticsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jsmodeldiagnostics_free(ptr, 0);
+    }
+    /**
+     * Whether all diagnostic tests pass at the configured significance level.
+     * @returns {boolean}
+     */
+    get passesAll() {
+        const ret = wasm.jsmodeldiagnostics_passesAll(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Autocorrelation function of the residuals.
+     * @returns {Float64Array}
+     */
+    get residualAcf() {
+        const ret = wasm.jsmodeldiagnostics_residualAcf(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Standard deviation of the residuals.
+     * @returns {number}
+     */
+    get residualStd() {
+        const ret = wasm.jsdataprofile_max(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Mean of the residuals.
+     * @returns {number}
+     */
+    get residualMean() {
+        const ret = wasm.jsdataprofile_min(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Partial autocorrelation function of the residuals.
+     * @returns {Float64Array}
+     */
+    get residualPacf() {
+        const ret = wasm.jsmodeldiagnostics_residualPacf(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Create diagnostics from an array of residuals.
+     *
+     * @param residuals - Array of model residuals
+     * @param significance - Significance level for tests (e.g., 0.05)
+     * @param {Float64Array} residuals
+     * @param {number} significance
+     * @returns {JsModelDiagnostics}
+     */
+    static fromResiduals(residuals, significance) {
+        const ptr0 = passArrayF64ToWasm0(residuals, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.jsmodeldiagnostics_fromResiduals(ptr0, len0, significance);
+        return JsModelDiagnostics.__wrap(ret);
+    }
+    /**
+     * Number of lags used in the Ljung-Box test.
+     * @returns {number}
+     */
+    get ljungBoxLags() {
+        const ret = wasm.jsmodeldiagnostics_ljungBoxLags(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Ljung-Box test p-value for autocorrelation.
+     * @returns {number}
+     */
+    get ljungBoxPvalue() {
+        const ret = wasm.jsmodeldiagnostics_ljungBoxPvalue(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Jarque-Bera test p-value.
+     * @returns {number}
+     */
+    get jarqueBeraPvalue() {
+        const ret = wasm.jsconformalresult_quantileValue(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Jarque-Bera test statistic for normality.
+     * @returns {number}
+     */
+    get jarqueBeraStatistic() {
+        const ret = wasm.jsmodeldiagnostics_jarqueBeraStatistic(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Breusch-Pagan heteroscedasticity test p-value.
+     * @returns {number}
+     */
+    get heteroscedasticityPvalue() {
+        const ret = wasm.jsconformalresult_coverage(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get a human-readable summary of the diagnostics.
+     * @returns {string}
+     */
+    summary() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsmodeldiagnostics_summary(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) JsModelDiagnostics.prototype[Symbol.dispose] = JsModelDiagnostics.prototype.free;
+
+/**
+ * Normal predictor — assumes Gaussian forecast errors.
+ *
+ * Generates quantile-based prediction intervals from the estimated
+ * error mean and standard deviation.
+ */
+export class JsNormalPredictor {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsNormalPredictorFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jsnormalpredictor_free(ptr, 0);
+    }
+    /**
+     * Generate prediction intervals for new point forecasts.
+     *
+     * Returns intervals using the first and last quantile as bounds.
+     *
+     * @param result - A fitted JsNormalResult from fit()
+     * @param pointForecasts - New point forecast values
+     * @param {JsNormalResult} result
+     * @param {Float64Array} point_forecasts
+     * @returns {JsPredictionIntervals}
+     */
+    predictIntervals(result, point_forecasts) {
+        _assertClass(result, JsNormalResult);
+        const ptr0 = passArrayF64ToWasm0(point_forecasts, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.jsnormalpredictor_predictIntervals(this.__wbg_ptr, result.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return JsPredictionIntervals.__wrap(ret[0]);
+    }
+    /**
+     * Fit the predictor on historical forecasts and actuals.
+     *
+     * @param forecasts - Historical point forecast values
+     * @param actuals - Corresponding actual observed values
+     * @param {Float64Array} forecasts
+     * @param {Float64Array} actuals
+     * @returns {JsNormalResult}
+     */
+    fit(forecasts, actuals) {
+        const ptr0 = passArrayF64ToWasm0(forecasts, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(actuals, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.jsnormalpredictor_fit(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return JsNormalResult.__wrap(ret[0]);
+    }
+    /**
+     * Create a new normal predictor.
+     *
+     * @param quantiles - Sorted quantile levels in (0,1), e.g. [0.1, 0.5, 0.9]
+     * @param {Float64Array} quantiles
+     */
+    constructor(quantiles) {
+        const ptr0 = passArrayF64ToWasm0(quantiles, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.jsnormalpredictor_new(ptr0, len0);
+        this.__wbg_ptr = ret >>> 0;
+        JsNormalPredictorFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) JsNormalPredictor.prototype[Symbol.dispose] = JsNormalPredictor.prototype.free;
+
+/**
+ * Normal prediction result — stores Gaussian fit parameters.
+ */
+export class JsNormalResult {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(JsNormalResult.prototype);
+        obj.__wbg_ptr = ptr;
+        JsNormalResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsNormalResultFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jsnormalresult_free(ptr, 0);
+    }
+    /**
+     * Get the mean error (bias).
+     * @returns {number}
+     */
+    get mean() {
+        const ret = wasm.jsmodeldiagnostics_ljungBoxPvalue(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get the standard deviation of errors.
+     * @returns {number}
+     */
+    stdDev() {
+        const ret = wasm.jsmodeldiagnostics_jarqueBeraStatistic(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) JsNormalResult.prototype[Symbol.dispose] = JsNormalResult.prototype.free;
+
+/**
+ * Declarative pipeline builder for composing forecasting workflows.
+ *
+ * Chain configuration methods and call `build()` to produce a pipeline,
+ * then `execute()` to run it.
+ *
+ * ```js
+ * const result = new JsPipelineBuilder()
+ *   .profile()
+ *   .preprocess("auto")
+ *   .metric("auto")
+ *   .ensemble("auto")
+ *   .addModel("Naive")
+ *   .addModel("SES")
+ *   .withFallback()
+ *   .nonNegative()
+ *   .build()
+ *   .execute(ts, 12);
+ * ```
+ */
+export class JsPipelineBuilder {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(JsPipelineBuilder.prototype);
+        obj.__wbg_ptr = ptr;
+        JsPipelineBuilderFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsPipelineBuilderFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jspipelinebuilder_free(ptr, 0);
+    }
+    /**
+     * Set preprocessing mode.
+     *
+     * @param mode - "auto", "none", or "manual"
+     * @param {string} mode
+     * @returns {JsPipelineBuilder}
+     */
+    preprocess(mode) {
+        const ptr = this.__destroy_into_raw();
+        const ptr0 = passStringToWasm0(mode, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.jsnormalpredictor_predictIntervals(this.__wbg_ptr, result.__wbg_ptr, ptr0, len0);
+        const ret = wasm.jspipelinebuilder_preprocess(ptr, ptr0, len0);
+        return JsPipelineBuilder.__wrap(ret);
+    }
+    /**
+     * Apply non-negative constraint to forecasts.
+     * @returns {JsPipelineBuilder}
+     */
+    nonNegative() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.jspipelinebuilder_nonNegative(ptr);
+        return JsPipelineBuilder.__wrap(ret);
+    }
+    /**
+     * Select top-K models for evaluation.
+     *
+     * @param k - Number of models to select
+     * @param {number} k
+     * @returns {JsPipelineBuilder}
+     */
+    selectModels(k) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.jspipelinebuilder_selectModels(ptr, k);
+        return JsPipelineBuilder.__wrap(ret);
+    }
+    /**
+     * Enable fallback chain (Naive → SMA).
+     * @returns {JsPipelineBuilder}
+     */
+    withFallback() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.jspipelinebuilder_withFallback(ptr);
+        return JsPipelineBuilder.__wrap(ret);
+    }
+    /**
+     * Enable cross-validation.
+     *
+     * @param folds - Number of CV folds
+     * @param horizon - Forecast horizon for each fold
+     * @param {number} folds
+     * @param {number} horizon
+     * @returns {JsPipelineBuilder}
+     */
+    crossValidate(folds, horizon) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.jspipelinebuilder_crossValidate(ptr, folds, horizon);
+        return JsPipelineBuilder.__wrap(ret);
+    }
+    /**
+     * Set the seasonal period hint.
+     *
+     * @param period - Seasonal period (e.g., 12 for monthly data)
+     * @param {number} period
+     * @returns {JsPipelineBuilder}
+     */
+    seasonalPeriod(period) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.jspipelinebuilder_seasonalPeriod(ptr, period);
+        return JsPipelineBuilder.__wrap(ret);
+    }
+    /**
+     * Add a seasonal model to the pipeline.
+     *
+     * @param name - Model name (e.g., "SeasonalNaive")
+     * @param period - Seasonal period
+     * @param {string} name
+     * @param {number} period
+     * @returns {JsPipelineBuilder}
+     */
+    addSeasonalModel(name, period) {
+        const ptr = this.__destroy_into_raw();
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.jspipelinebuilder_addSeasonalModel(ptr, ptr0, len0, period);
+        return JsPipelineBuilder.__wrap(ret);
+    }
+    /**
+     * Create a new pipeline builder.
+     */
+    constructor() {
+        const ret = wasm.jspipelinebuilder_new();
+        this.__wbg_ptr = ret >>> 0;
+        JsPipelineBuilderFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Set the metric strategy for model selection.
+     *
+     * @param strategy - "auto", "mae", "mse", "rmse", "smape", "wape", or "mda"
+     * @param {string} strategy
+     * @returns {JsPipelineBuilder}
+     */
+    metric(strategy) {
+        const ptr = this.__destroy_into_raw();
+        const ptr0 = passStringToWasm0(strategy, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.jspipelinebuilder_metric(ptr, ptr0, len0);
+        return JsPipelineBuilder.__wrap(ret);
+    }
+    /**
+     * Build and execute the pipeline.
+     *
+     * @param series - TimeSeries to forecast
+     * @param horizon - Number of steps to forecast
+     * @returns JsPipelineResult with forecast, profile, and diagnostics
+     * @param {TimeSeries} series
+     * @param {number} horizon
+     * @returns {JsPipelineResult}
+     */
+    execute(series, horizon) {
+        const ptr = this.__destroy_into_raw();
+        _assertClass(series, TimeSeries);
+        const ret = wasm.jspipelinebuilder_execute(ptr, series.__wbg_ptr, horizon);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return JsPredictionIntervals.__wrap(ret[0]);
+        return JsPipelineResult.__wrap(ret[0]);
     }
     /**
-     * Fit the predictor on historical forecasts and actuals.
+     * Enable data profiling.
+     * @returns {JsPipelineBuilder}
+     */
+    profile() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.jspipelinebuilder_profile(ptr);
+        return JsPipelineBuilder.__wrap(ret);
+    }
+    /**
+     * Set the ensemble mode.
      *
-     * @param forecasts - Historical point forecast values
-     * @param actuals - Corresponding actual observed values
-     * @param {Float64Array} forecasts
-     * @param {Float64Array} actuals
-     * @returns {JsNormalResult}
+     * @param mode - "auto", "none", "mean", "median", or "weighted"
+     * @param {string} mode
+     * @returns {JsPipelineBuilder}
      */
-    fit(forecasts, actuals) {
-        const ptr0 = passArrayF64ToWasm0(forecasts, wasm.__wbindgen_malloc);
+    ensemble(mode) {
+        const ptr = this.__destroy_into_raw();
+        const ptr0 = passStringToWasm0(mode, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArrayF64ToWasm0(actuals, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.jsnormalpredictor_fit(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        const ret = wasm.jspipelinebuilder_ensemble(ptr, ptr0, len0);
+        return JsPipelineBuilder.__wrap(ret);
+    }
+    /**
+     * Add a built-in model to the pipeline.
+     *
+     * Supported models: "Naive", "SES", "SMA", "SMA5", "SMA10"
+     *
+     * @param name - Model name
+     * @param {string} name
+     * @returns {JsPipelineBuilder}
+     */
+    addModel(name) {
+        const ptr = this.__destroy_into_raw();
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.jspipelinebuilder_addModel(ptr, ptr0, len0);
+        return JsPipelineBuilder.__wrap(ret);
+    }
+}
+if (Symbol.dispose) JsPipelineBuilder.prototype[Symbol.dispose] = JsPipelineBuilder.prototype.free;
+
+/**
+ * Structured multi-section pipeline report.
+ *
+ * Contains summary, data profile, preprocessing, model selection,
+ * ensemble, forecast, horizon analysis, decision log, and execution metadata.
+ */
+export class JsPipelineReport {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(JsPipelineReport.prototype);
+        obj.__wbg_ptr = ptr;
+        JsPipelineReportFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsPipelineReportFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jspipelinereport_free(ptr, 0);
+    }
+    /**
+     * Get the full report as formatted text.
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jspipelinereport_toString(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Get the number of sections.
+     * @returns {number}
+     */
+    get sectionCount() {
+        const ret = wasm.jspipelinereport_sectionCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get a section heading by index.
+     * @param {number} index
+     * @returns {string | undefined}
+     */
+    sectionHeading(index) {
+        const ret = wasm.jspipelinereport_sectionHeading(this.__wbg_ptr, index);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * Get the report title.
+     * @returns {string}
+     */
+    get title() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jspipelinereport_title(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Get the report as a JSON object.
+     *
+     * Returns `{ title, sections: [{ heading, content }] }`.
+     * @returns {any}
+     */
+    toJSON() {
+        const ret = wasm.jspipelinereport_toJSON(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+}
+if (Symbol.dispose) JsPipelineReport.prototype[Symbol.dispose] = JsPipelineReport.prototype.free;
+
+/**
+ * Result of executing a forecasting pipeline.
+ *
+ * Contains the forecast, selected model name, data profile, decision log,
+ * preprocessing info, ensemble weights, and metric scores.
+ */
+export class JsPipelineResult {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(JsPipelineResult.prototype);
+        obj.__wbg_ptr = ptr;
+        JsPipelineResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsPipelineResultFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jspipelineresult_free(ptr, 0);
+    }
+    /**
+     * Get the name of the selected model.
+     * @returns {string}
+     */
+    get modelName() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jspipelineresult_modelName(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Get the decision log as a formatted string.
+     * @returns {string}
+     */
+    get decisionLog() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jspipelineresult_decisionLog(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Get a human-readable summary of the result.
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jspipelineresult_toString(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Get metric scores as JSON (undefined if not computed).
+     * @returns {any}
+     */
+    get metricScores() {
+        const ret = wasm.jspipelineresult_metricScores(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Get quality floor result (undefined if not computed).
+     * @returns {string | undefined}
+     */
+    get qualityFloor() {
+        const ret = wasm.jspipelineresult_qualityFloor(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * Get the number of decisions in the log.
+     * @returns {number}
+     */
+    get decisionCount() {
+        const ret = wasm.jspipelineresult_decisionCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get preprocessing info (undefined if not applied).
+     * @returns {any}
+     */
+    get preprocessInfo() {
+        const ret = wasm.jspipelineresult_preprocessInfo(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Get ensemble weights as JSON (undefined if not an ensemble).
+     * @returns {any}
+     */
+    get ensembleWeights() {
+        const ret = wasm.jspipelineresult_ensembleWeights(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Get model confidence set (undefined if not computed).
+     * @returns {any}
+     */
+    get modelConfidenceSet() {
+        const ret = wasm.jspipelineresult_modelConfidenceSet(this.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return JsNormalResult.__wrap(ret[0]);
+        return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * Create a new normal predictor.
-     *
-     * @param quantiles - Sorted quantile levels in (0,1), e.g. [0.1, 0.5, 0.9]
-     * @param {Float64Array} quantiles
+     * Get selection confidence (undefined if not computed).
+     * @returns {string | undefined}
      */
-    constructor(quantiles) {
-        const ptr0 = passArrayF64ToWasm0(quantiles, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.jsnormalpredictor_new(ptr0, len0);
-        this.__wbg_ptr = ret >>> 0;
-        JsNormalPredictorFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-}
-if (Symbol.dispose) JsNormalPredictor.prototype[Symbol.dispose] = JsNormalPredictor.prototype.free;
-
-/**
- * Normal prediction result — stores Gaussian fit parameters.
- */
-export class JsNormalResult {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(JsNormalResult.prototype);
-        obj.__wbg_ptr = ptr;
-        JsNormalResultFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        JsNormalResultFinalization.unregister(this);
-        return ptr;
+    get selectionConfidence() {
+        const ret = wasm.jspipelineresult_selectionConfidence(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
     }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_jsnormalresult_free(ptr, 0);
+    /**
+     * Generate a full structured report.
+     * @returns {JsPipelineReport}
+     */
+    report() {
+        const ret = wasm.jspipelineresult_report(this.__wbg_ptr);
+        return JsPipelineReport.__wrap(ret);
     }
     /**
-     * Get the mean error (bias).
-     * @returns {number}
+     * Get the data profile (undefined if profiling was not enabled).
+     * @returns {JsDataProfile | undefined}
      */
-    get mean() {
-        const ret = wasm.jsnormalresult_mean(this.__wbg_ptr);
-        return ret;
+    get profile() {
+        const ret = wasm.jspipelineresult_profile(this.__wbg_ptr);
+        return ret === 0 ? undefined : JsDataProfile.__wrap(ret);
     }
     /**
-     * Get the standard deviation of errors.
-     * @returns {number}
+     * Get the forecast.
+     * @returns {Forecast}
      */
-    stdDev() {
-        const ret = wasm.jsnormalresult_stdDev(this.__wbg_ptr);
-        return ret;
+    get forecast() {
+        const ret = wasm.jspipelineresult_forecast(this.__wbg_ptr);
+        return Forecast.__wrap(ret);
     }
 }
-if (Symbol.dispose) JsNormalResult.prototype[Symbol.dispose] = JsNormalResult.prototype.free;
+if (Symbol.dispose) JsPipelineResult.prototype[Symbol.dispose] = JsPipelineResult.prototype.free;
 
 /**
  * Point forecasts — a sequence of predicted values.
@@ -2995,7 +4158,7 @@ export class JsPredictionIntervals {
      * @returns {number}
      */
     get coverage() {
-        const ret = wasm.jsnormalresult_mean(this.__wbg_ptr);
+        const ret = wasm.jsmodeldiagnostics_ljungBoxPvalue(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -3037,6 +4200,139 @@ export class JsTrainedModel {
 }
 if (Symbol.dispose) JsTrainedModel.prototype[Symbol.dispose] = JsTrainedModel.prototype.free;
 
+/**
+ * Kalman filter forecaster for state-space models.
+ *
+ * Supports local level and local linear trend models out of the box.
+ */
+export class KalmanForecaster {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(KalmanForecaster.prototype);
+        obj.__wbg_ptr = ptr;
+        KalmanForecasterFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        KalmanForecasterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_kalmanforecaster_free(ptr, 0);
+    }
+    /**
+     * Create a local level (random walk plus noise) model.
+     *
+     * @param obs_noise - Observation noise variance
+     * @param state_noise - State (level) noise variance
+     * @param {number} obs_noise
+     * @param {number} state_noise
+     * @returns {KalmanForecaster}
+     */
+    static localLevel(obs_noise, state_noise) {
+        const ret = wasm.kalmanforecaster_localLevel(obs_noise, state_noise);
+        return KalmanForecaster.__wrap(ret);
+    }
+    /**
+     * Create a local linear trend model.
+     *
+     * @param obs_noise - Observation noise variance
+     * @param level_noise - Level noise variance
+     * @param trend_noise - Trend noise variance
+     * @param {number} obs_noise
+     * @param {number} level_noise
+     * @param {number} trend_noise
+     * @returns {KalmanForecaster}
+     */
+    static localLinearTrend(obs_noise, level_noise, trend_noise) {
+        const ret = wasm.kalmanforecaster_localLinearTrend(obs_noise, level_noise, trend_noise);
+        return KalmanForecaster.__wrap(ret);
+    }
+    /**
+     * Predict with prediction intervals.
+     *
+     * @param horizon - Number of steps to forecast
+     * @param level - Confidence level (e.g., 0.95 for 95% intervals)
+     * @returns Forecast with predictions and intervals
+     * @param {number} horizon
+     * @param {number} level
+     * @returns {Forecast}
+     */
+    predictWithIntervals(horizon, level) {
+        const ret = wasm.kalmanforecaster_predictWithIntervals(this.__wbg_ptr, horizon, level);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+    /**
+     * Fit the Kalman filter to a time series.
+     *
+     * @param series - TimeSeries to fit
+     * @param {TimeSeries} series
+     */
+    fit(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.kalmanforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Get the model name.
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.kalmanforecaster_name(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Apply the Kalman smoother (RTS smoother) and return smoothed observations.
+     *
+     * @param series - TimeSeries to smooth
+     * @returns Array of smoothed observation values
+     * @param {TimeSeries} series
+     * @returns {Float64Array}
+     */
+    smooth(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.kalmanforecaster_smooth(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Predict future values.
+     *
+     * @param horizon - Number of steps to forecast
+     * @returns Forecast with point predictions
+     * @param {number} horizon
+     * @returns {Forecast}
+     */
+    predict(horizon) {
+        const ret = wasm.kalmanforecaster_predict(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) KalmanForecaster.prototype[Symbol.dispose] = KalmanForecaster.prototype.free;
+
 /**
  * MFLES - Multiple Frequency Locally Estimated Scatterplot Smoothing.
  */
@@ -4319,6 +5615,108 @@ export class TimeSeries {
 }
 if (Symbol.dispose) TimeSeries.prototype[Symbol.dispose] = TimeSeries.prototype.free;
 
+/**
+ * Vector Autoregression forecaster for multivariate time series.
+ *
+ * Models multiple time series jointly where each variable at time t is a
+ * linear function of the p most recent lags of all variables.
+ */
+export class VARForecaster {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        VARForecasterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_varforecaster_free(ptr, 0);
+    }
+    /**
+     * Fit the VAR model to multivariate time series data.
+     *
+     * @param data - Array of Float64Arrays, one per variable. All must have the same length.
+     * @param {Array<any>} data
+     */
+    fitMultivariate(data) {
+        const ret = wasm.varforecaster_fitMultivariate(this.__wbg_ptr, data);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Predict future values for all variables.
+     *
+     * @param horizon - Number of steps to forecast
+     * @returns Array of Float64Arrays, one per variable
+     * @param {number} horizon
+     * @returns {Array<any>}
+     */
+    predictMultivariate(horizon) {
+        const ret = wasm.varforecaster_predictMultivariate(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Perform a Granger causality test.
+     *
+     * Tests whether variable `cause` Granger-causes variable `effect`.
+     *
+     * @param cause - Index of the potentially causal variable (0-based)
+     * @param effect - Index of the effect variable (0-based)
+     * @returns F-statistic. Higher values indicate stronger evidence of causality.
+     * @param {number} cause
+     * @param {number} effect
+     * @returns {number}
+     */
+    grangerCausalityTest(cause, effect) {
+        const ret = wasm.varforecaster_grangerCausalityTest(this.__wbg_ptr, cause, effect);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Create a new VAR forecaster with the given lag order.
+     *
+     * @param order - Number of lags (p). Must be at least 1.
+     * @param {number} order
+     */
+    constructor(order) {
+        const ret = wasm.varforecaster_new(order);
+        this.__wbg_ptr = ret >>> 0;
+        VARForecasterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Get the model name.
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.varforecaster_name(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Get the lag order.
+     * @returns {number}
+     */
+    get order() {
+        const ret = wasm.varforecaster_order(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) VARForecaster.prototype[Symbol.dispose] = VARForecaster.prototype.free;
+
 /**
  * Window Average forecaster - uses the last N observations.
  */
@@ -4640,6 +6038,27 @@ export function durbinWatson(residuals) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Generate a human-readable explanation of a pipeline result.
+ *
+ * @param result - A JsPipelineResult to explain
+ * @param verbosity - "brief", "normal", or "detailed"
+ * @returns Object with `summary` and `sections`
+ * @param {JsPipelineResult} result
+ * @param {string} verbosity
+ * @returns {any}
+ */
+export function explainResult(result, verbosity) {
+    _assertClass(result, JsPipelineResult);
+    const ptr0 = passStringToWasm0(verbosity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.explainResult(result.__wbg_ptr, ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Initialize the WASM module.
  *
@@ -4822,6 +6241,28 @@ export function sampleEntropy(values, m, r) {
     return ret;
 }
 
+/**
+ * Recommend models based on data profile characteristics.
+ *
+ * Returns an object with `recommended` (model names) and `reasoning` (explanations).
+ *
+ * @param profile - A JsDataProfile from profiling
+ * @param availableModels - Optional array of model names to filter by
+ * @param {JsDataProfile} profile
+ * @param {string[] | null} [available_models]
+ * @returns {any}
+ */
+export function selectModels(profile, available_models) {
+    _assertClass(profile, JsDataProfile);
+    var ptr0 = isLikeNone(available_models) ? 0 : passArrayJsValueToWasm0(available_models, wasm.__wbindgen_malloc);
+    var len0 = WASM_VECTOR_LEN;
+    const ret = wasm.selectModels(profile.__wbg_ptr, ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Compute the skewness (third standardized moment) of a time series.
  *
@@ -4990,10 +6431,32 @@ function __wbg_get_imports() {
         const ret = arg0.getTime();
         return ret;
     };
+    imports.wbg.__wbg_get_6b7bd52aca3f9671 = function(arg0, arg1) {
+        const ret = arg0[arg1 >>> 0];
+        return ret;
+    };
+    imports.wbg.__wbg_instanceof_Float64Array_9fefccd7bfa2fefe = function(arg0) {
+        let result;
+        try {
+            result = arg0 instanceof Float64Array;
+        } catch (_) {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
     imports.wbg.__wbg_length_22ac23eaec9d8053 = function(arg0) {
         const ret = arg0.length;
         return ret;
     };
+    imports.wbg.__wbg_length_406f6daaaa453057 = function(arg0) {
+        const ret = arg0.length;
+        return ret;
+    };
+    imports.wbg.__wbg_length_d45040a40c570362 = function(arg0) {
+        const ret = arg0.length;
+        return ret;
+    };
     imports.wbg.__wbg_msCrypto_a61aeb35a24c1329 = function(arg0) {
         const ret = arg0.msCrypto;
         return ret;
@@ -5014,6 +6477,14 @@ function __wbg_get_imports() {
         const ret = new Function(getStringFromWasm0(arg0, arg1));
         return ret;
     };
+    imports.wbg.__wbg_new_with_length_12c6de4fac33117a = function(arg0) {
+        const ret = new Array(arg0 >>> 0);
+        return ret;
+    };
+    imports.wbg.__wbg_new_with_length_806b9e5b8290af7c = function(arg0) {
+        const ret = new Float64Array(arg0 >>> 0);
+        return ret;
+    };
     imports.wbg.__wbg_new_with_length_aa5eaf41d35235e5 = function(arg0) {
         const ret = new Uint8Array(arg0 >>> 0);
         return ret;
@@ -5026,6 +6497,9 @@ function __wbg_get_imports() {
         const ret = arg0.process;
         return ret;
     };
+    imports.wbg.__wbg_prototypesetcall_d3c4edbb4ef96ca1 = function(arg0, arg1, arg2) {
+        Float64Array.prototype.set.call(getArrayF64FromWasm0(arg0, arg1), arg2);
+    };
     imports.wbg.__wbg_prototypesetcall_dfe9b766cdc1f1fd = function(arg0, arg1, arg2) {
         Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
     };
@@ -5036,6 +6510,9 @@ function __wbg_get_imports() {
         const ret = module.require;
         return ret;
     }, arguments) };
+    imports.wbg.__wbg_set_22933af9286a43df = function(arg0, arg1, arg2) {
+        arg0.set(getArrayF64FromWasm0(arg1, arg2));
+    };
     imports.wbg.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
         arg0[arg1] = arg2;
     };