@sipemu/anofox-forecast 0.4.4 → 0.4.5

package/anofox_forecast_js.js

@@ -1,5 +1,11 @@
 let wasm;
 
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
 function _assertClass(instance, klass) {
     if (!(instance instanceof klass)) {
         throw new Error(`expected instance of ${klass.name}`);
@@ -11,6 +17,19 @@ function getArrayF64FromWasm0(ptr, len) {
     return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
 }
 
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
 let cachedFloat64ArrayMemory0 = null;
 function getFloat64ArrayMemory0() {
     if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
@@ -40,6 +59,15 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
 function isLikeNone(x) {
     return x === undefined || x === null;
 }
@@ -58,6 +86,16 @@ function passArrayF64ToWasm0(arg, malloc) {
     return ptr;
 }
 
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    for (let i = 0; i < array.length; i++) {
+        const add = addToExternrefTable0(array[i]);
+        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);
@@ -146,6 +184,14 @@ const AutoETSForecasterFinalization = (typeof FinalizationRegistry === 'undefine
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_autoetsforecaster_free(ptr >>> 0, 1));
 
+const AutoEnsembleForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_autoensembleforecaster_free(ptr >>> 0, 1));
+
+const AutoForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_autoforecaster_free(ptr >>> 0, 1));
+
 const AutoTBATSForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_autotbatsforecaster_free(ptr >>> 0, 1));
@@ -154,6 +200,10 @@ const AutoThetaForecasterFinalization = (typeof FinalizationRegistry === 'undefi
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_autothetaforecaster_free(ptr >>> 0, 1));
 
+const CalendarAnnotationsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_calendarannotations_free(ptr >>> 0, 1));
+
 const CrostonForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_crostonforecaster_free(ptr >>> 0, 1));
@@ -166,6 +216,10 @@ const ETSForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_etsforecaster_free(ptr >>> 0, 1));
 
+const EnsembleForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_ensembleforecaster_free(ptr >>> 0, 1));
+
 const ForecastFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_forecast_free(ptr >>> 0, 1));
@@ -186,6 +240,54 @@ const IMAPAForecasterFinalization = (typeof FinalizationRegistry === 'undefined'
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_imapaforecaster_free(ptr >>> 0, 1));
 
+const JsBacktestConfigFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jsbacktestconfig_free(ptr >>> 0, 1));
+
+const JsBacktestResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jsbacktestresult_free(ptr >>> 0, 1));
+
+const JsConformalPredictorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jsconformalpredictor_free(ptr >>> 0, 1));
+
+const JsConformalResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jsconformalresult_free(ptr >>> 0, 1));
+
+const JsHistoricalSimResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jshistoricalsimresult_free(ptr >>> 0, 1));
+
+const JsHistoricalSimulatorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jshistoricalsimulator_free(ptr >>> 0, 1));
+
+const JsNormalPredictorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jsnormalpredictor_free(ptr >>> 0, 1));
+
+const JsNormalResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jsnormalresult_free(ptr >>> 0, 1));
+
+const JsPointForecastsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jspointforecasts_free(ptr >>> 0, 1));
+
+const JsPostProcessorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jspostprocessor_free(ptr >>> 0, 1));
+
+const JsPredictionIntervalsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jspredictionintervals_free(ptr >>> 0, 1));
+
+const JsTrainedModelFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jstrainedmodel_free(ptr >>> 0, 1));
+
 const MFLESForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_mflesforecaster_free(ptr >>> 0, 1));
@@ -268,6 +370,18 @@ export class ADIDAForecaster {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_adidaforecaster_free(ptr, 0);
     }
+    /**
+     * @param {number} horizon
+     * @param {number} level
+     * @returns {Forecast}
+     */
+    predictWithIntervals(horizon, level) {
+        const ret = wasm.adidaforecaster_predictWithIntervals(this.__wbg_ptr, horizon, level);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
     /**
      * @param {TimeSeries} series
      */
@@ -566,49 +680,115 @@ export class AutoETSForecaster {
 if (Symbol.dispose) AutoETSForecaster.prototype[Symbol.dispose] = AutoETSForecaster.prototype.free;
 
 /**
- * AutoTBATS - Automatic TBATS model selection.
+ * Automatic ensemble that selects top-K models across families.
+ *
+ * Fits AutoARIMA, AutoETS, and AutoTheta, ranks them by in-sample MSE,
+ * and combines the top-K into a weighted ensemble forecast.
  */
-export class AutoTBATSForecaster {
+export class AutoEnsembleForecaster {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(AutoEnsembleForecaster.prototype);
+        obj.__wbg_ptr = ptr;
+        AutoEnsembleForecasterFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        AutoTBATSForecasterFinalization.unregister(this);
+        AutoEnsembleForecasterFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_autotbatsforecaster_free(ptr, 0);
+        wasm.__wbg_autoensembleforecaster_free(ptr, 0);
+    }
+    /**
+     * Get all candidate scores as a JSON object.
+     *
+     * Returns an array of `{ name, score }` objects sorted by score (ascending).
+     * @returns {any}
+     */
+    allScores() {
+        const ret = wasm.autoensembleforecaster_allScores(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Get the number of models in the ensemble.
+     * @returns {number}
+     */
+    modelCount() {
+        const ret = wasm.autoensembleforecaster_modelCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Create with custom configuration.
+     *
+     * @param topK - Number of top models to include in ensemble (default: 3)
+     * @param seasonalPeriod - Seasonal period (0 or undefined for non-seasonal)
+     * @param {number | null} [top_k]
+     * @param {number | null} [seasonal_period]
+     * @returns {AutoEnsembleForecaster}
+     */
+    static withConfig(top_k, seasonal_period) {
+        const ret = wasm.autoensembleforecaster_withConfig(isLikeNone(top_k) ? 0x100000001 : (top_k) >>> 0, isLikeNone(seasonal_period) ? 0x100000001 : (seasonal_period) >>> 0);
+        return AutoEnsembleForecaster.__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 combined predictions and intervals
+     * @param {number} horizon
+     * @param {number} level
+     * @returns {Forecast}
+     */
+    predictWithIntervals(horizon, level) {
+        const ret = wasm.autoensembleforecaster_predictWithIntervals(this.__wbg_ptr, horizon, level);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
     }
     /**
+     * Fit the ensemble to a time series.
+     *
+     * Fits all candidate models, selects the top-K, and builds the ensemble.
+     *
+     * @param series - TimeSeries to fit
      * @param {TimeSeries} series
      */
     fit(series) {
         _assertClass(series, TimeSeries);
-        const ret = wasm.autotbatsforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        const ret = wasm.autoensembleforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
     /**
-     * @param seasonal_periods - Array of seasonal periods
-     * @param {Uint32Array} seasonal_periods
+     * Create a new AutoEnsembleForecaster with default configuration.
+     *
+     * By default, uses top-3 models with weighted MSE combination.
      */
-    constructor(seasonal_periods) {
-        const ptr0 = passArray32ToWasm0(seasonal_periods, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.autotbatsforecaster_new(ptr0, len0);
+    constructor() {
+        const ret = wasm.autoensembleforecaster_new();
         this.__wbg_ptr = ret >>> 0;
-        AutoTBATSForecasterFinalization.register(this, this.__wbg_ptr, this);
+        AutoEnsembleForecasterFinalization.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.autotbatsforecaster_name(this.__wbg_ptr);
+            const ret = wasm.autoensembleforecaster_name(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -617,69 +797,158 @@ export class AutoTBATSForecaster {
         }
     }
     /**
+     * Predict future values.
+     *
+     * @param horizon - Number of steps to forecast
+     * @returns Forecast with combined point predictions
      * @param {number} horizon
      * @returns {Forecast}
      */
     predict(horizon) {
-        const ret = wasm.autotbatsforecaster_predict(this.__wbg_ptr, horizon);
+        const ret = wasm.autoensembleforecaster_predict(this.__wbg_ptr, horizon);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return Forecast.__wrap(ret[0]);
     }
+    /**
+     * Create a seasonal AutoEnsembleForecaster.
+     *
+     * @param period - Seasonal period
+     * @param {number} period
+     * @returns {AutoEnsembleForecaster}
+     */
+    static seasonal(period) {
+        const ret = wasm.autoensembleforecaster_seasonal(period);
+        return AutoEnsembleForecaster.__wrap(ret);
+    }
 }
-if (Symbol.dispose) AutoTBATSForecaster.prototype[Symbol.dispose] = AutoTBATSForecaster.prototype.free;
+if (Symbol.dispose) AutoEnsembleForecaster.prototype[Symbol.dispose] = AutoEnsembleForecaster.prototype.free;
 
 /**
- * AutoTheta - Automatic Theta model selection.
+ * Automatic model selection across ARIMA, ETS, and Theta families.
+ *
+ * Fits all enabled auto models and selects the best one based on
+ * in-sample MSE or cross-validation error.
  */
-export class AutoThetaForecaster {
+export class AutoForecaster {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(AutoForecaster.prototype);
+        obj.__wbg_ptr = ptr;
+        AutoForecasterFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        AutoThetaForecasterFinalization.unregister(this);
+        AutoForecasterFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_autothetaforecaster_free(ptr, 0);
+        wasm.__wbg_autoforecaster_free(ptr, 0);
+    }
+    /**
+     * Get all candidate scores as a JSON object.
+     *
+     * Returns an array of `{ name, score }` objects sorted by score (ascending).
+     * @returns {any}
+     */
+    allScores() {
+        const ret = wasm.autoforecaster_allScores(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Create an AutoForecaster with custom configuration.
+     *
+     * @param seasonalPeriod - Seasonal period (0 or undefined for non-seasonal)
+     * @param includeArima - Include AutoARIMA candidate (default: true)
+     * @param includeEts - Include AutoETS candidate (default: true)
+     * @param includeTheta - Include AutoTheta candidate (default: true)
+     * @param useCrossValidation - Use cross-validation instead of in-sample MSE (default: false)
+     * @param {number | null} [seasonal_period]
+     * @param {boolean | null} [include_arima]
+     * @param {boolean | null} [include_ets]
+     * @param {boolean | null} [include_theta]
+     * @param {boolean | null} [use_cross_validation]
+     * @returns {AutoForecaster}
+     */
+    static withConfig(seasonal_period, include_arima, include_ets, include_theta, use_cross_validation) {
+        const ret = wasm.autoforecaster_withConfig(isLikeNone(seasonal_period) ? 0x100000001 : (seasonal_period) >>> 0, isLikeNone(include_arima) ? 0xFFFFFF : include_arima ? 1 : 0, isLikeNone(include_ets) ? 0xFFFFFF : include_ets ? 1 : 0, isLikeNone(include_theta) ? 0xFFFFFF : include_theta ? 1 : 0, isLikeNone(use_cross_validation) ? 0xFFFFFF : use_cross_validation ? 1 : 0);
+        return AutoForecaster.__wrap(ret);
+    }
+    /**
+     * Get the name of the selected model.
+     *
+     * @returns Name of the best model, or undefined if not yet fitted
+     * @returns {string | undefined}
+     */
+    selectedModelName() {
+        const ret = wasm.autoforecaster_selectedModelName(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;
     }
     /**
+     * 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 point predictions and intervals
      * @param {number} horizon
      * @param {number} level
      * @returns {Forecast}
      */
     predictWithIntervals(horizon, level) {
-        const ret = wasm.autothetaforecaster_predictWithIntervals(this.__wbg_ptr, horizon, level);
+        const ret = wasm.autoforecaster_predictWithIntervals(this.__wbg_ptr, horizon, level);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return Forecast.__wrap(ret[0]);
     }
     /**
+     * Fit the model to a time series.
+     *
+     * Fits all candidate models and selects the best one.
+     *
+     * @param series - TimeSeries to fit
      * @param {TimeSeries} series
      */
     fit(series) {
         _assertClass(series, TimeSeries);
-        const ret = wasm.autothetaforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        const ret = wasm.autoforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
+    /**
+     * Create a new AutoForecaster with default configuration.
+     *
+     * By default, includes AutoARIMA, AutoETS, and AutoTheta candidates
+     * and uses in-sample MSE for model selection.
+     */
     constructor() {
-        const ret = wasm.autothetaforecaster_new();
+        const ret = wasm.autoforecaster_new();
         this.__wbg_ptr = ret >>> 0;
-        AutoThetaForecasterFinalization.register(this, this.__wbg_ptr, this);
+        AutoForecasterFinalization.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.autothetaforecaster_name(this.__wbg_ptr);
+            const ret = wasm.autoforecaster_name(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -688,47 +957,68 @@ export class AutoThetaForecaster {
         }
     }
     /**
+     * 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.autothetaforecaster_predict(this.__wbg_ptr, horizon);
+        const ret = wasm.autoforecaster_predict(this.__wbg_ptr, horizon);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return Forecast.__wrap(ret[0]);
     }
+    /**
+     * Create a seasonal AutoForecaster.
+     *
+     * @param period - Seasonal period (e.g., 12 for monthly data with yearly seasonality)
+     * @param {number} period
+     * @returns {AutoForecaster}
+     */
+    static seasonal(period) {
+        const ret = wasm.autoforecaster_seasonal(period);
+        return AutoForecaster.__wrap(ret);
+    }
 }
-if (Symbol.dispose) AutoThetaForecaster.prototype[Symbol.dispose] = AutoThetaForecaster.prototype.free;
+if (Symbol.dispose) AutoForecaster.prototype[Symbol.dispose] = AutoForecaster.prototype.free;
 
 /**
- * Croston's method for intermittent demand forecasting.
+ * AutoTBATS - Automatic TBATS model selection.
  */
-export class CrostonForecaster {
+export class AutoTBATSForecaster {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        CrostonForecasterFinalization.unregister(this);
+        AutoTBATSForecasterFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_crostonforecaster_free(ptr, 0);
+        wasm.__wbg_autotbatsforecaster_free(ptr, 0);
     }
     /**
      * @param {TimeSeries} series
      */
     fit(series) {
         _assertClass(series, TimeSeries);
-        const ret = wasm.crostonforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        const ret = wasm.autotbatsforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
-    constructor() {
-        const ret = wasm.crostonforecaster_new();
+    /**
+     * @param seasonal_periods - Array of seasonal periods
+     * @param {Uint32Array} seasonal_periods
+     */
+    constructor(seasonal_periods) {
+        const ptr0 = passArray32ToWasm0(seasonal_periods, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.autotbatsforecaster_new(ptr0, len0);
         this.__wbg_ptr = ret >>> 0;
-        CrostonForecasterFinalization.register(this, this.__wbg_ptr, this);
+        AutoTBATSForecasterFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
     /**
@@ -738,7 +1028,7 @@ export class CrostonForecaster {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.crostonforecaster_name(this.__wbg_ptr);
+            const ret = wasm.autotbatsforecaster_name(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -751,35 +1041,28 @@ export class CrostonForecaster {
      * @returns {Forecast}
      */
     predict(horizon) {
-        const ret = wasm.crostonforecaster_predict(this.__wbg_ptr, horizon);
+        const ret = wasm.autotbatsforecaster_predict(this.__wbg_ptr, horizon);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return Forecast.__wrap(ret[0]);
     }
 }
-if (Symbol.dispose) CrostonForecaster.prototype[Symbol.dispose] = CrostonForecaster.prototype.free;
+if (Symbol.dispose) AutoTBATSForecaster.prototype[Symbol.dispose] = AutoTBATSForecaster.prototype.free;
 
 /**
- * Dynamic Theta forecaster - updates coefficients dynamically.
+ * AutoTheta - Automatic Theta model selection.
  */
-export class DynamicThetaForecaster {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(DynamicThetaForecaster.prototype);
-        obj.__wbg_ptr = ptr;
-        DynamicThetaForecasterFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
+export class AutoThetaForecaster {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        DynamicThetaForecasterFinalization.unregister(this);
+        AutoThetaForecasterFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_dynamicthetaforecaster_free(ptr, 0);
+        wasm.__wbg_autothetaforecaster_free(ptr, 0);
     }
     /**
      * @param {number} horizon
@@ -787,7 +1070,7 @@ export class DynamicThetaForecaster {
      * @returns {Forecast}
      */
     predictWithIntervals(horizon, level) {
-        const ret = wasm.dynamicthetaforecaster_predictWithIntervals(this.__wbg_ptr, horizon, level);
+        const ret = wasm.autothetaforecaster_predictWithIntervals(this.__wbg_ptr, horizon, level);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -798,19 +1081,15 @@ export class DynamicThetaForecaster {
      */
     fit(series) {
         _assertClass(series, TimeSeries);
-        const ret = wasm.dynamicthetaforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        const ret = wasm.autothetaforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
-    /**
-     * @param alpha - Smoothing parameter for the forecast
-     * @param {number} alpha
-     */
-    constructor(alpha) {
-        const ret = wasm.dynamicthetaforecaster_new(alpha);
+    constructor() {
+        const ret = wasm.autothetaforecaster_new();
         this.__wbg_ptr = ret >>> 0;
-        DynamicThetaForecasterFinalization.register(this, this.__wbg_ptr, this);
+        AutoThetaForecasterFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
     /**
@@ -820,7 +1099,7 @@ export class DynamicThetaForecaster {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.dynamicthetaforecaster_name(this.__wbg_ptr);
+            const ret = wasm.autothetaforecaster_name(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -833,311 +1112,274 @@ export class DynamicThetaForecaster {
      * @returns {Forecast}
      */
     predict(horizon) {
-        const ret = wasm.dynamicthetaforecaster_predict(this.__wbg_ptr, horizon);
+        const ret = wasm.autothetaforecaster_predict(this.__wbg_ptr, horizon);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return Forecast.__wrap(ret[0]);
     }
-    /**
-     * Create a seasonal Dynamic Theta model.
-     * @param period - Seasonal period
-     * @param {number} period
-     * @returns {DynamicThetaForecaster}
-     */
-    static seasonal(period) {
-        const ret = wasm.dynamicthetaforecaster_seasonal(period);
-        return DynamicThetaForecaster.__wrap(ret);
-    }
-    /**
-     * Create an optimized Dynamic Theta model.
-     * @returns {DynamicThetaForecaster}
-     */
-    static optimized() {
-        const ret = wasm.dynamicthetaforecaster_optimized();
-        return DynamicThetaForecaster.__wrap(ret);
-    }
 }
-if (Symbol.dispose) DynamicThetaForecaster.prototype[Symbol.dispose] = DynamicThetaForecaster.prototype.free;
+if (Symbol.dispose) AutoThetaForecaster.prototype[Symbol.dispose] = AutoThetaForecaster.prototype.free;
 
 /**
- * ETS (Error-Trend-Seasonal) state-space model.
+ * Calendar annotations for holidays and external regressors.
  *
- * Use string codes: "A" = Additive, "M" = Multiplicative, "N" = None
- * Or use standard ETS notation like "ANN", "AAA", "MAM", "AAdM".
+ * Use this to define holidays, events, promotions, or any named
+ * numeric regressors that can influence a forecast. Attach to a
+ * `TimeSeries` via `TimeSeries.setCalendar()` before fitting a
+ * model that supports exogenous variables.
  *
- * Follows the ETS taxonomy from FPP3: <https://otexts.com/fpp3/taxonomy.html>
+ * @example
+ * ```js
+ * const cal = new CalendarAnnotations();
+ * cal.addHoliday(new Date("2024-12-25").getTime());
+ * cal.addHoliday(new Date("2025-01-01").getTime());
+ * cal.addRegressor("promo", new Float64Array([0,0,1,1,0,0,0]));
  *
- * Note: Some combinations are invalid/unstable per FPP3:
- * - MAA (Multiplicative error + Additive trend + Additive seasonal)
- * - MAdA (Multiplicative error + Damped trend + Additive seasonal)
+ * const ts = TimeSeries.withTimestamps(values, timestamps);
+ * ts.setCalendar(cal);
+ * ```
  */
-export class ETSForecaster {
+export class CalendarAnnotations {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(ETSForecaster.prototype);
+        const obj = Object.create(CalendarAnnotations.prototype);
         obj.__wbg_ptr = ptr;
-        ETSForecasterFinalization.register(obj, obj.__wbg_ptr, obj);
+        CalendarAnnotationsFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        ETSForecasterFinalization.unregister(this);
+        CalendarAnnotationsFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_etsforecaster_free(ptr, 0);
+        wasm.__wbg_calendarannotations_free(ptr, 0);
     }
     /**
-     * Create an ETS model from standard notation.
-     *
-     * @param notation - ETS notation string like "ANN", "AAA", "MAM", "AAdM"
-     * @param period - Seasonal period (required if notation has seasonal component)
+     * Check if a specific date is a holiday.
      *
-     * Format: ErrorTrendSeasonal
-     * - Error: A (additive) or M (multiplicative)
-     * - Trend: N (none), A (additive), or Ad (additive damped)
-     * - Seasonal: N (none), A (additive), or M (multiplicative)
+     * @param timestamp_ms - Date to check as milliseconds since Unix epoch
+     * @returns true if the date matches any registered holiday
+     * @param {number} timestamp_ms
+     * @returns {boolean}
+     */
+    isHoliday(timestamp_ms) {
+        const ret = wasm.calendarannotations_isHoliday(this.__wbg_ptr, timestamp_ms);
+        return ret !== 0;
+    }
+    /**
+     * Add a single holiday date.
      *
-     * Examples:
-     * - "ANN" - Simple exponential smoothing
-     * - "AAN" - Holt's linear method
-     * - "AAA" - Holt-Winters additive
-     * - "MAM" - Multiplicative Holt-Winters
-     * - "AAdM" - Damped trend with multiplicative seasonal
+     * @param timestamp_ms - Holiday date as milliseconds since Unix epoch
+     * @param {number} timestamp_ms
+     */
+    addHoliday(timestamp_ms) {
+        wasm.calendarannotations_addHoliday(this.__wbg_ptr, timestamp_ms);
+    }
+    /**
+     * Get holiday dates as milliseconds since Unix epoch.
+     * @returns {Float64Array}
+     */
+    getHolidays() {
+        const ret = wasm.calendarannotations_getHolidays(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Set multiple holiday dates at once (replaces any existing holidays).
      *
-     * @throws Error for invalid notation or unstable combinations (MAA, MAdA)
-     * @param {string} notation
-     * @param {number} period
-     * @returns {ETSForecaster}
+     * @param timestamps_ms - Array of holiday dates as milliseconds since Unix epoch
+     * @param {Float64Array} timestamps_ms
      */
-    static fromNotation(notation, period) {
-        const ptr0 = passStringToWasm0(notation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    setHolidays(timestamps_ms) {
+        const ptr0 = passArrayF64ToWasm0(timestamps_ms, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.etsforecaster_fromNotation(ptr0, len0, period);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ETSForecaster.__wrap(ret[0]);
+        wasm.calendarannotations_setHolidays(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * Check if an ETS specification is valid/stable.
+     * Add a named regressor with values aligned to the time series.
      *
-     * @param error - Error type: "A" or "M"
-     * @param trend - Trend type: "N", "A", or "Ad"
-     * @param seasonal - Seasonal type: "N", "A", or "M"
-     * @returns true if the combination is stable and usable
+     * The values array must have the same length as the time series this
+     * will be attached to. Common examples: promotional flags (0/1),
+     * temperature, price changes, etc.
      *
-     * Invalid combinations (return false):
-     * - M,A,A - Multiplicative error with additive trend and additive seasonal
-     * - M,Ad,A - Multiplicative error with damped trend and additive seasonal
-     * @param {string} error
-     * @param {string} trend
-     * @param {string} seasonal
-     * @returns {boolean}
+     * @param name - Name of the regressor (e.g., "promo", "temperature")
+     * @param values - Array of numeric values, one per time step
+     * @param {string} name
+     * @param {Float64Array} values
      */
-    static isValidSpec(error, trend, seasonal) {
-        const ptr0 = passStringToWasm0(error, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    addRegressor(name, values) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(trend, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr1 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
         const len1 = WASM_VECTOR_LEN;
-        const ptr2 = passStringToWasm0(seasonal, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len2 = WASM_VECTOR_LEN;
-        const ret = wasm.etsforecaster_isValidSpec(ptr0, len0, ptr1, len1, ptr2, len2);
-        return ret !== 0;
-    }
-    /**
-     * @param {TimeSeries} series
-     */
-    fit(series) {
-        _assertClass(series, TimeSeries);
-        const ret = wasm.etsforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
+        wasm.calendarannotations_addRegressor(this.__wbg_ptr, ptr0, len0, ptr1, len1);
     }
     /**
-     * Create an ETS model with specified components.
-     * @param error - Error type: "A" (additive) or "M" (multiplicative)
-     * @param trend - Trend type: "N" (none), "A" (additive), or "Ad" (additive damped)
-     * @param seasonal - Seasonal type: "N" (none), "A" (additive), or "M" (multiplicative)
-     * @param period - Seasonal period (ignored if seasonal is "N")
-     * @throws Error if the combination is unstable (MAA or MAdA)
-     * @param {string} error
-     * @param {string} trend
-     * @param {string} seasonal
-     * @param {number} period
+     * Get values for a named regressor.
+     *
+     * @param name - Regressor name
+     * @returns Array of values, or undefined if the regressor does not exist
+     * @param {string} name
+     * @returns {Float64Array | undefined}
      */
-    constructor(error, trend, seasonal, period) {
-        const ptr0 = passStringToWasm0(error, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    getRegressor(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(trend, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ptr2 = passStringToWasm0(seasonal, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len2 = WASM_VECTOR_LEN;
-        const ret = wasm.etsforecaster_new(ptr0, len0, ptr1, len1, ptr2, len2, period);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
+        const ret = wasm.calendarannotations_getRegressor(this.__wbg_ptr, ptr0, len0);
+        let v2;
+        if (ret[0] !== 0) {
+            v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
         }
-        this.__wbg_ptr = ret[0] >>> 0;
-        ETSForecasterFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+        return v2;
     }
     /**
-     * @returns {string}
+     * Get the number of holidays.
+     * @returns {number}
      */
-    get name() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.etsforecaster_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);
-        }
+    holidayCount() {
+        const ret = wasm.calendarannotations_holidayCount(this.__wbg_ptr);
+        return ret >>> 0;
     }
     /**
-     * @param {number} horizon
-     * @returns {Forecast}
+     * Check whether any regressors have been added.
+     * @returns {boolean}
      */
-    predict(horizon) {
-        const ret = wasm.etsforecaster_predict(this.__wbg_ptr, horizon);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return Forecast.__wrap(ret[0]);
-    }
-}
-if (Symbol.dispose) ETSForecaster.prototype[Symbol.dispose] = ETSForecaster.prototype.free;
-
-/**
- * Forecast result wrapper for JavaScript.
- *
- * Contains point predictions and optional prediction intervals.
- */
-export class Forecast {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(Forecast.prototype);
-        obj.__wbg_ptr = ptr;
-        ForecastFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        ForecastFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_forecast_free(ptr, 0);
+    hasRegressors() {
+        const ret = wasm.calendarannotations_hasRegressors(this.__wbg_ptr);
+        return ret !== 0;
     }
     /**
-     * Get lower prediction interval bounds.
+     * Check if a specific date is a business day (not weekend, not holiday).
      *
-     * @returns Array of lower bounds, or undefined if not available
-     * @returns {Float64Array | undefined}
+     * @param timestamp_ms - Date to check as milliseconds since Unix epoch
+     * @returns true if the date is a weekday and not a holiday
+     * @param {number} timestamp_ms
+     * @returns {boolean}
      */
-    get lower() {
-        const ret = wasm.forecast_lower(this.__wbg_ptr);
-        let v1;
-        if (ret[0] !== 0) {
-            v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-            wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        }
-        return v1;
+    isBusinessDay(timestamp_ms) {
+        const ret = wasm.calendarannotations_isBusinessDay(this.__wbg_ptr, timestamp_ms);
+        return ret !== 0;
     }
     /**
-     * Get upper prediction interval bounds.
-     *
-     * @returns Array of upper bounds, or undefined if not available
-     * @returns {Float64Array | undefined}
+     * Get the number of named regressors.
+     * @returns {number}
      */
-    get upper() {
-        const ret = wasm.forecast_upper(this.__wbg_ptr);
-        let v1;
-        if (ret[0] !== 0) {
-            v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-            wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        }
-        return v1;
+    regressorCount() {
+        const ret = wasm.calendarannotations_regressorCount(this.__wbg_ptr);
+        return ret >>> 0;
     }
     /**
-     * Get point predictions.
-     * @returns {Float64Array}
+     * Get the names of all registered regressors.
+     * @returns {any}
      */
-    get values() {
-        const ret = wasm.forecast_values(this.__wbg_ptr);
-        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v1;
+    regressorNames() {
+        const ret = wasm.calendarannotations_regressorNames(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * Get the forecast horizon (number of predictions).
-     * @returns {number}
+     * Create an empty CalendarAnnotations instance.
      */
-    get horizon() {
-        const ret = wasm.forecast_horizon(this.__wbg_ptr);
-        return ret >>> 0;
+    constructor() {
+        const ret = wasm.calendarannotations_new();
+        this.__wbg_ptr = ret >>> 0;
+        CalendarAnnotationsFinalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
     /**
-     * Check if lower prediction interval is available.
-     * @returns {boolean}
+     * Serialize the calendar annotations to a JSON string.
+     *
+     * Useful for persisting or transferring annotations between contexts.
+     *
+     * @returns JSON string with `{ holidays: number[], regressors: { [name]: number[] } }`
+     * @returns {string}
      */
-    hasLower() {
-        const ret = wasm.forecast_hasLower(this.__wbg_ptr);
-        return ret !== 0;
+    toJSON() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.calendarannotations_toJSON(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
     }
     /**
-     * Check if upper prediction interval is available.
-     * @returns {boolean}
+     * Deserialize calendar annotations from a JSON string.
+     *
+     * @param json - JSON string produced by `toJSON()`
+     * @returns A new CalendarAnnotations instance
+     * @param {string} json
+     * @returns {CalendarAnnotations}
      */
-    hasUpper() {
-        const ret = wasm.forecast_hasUpper(this.__wbg_ptr);
-        return ret !== 0;
+    static fromJSON(json) {
+        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.calendarannotations_fromJSON(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return CalendarAnnotations.__wrap(ret[0]);
     }
 }
-if (Symbol.dispose) Forecast.prototype[Symbol.dispose] = Forecast.prototype.free;
+if (Symbol.dispose) CalendarAnnotations.prototype[Symbol.dispose] = CalendarAnnotations.prototype.free;
 
 /**
- * GARCH - Generalized Autoregressive Conditional Heteroskedasticity.
+ * Croston's method for intermittent demand forecasting.
  */
-export class GARCHForecaster {
+export class CrostonForecaster {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        GARCHForecasterFinalization.unregister(this);
+        CrostonForecasterFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_garchforecaster_free(ptr, 0);
+        wasm.__wbg_crostonforecaster_free(ptr, 0);
+    }
+    /**
+     * @param {number} horizon
+     * @param {number} level
+     * @returns {Forecast}
+     */
+    predictWithIntervals(horizon, level) {
+        const ret = wasm.crostonforecaster_predictWithIntervals(this.__wbg_ptr, horizon, level);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
     }
     /**
      * @param {TimeSeries} series
      */
     fit(series) {
         _assertClass(series, TimeSeries);
-        const ret = wasm.garchforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        const ret = wasm.crostonforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
-    /**
-     * @param p - GARCH order (lagged variance terms)
-     * @param q - ARCH order (lagged squared residuals)
-     * @param {number} p
-     * @param {number} q
-     */
-    constructor(p, q) {
-        const ret = wasm.garchforecaster_new(p, q);
+    constructor() {
+        const ret = wasm.crostonforecaster_new();
         this.__wbg_ptr = ret >>> 0;
-        GARCHForecasterFinalization.register(this, this.__wbg_ptr, this);
+        CrostonForecasterFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
     /**
@@ -1147,7 +1389,7 @@ export class GARCHForecaster {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.garchforecaster_name(this.__wbg_ptr);
+            const ret = wasm.crostonforecaster_name(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -1160,49 +1402,66 @@ export class GARCHForecaster {
      * @returns {Forecast}
      */
     predict(horizon) {
-        const ret = wasm.garchforecaster_predict(this.__wbg_ptr, horizon);
+        const ret = wasm.crostonforecaster_predict(this.__wbg_ptr, horizon);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return Forecast.__wrap(ret[0]);
     }
 }
-if (Symbol.dispose) GARCHForecaster.prototype[Symbol.dispose] = GARCHForecaster.prototype.free;
+if (Symbol.dispose) CrostonForecaster.prototype[Symbol.dispose] = CrostonForecaster.prototype.free;
 
 /**
- * Holt Linear Trend (Double Exponential Smoothing) forecaster.
+ * Dynamic Theta forecaster - updates coefficients dynamically.
  */
-export class HoltForecaster {
+export class DynamicThetaForecaster {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(DynamicThetaForecaster.prototype);
+        obj.__wbg_ptr = ptr;
+        DynamicThetaForecasterFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        HoltForecasterFinalization.unregister(this);
+        DynamicThetaForecasterFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_holtforecaster_free(ptr, 0);
+        wasm.__wbg_dynamicthetaforecaster_free(ptr, 0);
+    }
+    /**
+     * @param {number} horizon
+     * @param {number} level
+     * @returns {Forecast}
+     */
+    predictWithIntervals(horizon, level) {
+        const ret = wasm.dynamicthetaforecaster_predictWithIntervals(this.__wbg_ptr, horizon, level);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
     }
     /**
      * @param {TimeSeries} series
      */
     fit(series) {
         _assertClass(series, TimeSeries);
-        const ret = wasm.holtforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        const ret = wasm.dynamicthetaforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
     /**
-     * @param alpha - Level smoothing parameter (0 < alpha <= 1)
-     * @param beta - Trend smoothing parameter (0 < beta <= 1)
+     * @param alpha - Smoothing parameter for the forecast
      * @param {number} alpha
-     * @param {number} beta
      */
-    constructor(alpha, beta) {
-        const ret = wasm.holtforecaster_new(alpha, beta);
+    constructor(alpha) {
+        const ret = wasm.dynamicthetaforecaster_new(alpha);
         this.__wbg_ptr = ret >>> 0;
-        HoltForecasterFinalization.register(this, this.__wbg_ptr, this);
+        DynamicThetaForecasterFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
     /**
@@ -1212,7 +1471,7 @@ export class HoltForecaster {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.holtforecaster_name(this.__wbg_ptr);
+            const ret = wasm.dynamicthetaforecaster_name(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -1225,91 +1484,157 @@ export class HoltForecaster {
      * @returns {Forecast}
      */
     predict(horizon) {
-        const ret = wasm.holtforecaster_predict(this.__wbg_ptr, horizon);
+        const ret = wasm.dynamicthetaforecaster_predict(this.__wbg_ptr, horizon);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return Forecast.__wrap(ret[0]);
     }
+    /**
+     * Create a seasonal Dynamic Theta model.
+     * @param period - Seasonal period
+     * @param {number} period
+     * @returns {DynamicThetaForecaster}
+     */
+    static seasonal(period) {
+        const ret = wasm.dynamicthetaforecaster_seasonal(period);
+        return DynamicThetaForecaster.__wrap(ret);
+    }
+    /**
+     * Create an optimized Dynamic Theta model.
+     * @returns {DynamicThetaForecaster}
+     */
+    static optimized() {
+        const ret = wasm.dynamicthetaforecaster_optimized();
+        return DynamicThetaForecaster.__wrap(ret);
+    }
 }
-if (Symbol.dispose) HoltForecaster.prototype[Symbol.dispose] = HoltForecaster.prototype.free;
+if (Symbol.dispose) DynamicThetaForecaster.prototype[Symbol.dispose] = DynamicThetaForecaster.prototype.free;
 
 /**
- * Holt-Winters (Triple Exponential Smoothing) forecaster.
+ * ETS (Error-Trend-Seasonal) state-space model.
+ *
+ * Use string codes: "A" = Additive, "M" = Multiplicative, "N" = None
+ * Or use standard ETS notation like "ANN", "AAA", "MAM", "AAdM".
+ *
+ * Follows the ETS taxonomy from FPP3: <https://otexts.com/fpp3/taxonomy.html>
+ *
+ * Note: Some combinations are invalid/unstable per FPP3:
+ * - MAA (Multiplicative error + Additive trend + Additive seasonal)
+ * - MAdA (Multiplicative error + Damped trend + Additive seasonal)
  */
-export class HoltWintersForecaster {
+export class ETSForecaster {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(HoltWintersForecaster.prototype);
+        const obj = Object.create(ETSForecaster.prototype);
         obj.__wbg_ptr = ptr;
-        HoltWintersForecasterFinalization.register(obj, obj.__wbg_ptr, obj);
+        ETSForecasterFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        HoltWintersForecasterFinalization.unregister(this);
+        ETSForecasterFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_holtwintersforecaster_free(ptr, 0);
+        wasm.__wbg_etsforecaster_free(ptr, 0);
     }
     /**
-     * Create with multiplicative seasonality.
-     * @param {number} alpha
-     * @param {number} beta
-     * @param {number} gamma
+     * Create an ETS model from standard notation.
+     *
+     * @param notation - ETS notation string like "ANN", "AAA", "MAM", "AAdM"
+     * @param period - Seasonal period (required if notation has seasonal component)
+     *
+     * Format: ErrorTrendSeasonal
+     * - Error: A (additive) or M (multiplicative)
+     * - Trend: N (none), A (additive), or Ad (additive damped)
+     * - Seasonal: N (none), A (additive), or M (multiplicative)
+     *
+     * Examples:
+     * - "ANN" - Simple exponential smoothing
+     * - "AAN" - Holt's linear method
+     * - "AAA" - Holt-Winters additive
+     * - "MAM" - Multiplicative Holt-Winters
+     * - "AAdM" - Damped trend with multiplicative seasonal
+     *
+     * @throws Error for invalid notation or unstable combinations (MAA, MAdA)
+     * @param {string} notation
      * @param {number} period
-     * @returns {HoltWintersForecaster}
+     * @returns {ETSForecaster}
      */
-    static multiplicative(alpha, beta, gamma, period) {
-        const ret = wasm.holtwintersforecaster_multiplicative(alpha, beta, gamma, period);
-        return HoltWintersForecaster.__wrap(ret);
+    static fromNotation(notation, period) {
+        const ptr0 = passStringToWasm0(notation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.etsforecaster_fromNotation(ptr0, len0, period);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ETSForecaster.__wrap(ret[0]);
+    }
+    /**
+     * Check if an ETS specification is valid/stable.
+     *
+     * @param error - Error type: "A" or "M"
+     * @param trend - Trend type: "N", "A", or "Ad"
+     * @param seasonal - Seasonal type: "N", "A", or "M"
+     * @returns true if the combination is stable and usable
+     *
+     * Invalid combinations (return false):
+     * - M,A,A - Multiplicative error with additive trend and additive seasonal
+     * - M,Ad,A - Multiplicative error with damped trend and additive seasonal
+     * @param {string} error
+     * @param {string} trend
+     * @param {string} seasonal
+     * @returns {boolean}
+     */
+    static isValidSpec(error, trend, seasonal) {
+        const ptr0 = passStringToWasm0(error, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(trend, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(seasonal, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.etsforecaster_isValidSpec(ptr0, len0, ptr1, len1, ptr2, len2);
+        return ret !== 0;
     }
     /**
      * @param {TimeSeries} series
      */
     fit(series) {
         _assertClass(series, TimeSeries);
-        const ret = wasm.holtwintersforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        const ret = wasm.etsforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
     /**
-     * Create with additive seasonality.
-     * @param alpha - Level smoothing parameter
-     * @param beta - Trend smoothing parameter
-     * @param gamma - Seasonal smoothing parameter
-     * @param period - Seasonal period
-     * @param {number} alpha
-     * @param {number} beta
-     * @param {number} gamma
-     * @param {number} period
-     */
-    constructor(alpha, beta, gamma, period) {
-        const ret = wasm.holtwintersforecaster_new(alpha, beta, gamma, period);
-        this.__wbg_ptr = ret >>> 0;
-        HoltWintersForecasterFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * Create with automatic parameter optimization.
-     * @param period - Seasonal period
-     * @param seasonal_type - "additive" or "multiplicative"
+     * Create an ETS model with specified components.
+     * @param error - Error type: "A" (additive) or "M" (multiplicative)
+     * @param trend - Trend type: "N" (none), "A" (additive), or "Ad" (additive damped)
+     * @param seasonal - Seasonal type: "N" (none), "A" (additive), or "M" (multiplicative)
+     * @param period - Seasonal period (ignored if seasonal is "N")
+     * @throws Error if the combination is unstable (MAA or MAdA)
+     * @param {string} error
+     * @param {string} trend
+     * @param {string} seasonal
      * @param {number} period
-     * @param {string} seasonal_type
-     * @returns {HoltWintersForecaster}
      */
-    static auto(period, seasonal_type) {
-        const ptr0 = passStringToWasm0(seasonal_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    constructor(error, trend, seasonal, period) {
+        const ptr0 = passStringToWasm0(error, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.holtwintersforecaster_auto(period, ptr0, len0);
+        const ptr1 = passStringToWasm0(trend, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(seasonal, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.etsforecaster_new(ptr0, len0, ptr1, len1, ptr2, len2, period);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return HoltWintersForecaster.__wrap(ret[0]);
+        this.__wbg_ptr = ret[0] >>> 0;
+        ETSForecasterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
     /**
      * @returns {string}
@@ -1318,7 +1643,7 @@ export class HoltWintersForecaster {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.holtwintersforecaster_name(this.__wbg_ptr);
+            const ret = wasm.etsforecaster_name(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -1331,53 +1656,124 @@ export class HoltWintersForecaster {
      * @returns {Forecast}
      */
     predict(horizon) {
-        const ret = wasm.holtwintersforecaster_predict(this.__wbg_ptr, horizon);
+        const ret = wasm.etsforecaster_predict(this.__wbg_ptr, horizon);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return Forecast.__wrap(ret[0]);
     }
 }
-if (Symbol.dispose) HoltWintersForecaster.prototype[Symbol.dispose] = HoltWintersForecaster.prototype.free;
+if (Symbol.dispose) ETSForecaster.prototype[Symbol.dispose] = ETSForecaster.prototype.free;
 
 /**
- * IMAPA (Intermittent Multiple Aggregation Prediction Algorithm).
+ * Ensemble forecaster that combines multiple models.
+ *
+ * Supports mean, median, weighted MSE, and custom-weight combination.
+ * Models are specified by name strings (e.g., "naive", "sma5", "ses").
  */
-export class IMAPAForecaster {
+export class EnsembleForecaster {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        IMAPAForecasterFinalization.unregister(this);
+        EnsembleForecasterFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_imapaforecaster_free(ptr, 0);
+        wasm.__wbg_ensembleforecaster_free(ptr, 0);
+    }
+    /**
+     * Set the combination method to median.
+     */
+    setMedian() {
+        wasm.ensembleforecaster_setMedian(this.__wbg_ptr);
+    }
+    /**
+     * Get the number of models in the ensemble.
+     * @returns {number}
+     */
+    modelCount() {
+        const ret = wasm.ensembleforecaster_modelCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Set custom combination weights.
+     *
+     * Weights are normalized to sum to 1. Length must match number of models.
+     *
+     * @param weights - Array of combination weights
+     * @param {Float64Array} weights
+     */
+    setWeights(weights) {
+        const ptr0 = passArrayF64ToWasm0(weights, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.ensembleforecaster_setWeights(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Set the combination method to weighted MSE.
+     */
+    setWeightedMse() {
+        wasm.ensembleforecaster_setWeightedMse(this.__wbg_ptr);
+    }
+    /**
+     * 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 combined predictions and intervals
+     * @param {number} horizon
+     * @param {number} level
+     * @returns {Forecast}
+     */
+    predictWithIntervals(horizon, level) {
+        const ret = wasm.ensembleforecaster_predictWithIntervals(this.__wbg_ptr, horizon, level);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
     }
     /**
+     * Fit all models in the ensemble.
+     *
+     * @param series - TimeSeries to fit
      * @param {TimeSeries} series
      */
     fit(series) {
         _assertClass(series, TimeSeries);
-        const ret = wasm.imapaforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        const ret = wasm.ensembleforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
-    constructor() {
-        const ret = wasm.imapaforecaster_new();
-        this.__wbg_ptr = ret >>> 0;
-        IMAPAForecasterFinalization.register(this, this.__wbg_ptr, this);
+    /**
+     * Create an ensemble from an array of model name strings.
+     *
+     * Supported names: "naive", "mean", "rwdrift", "ses", "holt",
+     * "autoarima", "autoets", "autotheta", "sma5", "wa10", etc.
+     *
+     * @param modelNames - Array of model name strings
+     * @param {string[]} model_names
+     */
+    constructor(model_names) {
+        const ptr0 = passArrayJsValueToWasm0(model_names, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ensembleforecaster_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        EnsembleForecasterFinalization.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.imapaforecaster_name(this.__wbg_ptr);
+            const ret = wasm.ensembleforecaster_name(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -1386,22 +1782,1264 @@ export class IMAPAForecaster {
         }
     }
     /**
+     * Predict future values using the combined ensemble.
+     *
+     * @param horizon - Number of steps to forecast
+     * @returns Forecast with combined point predictions
      * @param {number} horizon
      * @returns {Forecast}
      */
     predict(horizon) {
-        const ret = wasm.imapaforecaster_predict(this.__wbg_ptr, horizon);
+        const ret = wasm.ensembleforecaster_predict(this.__wbg_ptr, horizon);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return Forecast.__wrap(ret[0]);
     }
 }
-if (Symbol.dispose) IMAPAForecaster.prototype[Symbol.dispose] = IMAPAForecaster.prototype.free;
+if (Symbol.dispose) EnsembleForecaster.prototype[Symbol.dispose] = EnsembleForecaster.prototype.free;
 
 /**
- * MFLES - Multiple Frequency Locally Estimated Scatterplot Smoothing.
- */
+ * Forecast result wrapper for JavaScript.
+ *
+ * Contains point predictions and optional prediction intervals.
+ */
+export class Forecast {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Forecast.prototype);
+        obj.__wbg_ptr = ptr;
+        ForecastFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ForecastFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_forecast_free(ptr, 0);
+    }
+    /**
+     * Get lower prediction interval bounds.
+     *
+     * @returns Array of lower bounds, or undefined if not available
+     * @returns {Float64Array | undefined}
+     */
+    get lower() {
+        const ret = wasm.forecast_lower(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        }
+        return v1;
+    }
+    /**
+     * Get upper prediction interval bounds.
+     *
+     * @returns Array of upper bounds, or undefined if not available
+     * @returns {Float64Array | undefined}
+     */
+    get upper() {
+        const ret = wasm.forecast_upper(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        }
+        return v1;
+    }
+    /**
+     * Get point predictions.
+     * @returns {Float64Array}
+     */
+    get values() {
+        const ret = wasm.forecast_values(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Get the forecast horizon (number of predictions).
+     * @returns {number}
+     */
+    get horizon() {
+        const ret = wasm.forecast_horizon(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Check if lower prediction interval is available.
+     * @returns {boolean}
+     */
+    hasLower() {
+        const ret = wasm.forecast_hasLower(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Check if upper prediction interval is available.
+     * @returns {boolean}
+     */
+    hasUpper() {
+        const ret = wasm.forecast_hasUpper(this.__wbg_ptr);
+        return ret !== 0;
+    }
+}
+if (Symbol.dispose) Forecast.prototype[Symbol.dispose] = Forecast.prototype.free;
+
+/**
+ * GARCH - Generalized Autoregressive Conditional Heteroskedasticity.
+ */
+export class GARCHForecaster {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GARCHForecasterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_garchforecaster_free(ptr, 0);
+    }
+    /**
+     * @param {number} horizon
+     * @param {number} level
+     * @returns {Forecast}
+     */
+    predictWithIntervals(horizon, level) {
+        const ret = wasm.garchforecaster_predictWithIntervals(this.__wbg_ptr, horizon, level);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+    /**
+     * @param {TimeSeries} series
+     */
+    fit(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.garchforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param p - GARCH order (lagged variance terms)
+     * @param q - ARCH order (lagged squared residuals)
+     * @param {number} p
+     * @param {number} q
+     */
+    constructor(p, q) {
+        const ret = wasm.garchforecaster_new(p, q);
+        this.__wbg_ptr = ret >>> 0;
+        GARCHForecasterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.garchforecaster_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);
+        }
+    }
+    /**
+     * @param {number} horizon
+     * @returns {Forecast}
+     */
+    predict(horizon) {
+        const ret = wasm.garchforecaster_predict(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) GARCHForecaster.prototype[Symbol.dispose] = GARCHForecaster.prototype.free;
+
+/**
+ * Holt Linear Trend (Double Exponential Smoothing) forecaster.
+ */
+export class HoltForecaster {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        HoltForecasterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_holtforecaster_free(ptr, 0);
+    }
+    /**
+     * @param {number} horizon
+     * @param {number} level
+     * @returns {Forecast}
+     */
+    predictWithIntervals(horizon, level) {
+        const ret = wasm.holtforecaster_predictWithIntervals(this.__wbg_ptr, horizon, level);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+    /**
+     * @param {TimeSeries} series
+     */
+    fit(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.holtforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param alpha - Level smoothing parameter (0 < alpha <= 1)
+     * @param beta - Trend smoothing parameter (0 < beta <= 1)
+     * @param {number} alpha
+     * @param {number} beta
+     */
+    constructor(alpha, beta) {
+        const ret = wasm.holtforecaster_new(alpha, beta);
+        this.__wbg_ptr = ret >>> 0;
+        HoltForecasterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.holtforecaster_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);
+        }
+    }
+    /**
+     * @param {number} horizon
+     * @returns {Forecast}
+     */
+    predict(horizon) {
+        const ret = wasm.holtforecaster_predict(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) HoltForecaster.prototype[Symbol.dispose] = HoltForecaster.prototype.free;
+
+/**
+ * Holt-Winters (Triple Exponential Smoothing) forecaster.
+ */
+export class HoltWintersForecaster {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(HoltWintersForecaster.prototype);
+        obj.__wbg_ptr = ptr;
+        HoltWintersForecasterFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        HoltWintersForecasterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_holtwintersforecaster_free(ptr, 0);
+    }
+    /**
+     * Create with multiplicative seasonality.
+     * @param {number} alpha
+     * @param {number} beta
+     * @param {number} gamma
+     * @param {number} period
+     * @returns {HoltWintersForecaster}
+     */
+    static multiplicative(alpha, beta, gamma, period) {
+        const ret = wasm.holtwintersforecaster_multiplicative(alpha, beta, gamma, period);
+        return HoltWintersForecaster.__wrap(ret);
+    }
+    /**
+     * @param {number} horizon
+     * @param {number} level
+     * @returns {Forecast}
+     */
+    predictWithIntervals(horizon, level) {
+        const ret = wasm.holtwintersforecaster_predictWithIntervals(this.__wbg_ptr, horizon, level);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+    /**
+     * @param {TimeSeries} series
+     */
+    fit(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.holtwintersforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Create with additive seasonality.
+     * @param alpha - Level smoothing parameter
+     * @param beta - Trend smoothing parameter
+     * @param gamma - Seasonal smoothing parameter
+     * @param period - Seasonal period
+     * @param {number} alpha
+     * @param {number} beta
+     * @param {number} gamma
+     * @param {number} period
+     */
+    constructor(alpha, beta, gamma, period) {
+        const ret = wasm.holtwintersforecaster_new(alpha, beta, gamma, period);
+        this.__wbg_ptr = ret >>> 0;
+        HoltWintersForecasterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Create with automatic parameter optimization.
+     * @param period - Seasonal period
+     * @param seasonal_type - "additive" or "multiplicative"
+     * @param {number} period
+     * @param {string} seasonal_type
+     * @returns {HoltWintersForecaster}
+     */
+    static auto(period, seasonal_type) {
+        const ptr0 = passStringToWasm0(seasonal_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.holtwintersforecaster_auto(period, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return HoltWintersForecaster.__wrap(ret[0]);
+    }
+    /**
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.holtwintersforecaster_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);
+        }
+    }
+    /**
+     * @param {number} horizon
+     * @returns {Forecast}
+     */
+    predict(horizon) {
+        const ret = wasm.holtwintersforecaster_predict(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) HoltWintersForecaster.prototype[Symbol.dispose] = HoltWintersForecaster.prototype.free;
+
+/**
+ * IMAPA (Intermittent Multiple Aggregation Prediction Algorithm).
+ */
+export class IMAPAForecaster {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IMAPAForecasterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_imapaforecaster_free(ptr, 0);
+    }
+    /**
+     * @param {number} horizon
+     * @param {number} level
+     * @returns {Forecast}
+     */
+    predictWithIntervals(horizon, level) {
+        const ret = wasm.imapaforecaster_predictWithIntervals(this.__wbg_ptr, horizon, level);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+    /**
+     * @param {TimeSeries} series
+     */
+    fit(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.imapaforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    constructor() {
+        const ret = wasm.imapaforecaster_new();
+        this.__wbg_ptr = ret >>> 0;
+        IMAPAForecasterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.imapaforecaster_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);
+        }
+    }
+    /**
+     * @param {number} horizon
+     * @returns {Forecast}
+     */
+    predict(horizon) {
+        const ret = wasm.imapaforecaster_predict(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) IMAPAForecaster.prototype[Symbol.dispose] = IMAPAForecaster.prototype.free;
+
+/**
+ * Configuration for backtesting a postprocessor.
+ */
+export class JsBacktestConfig {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(JsBacktestConfig.prototype);
+        obj.__wbg_ptr = ptr;
+        JsBacktestConfigFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsBacktestConfigFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jsbacktestconfig_free(ptr, 0);
+    }
+    /**
+     * Set the initial training window size.
+     * @param {number} size
+     * @returns {JsBacktestConfig}
+     */
+    initialWindow(size) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.jsbacktestconfig_initialWindow(ptr, size);
+        return JsBacktestConfig.__wrap(ret);
+    }
+    /**
+     * Create a new backtest configuration with default settings.
+     *
+     * Defaults: initial_window=50, step=1, horizon=1, expanding=true.
+     */
+    constructor() {
+        const ret = wasm.jsbacktestconfig_new();
+        this.__wbg_ptr = ret >>> 0;
+        JsBacktestConfigFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Set the step size between folds.
+     * @param {number} step
+     * @returns {JsBacktestConfig}
+     */
+    step(step) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.jsbacktestconfig_step(ptr, step);
+        return JsBacktestConfig.__wrap(ret);
+    }
+    /**
+     * Set the forecast horizon.
+     * @param {number} horizon
+     * @returns {JsBacktestConfig}
+     */
+    horizon(horizon) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.jsbacktestconfig_horizon(ptr, horizon);
+        return JsBacktestConfig.__wrap(ret);
+    }
+    /**
+     * Set whether to use expanding (true) or rolling (false) window.
+     * @param {boolean} expanding
+     * @returns {JsBacktestConfig}
+     */
+    expanding(expanding) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.jsbacktestconfig_expanding(ptr, expanding);
+        return JsBacktestConfig.__wrap(ret);
+    }
+}
+if (Symbol.dispose) JsBacktestConfig.prototype[Symbol.dispose] = JsBacktestConfig.prototype.free;
+
+/**
+ * Results from backtesting a postprocessor.
+ */
+export class JsBacktestResult {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(JsBacktestResult.prototype);
+        obj.__wbg_ptr = ptr;
+        JsBacktestResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsBacktestResultFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jsbacktestresult_free(ptr, 0);
+    }
+    /**
+     * Get average interval width across all folds.
+     * @returns {number}
+     */
+    intervalWidths() {
+        const ret = wasm.jsbacktestresult_intervalWidths(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get calibration error (absolute deviation from target coverage).
+     * @param {number} target_coverage
+     * @returns {number}
+     */
+    calibrationError(target_coverage) {
+        const ret = wasm.jsbacktestresult_calibrationError(this.__wbg_ptr, target_coverage);
+        return ret;
+    }
+    /**
+     * Get the number of backtest folds.
+     * @returns {number}
+     */
+    numFolds() {
+        const ret = wasm.jsbacktestresult_numFolds(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get overall coverage across all folds.
+     * @returns {number}
+     */
+    get coverage() {
+        const ret = wasm.jsbacktestresult_coverage(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) JsBacktestResult.prototype[Symbol.dispose] = JsBacktestResult.prototype.free;
+
+/**
+ * Conformal predictor for distribution-free prediction intervals.
+ *
+ * Provides coverage-guaranteed intervals without distributional assumptions.
+ */
+export class JsConformalPredictor {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(JsConformalPredictor.prototype);
+        obj.__wbg_ptr = ptr;
+        JsConformalPredictorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsConformalPredictorFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jsconformalpredictor_free(ptr, 0);
+    }
+    /**
+     * Create a conformal predictor with the Jackknife+ method.
+     *
+     * @param coverage - Target coverage level in (0, 1)
+     * @param {number} coverage
+     * @returns {JsConformalPredictor}
+     */
+    static jackknifePlus(coverage) {
+        const ret = wasm.jsconformalpredictor_jackknifePlus(coverage);
+        return JsConformalPredictor.__wrap(ret);
+    }
+    /**
+     * Generate prediction intervals for new point forecasts.
+     *
+     * @param result - A fitted JsConformalResult from calibrate()
+     * @param pointForecasts - New point forecast values
+     * @param {JsConformalResult} result
+     * @param {Float64Array} point_forecasts
+     * @returns {JsPredictionIntervals}
+     */
+    predictIntervals(result, point_forecasts) {
+        _assertClass(result, JsConformalResult);
+        const ptr0 = passArrayF64ToWasm0(point_forecasts, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.jsconformalpredictor_predictIntervals(this.__wbg_ptr, result.__wbg_ptr, ptr0, len0);
+        return JsPredictionIntervals.__wrap(ret);
+    }
+    /**
+     * Create a split conformal predictor.
+     *
+     * @param coverage - Target coverage level in (0, 1), e.g. 0.90
+     * @param {number} coverage
+     */
+    constructor(coverage) {
+        const ret = wasm.jsconformalpredictor_new(coverage);
+        this.__wbg_ptr = ret >>> 0;
+        JsConformalPredictorFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Calibrate (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 {JsConformalResult}
+     */
+    calibrate(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.jsconformalpredictor_calibrate(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return JsConformalResult.__wrap(ret[0]);
+    }
+    /**
+     * Create a conformal predictor with the cross-validation method.
+     *
+     * @param coverage - Target coverage level in (0, 1)
+     * @param nFolds - Number of cross-validation folds
+     * @param {number} coverage
+     * @param {number} n_folds
+     * @returns {JsConformalPredictor}
+     */
+    static crossVal(coverage, n_folds) {
+        const ret = wasm.jsconformalpredictor_crossVal(coverage, n_folds);
+        return JsConformalPredictor.__wrap(ret);
+    }
+}
+if (Symbol.dispose) JsConformalPredictor.prototype[Symbol.dispose] = JsConformalPredictor.prototype.free;
+
+/**
+ * Conformal prediction result — stores calibration data from fitting.
+ */
+export class JsConformalResult {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(JsConformalResult.prototype);
+        obj.__wbg_ptr = ptr;
+        JsConformalResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsConformalResultFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jsconformalresult_free(ptr, 0);
+    }
+    /**
+     * Get the quantile value (interval half-width).
+     * @returns {number}
+     */
+    quantileValue() {
+        const ret = wasm.jsconformalresult_quantileValue(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get the nonconformity scores.
+     * @returns {Float64Array}
+     */
+    scores() {
+        const ret = wasm.jsconformalresult_scores(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Get the coverage level.
+     * @returns {number}
+     */
+    get coverage() {
+        const ret = wasm.jsconformalresult_coverage(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) JsConformalResult.prototype[Symbol.dispose] = JsConformalResult.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;
+
+/**
+ * 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.jsnormalresult_mean(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get the standard deviation of errors.
+     * @returns {number}
+     */
+    stdDev() {
+        const ret = wasm.jsnormalresult_stdDev(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) JsNormalResult.prototype[Symbol.dispose] = JsNormalResult.prototype.free;
+
+/**
+ * Point forecasts — a sequence of predicted values.
+ *
+ * Used as input for postprocessing methods.
+ */
+export class JsPointForecasts {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsPointForecastsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jspointforecasts_free(ptr, 0);
+    }
+    /**
+     * Create point forecasts from an array of values.
+     * @param {Float64Array} values
+     */
+    constructor(values) {
+        const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.jspointforecasts_new(ptr0, len0);
+        this.__wbg_ptr = ret >>> 0;
+        JsPointForecastsFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Get the number of forecast points.
+     * @returns {number}
+     */
+    get length() {
+        const ret = wasm.jspointforecasts_length(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get the forecast values.
+     * @returns {Float64Array}
+     */
+    get values() {
+        const ret = wasm.jspointforecasts_values(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Check if empty.
+     * @returns {boolean}
+     */
+    isEmpty() {
+        const ret = wasm.jspointforecasts_isEmpty(this.__wbg_ptr);
+        return ret !== 0;
+    }
+}
+if (Symbol.dispose) JsPointForecasts.prototype[Symbol.dispose] = JsPointForecasts.prototype.free;
+
+/**
+ * Unified postprocessor that wraps conformal, normal, and historical simulation
+ * methods behind a single API.
+ */
+export class JsPostProcessor {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(JsPostProcessor.prototype);
+        obj.__wbg_ptr = ptr;
+        JsPostProcessorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsPostProcessorFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jspostprocessor_free(ptr, 0);
+    }
+    /**
+     * Create a historical simulation postprocessor.
+     *
+     * @param quantiles - Sorted quantile levels in (0,1)
+     * @param {Float64Array} quantiles
+     * @returns {JsPostProcessor}
+     */
+    static historicalSim(quantiles) {
+        const ptr0 = passArrayF64ToWasm0(quantiles, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.jspostprocessor_historicalSim(ptr0, len0);
+        return JsPostProcessor.__wrap(ret);
+    }
+    /**
+     * Generate prediction intervals from a trained model.
+     *
+     * @param trained - A JsTrainedModel from train()
+     * @param forecasts - New point forecasts
+     * @param {JsTrainedModel} trained
+     * @param {JsPointForecasts} forecasts
+     * @returns {JsPredictionIntervals}
+     */
+    predictIntervals(trained, forecasts) {
+        _assertClass(trained, JsTrainedModel);
+        _assertClass(forecasts, JsPointForecasts);
+        const ret = wasm.jspostprocessor_predictIntervals(this.__wbg_ptr, trained.__wbg_ptr, forecasts.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return JsPredictionIntervals.__wrap(ret[0]);
+    }
+    /**
+     * Train the postprocessor on historical data.
+     *
+     * @param forecasts - JsPointForecasts with historical predictions
+     * @param actuals - Corresponding actual observed values
+     * @param {JsPointForecasts} forecasts
+     * @param {Float64Array} actuals
+     * @returns {JsTrainedModel}
+     */
+    train(forecasts, actuals) {
+        _assertClass(forecasts, JsPointForecasts);
+        const ptr0 = passArrayF64ToWasm0(actuals, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.jspostprocessor_train(this.__wbg_ptr, forecasts.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return JsTrainedModel.__wrap(ret[0]);
+    }
+    /**
+     * Create a normal prediction postprocessor.
+     *
+     * @param quantiles - Sorted quantile levels in (0,1)
+     * @param {Float64Array} quantiles
+     * @returns {JsPostProcessor}
+     */
+    static normal(quantiles) {
+        const ptr0 = passArrayF64ToWasm0(quantiles, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.jspostprocessor_normal(ptr0, len0);
+        return JsPostProcessor.__wrap(ret);
+    }
+    /**
+     * Create a conformal prediction postprocessor.
+     *
+     * @param coverage - Target coverage level in (0, 1), e.g. 0.90
+     * @param {number} coverage
+     * @returns {JsPostProcessor}
+     */
+    static conformal(coverage) {
+        const ret = wasm.jspostprocessor_conformal(coverage);
+        return JsPostProcessor.__wrap(ret);
+    }
+}
+if (Symbol.dispose) JsPostProcessor.prototype[Symbol.dispose] = JsPostProcessor.prototype.free;
+
+/**
+ * Prediction intervals with lower bounds, upper bounds, and a coverage level.
+ */
+export class JsPredictionIntervals {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(JsPredictionIntervals.prototype);
+        obj.__wbg_ptr = ptr;
+        JsPredictionIntervalsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsPredictionIntervalsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jspredictionintervals_free(ptr, 0);
+    }
+    /**
+     * Compute empirical coverage given actual values.
+     * @param {Float64Array} actuals
+     * @returns {number | undefined}
+     */
+    empiricalCoverage(actuals) {
+        const ptr0 = passArrayF64ToWasm0(actuals, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.jspredictionintervals_empiricalCoverage(this.__wbg_ptr, ptr0, len0);
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+    /**
+     * Get the lower bounds.
+     * @returns {Float64Array}
+     */
+    get lower() {
+        const ret = wasm.jspredictionintervals_lower(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Get the upper bounds.
+     * @returns {Float64Array}
+     */
+    get upper() {
+        const ret = wasm.jspredictionintervals_upper(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Get the number of intervals.
+     * @returns {number}
+     */
+    get length() {
+        const ret = wasm.jspredictionintervals_length(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get the interval widths.
+     * @returns {Float64Array}
+     */
+    widths() {
+        const ret = wasm.jspredictionintervals_widths(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Get the coverage level (e.g. 0.90).
+     * @returns {number}
+     */
+    get coverage() {
+        const ret = wasm.jsnormalresult_mean(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get the interval midpoints.
+     * @returns {Float64Array}
+     */
+    midpoints() {
+        const ret = wasm.jspredictionintervals_midpoints(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) JsPredictionIntervals.prototype[Symbol.dispose] = JsPredictionIntervals.prototype.free;
+
+/**
+ * An opaque handle to a trained postprocessing model.
+ *
+ * Returned by `JsPostProcessor.train()` and consumed by prediction methods.
+ */
+export class JsTrainedModel {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(JsTrainedModel.prototype);
+        obj.__wbg_ptr = ptr;
+        JsTrainedModelFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsTrainedModelFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jstrainedmodel_free(ptr, 0);
+    }
+}
+if (Symbol.dispose) JsTrainedModel.prototype[Symbol.dispose] = JsTrainedModel.prototype.free;
+
+/**
+ * MFLES - Multiple Frequency Locally Estimated Scatterplot Smoothing.
+ */
 export class MFLESForecaster {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -1413,6 +3051,18 @@ export class MFLESForecaster {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_mflesforecaster_free(ptr, 0);
     }
+    /**
+     * @param {number} horizon
+     * @param {number} level
+     * @returns {Forecast}
+     */
+    predictWithIntervals(horizon, level) {
+        const ret = wasm.mflesforecaster_predictWithIntervals(this.__wbg_ptr, horizon, level);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
     /**
      * @param {TimeSeries} series
      */
@@ -1914,6 +3564,18 @@ export class SESForecaster {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_sesforecaster_free(ptr, 0);
     }
+    /**
+     * @param {number} horizon
+     * @param {number} level
+     * @returns {Forecast}
+     */
+    predictWithIntervals(horizon, level) {
+        const ret = wasm.sesforecaster_predictWithIntervals(this.__wbg_ptr, horizon, level);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
     /**
      * @param {TimeSeries} series
      */
@@ -2233,6 +3895,13 @@ if (Symbol.dispose) SeasonalWindowAverageForecaster.prototype[Symbol.dispose] =
  * TBATS - Trigonometric seasonality, Box-Cox, ARMA errors, Trend, Seasonal.
  */
 export class TBATSForecaster {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(TBATSForecaster.prototype);
+        obj.__wbg_ptr = ptr;
+        TBATSForecasterFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -2243,6 +3912,65 @@ export class TBATSForecaster {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_tbatsforecaster_free(ptr, 0);
     }
+    /**
+     * Enable Box-Cox transformation.
+     *
+     * @param lambda - Box-Cox parameter (0 = log, 1 = identity)
+     * @param {number} lambda
+     */
+    setBoxCox(lambda) {
+        wasm.tbatsforecaster_setBoxCox(this.__wbg_ptr, lambda);
+    }
+    /**
+     * Set Fourier K (number of harmonics) for each seasonal period.
+     *
+     * @param k - Array of K values (one per seasonal period)
+     * @param {Uint32Array} k
+     */
+    setFourierK(k) {
+        const ptr0 = passArray32ToWasm0(k, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.tbatsforecaster_setFourierK(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Enable damped trend.
+     *
+     * @param phi - Damping parameter (typically 0.8-0.99)
+     * @param {number} phi
+     */
+    setDampedTrend(phi) {
+        wasm.tbatsforecaster_setDampedTrend(this.__wbg_ptr, phi);
+    }
+    /**
+     * Create a TBATSForecaster with specified seasonal periods.
+     *
+     * @param periods - Array of seasonal periods
+     * @returns A new TBATSForecaster
+     * @param {Uint32Array} periods
+     * @returns {TBATSForecaster}
+     */
+    static withSeasonalPeriods(periods) {
+        const ptr0 = passArray32ToWasm0(periods, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.tbatsforecaster_new(ptr0, len0);
+        return TBATSForecaster.__wrap(ret);
+    }
+    /**
+     * Predict with prediction intervals.
+     *
+     * @param horizon - Number of steps to forecast
+     * @param level - Confidence level (e.g., 0.95 for 95% intervals)
+     * @param {number} horizon
+     * @param {number} level
+     * @returns {Forecast}
+     */
+    predictWithIntervals(horizon, level) {
+        const ret = wasm.tbatsforecaster_predictWithIntervals(this.__wbg_ptr, horizon, level);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
     /**
      * @param {TimeSeries} series
      */
@@ -2291,6 +4019,17 @@ export class TBATSForecaster {
         }
         return Forecast.__wrap(ret[0]);
     }
+    /**
+     * Set ARMA error orders.
+     *
+     * @param p - AR order
+     * @param q - MA order
+     * @param {number} p
+     * @param {number} q
+     */
+    setArma(p, q) {
+        wasm.tbatsforecaster_setArma(this.__wbg_ptr, p, q);
+    }
 }
 if (Symbol.dispose) TBATSForecaster.prototype[Symbol.dispose] = TBATSForecaster.prototype.free;
 
@@ -2308,6 +4047,18 @@ export class TSBForecaster {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_tsbforecaster_free(ptr, 0);
     }
+    /**
+     * @param {number} horizon
+     * @param {number} level
+     * @returns {Forecast}
+     */
+    predictWithIntervals(horizon, level) {
+        const ret = wasm.tsbforecaster_predictWithIntervals(this.__wbg_ptr, horizon, level);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
     /**
      * @param {TimeSeries} series
      */
@@ -2448,6 +4199,33 @@ export class TimeSeries {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_timeseries_free(ptr, 0);
     }
+    /**
+     * Check if calendar annotations are attached.
+     * @returns {boolean}
+     */
+    hasCalendar() {
+        const ret = wasm.timeseries_hasCalendar(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Attach calendar annotations (holidays, regressors) to this time series.
+     *
+     * Models that support exogenous variables will automatically use the
+     * calendar annotations during fitting.
+     *
+     * @param calendar - CalendarAnnotations instance
+     * @param {CalendarAnnotations} calendar
+     */
+    setCalendar(calendar) {
+        _assertClass(calendar, CalendarAnnotations);
+        wasm.timeseries_setCalendar(this.__wbg_ptr, calendar.__wbg_ptr);
+    }
+    /**
+     * Remove calendar annotations from this time series.
+     */
+    clearCalendar() {
+        wasm.timeseries_clearCalendar(this.__wbg_ptr);
+    }
     /**
      * Create a time series with timestamps.
      *
@@ -2604,6 +4382,264 @@ export class WindowAverageForecaster {
 }
 if (Symbol.dispose) WindowAverageForecaster.prototype[Symbol.dispose] = WindowAverageForecaster.prototype.free;
 
+/**
+ * Perform the Augmented Dickey-Fuller (ADF) test for unit root.
+ *
+ * Tests the null hypothesis that the series has a unit root (non-stationary).
+ * Rejection (low p-value, negative statistic below critical values) implies
+ * stationarity.
+ *
+ * @param values - Array of numeric values
+ * @param maxLags - Maximum lags to include (default: (n-1)^(1/3))
+ * @returns Object with `statistic`, `pValue`, `lags`, `isStationary`, and `criticalValues`
+ * @param {Float64Array} values
+ * @param {number | null} [max_lags]
+ * @returns {any}
+ */
+export function adfTest(values, max_lags) {
+    const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.adfTest(ptr0, len0, isLikeNone(max_lags) ? 0x100000001 : (max_lags) >>> 0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Compute the approximate entropy of a time series.
+ *
+ * Measures the complexity/regularity of a time series, including self-matches.
+ *
+ * @param values - Array of numeric values
+ * @param m - Embedding dimension (typically 2)
+ * @param r - Tolerance (typically 0.2 * standard deviation)
+ * @returns Approximate entropy, or NaN if insufficient data
+ * @param {Float64Array} values
+ * @param {number} m
+ * @param {number} r
+ * @returns {number}
+ */
+export function approximateEntropy(values, m, r) {
+    const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.approximateEntropy(ptr0, len0, m, r);
+    return ret;
+}
+
+/**
+ * Compute the autocorrelation of a time series at a specific lag.
+ *
+ * @param values - Array of numeric values
+ * @param lag - Lag value
+ * @returns Autocorrelation coefficient at the given lag
+ * @param {Float64Array} values
+ * @param {number} lag
+ * @returns {number}
+ */
+export function autocorrelation(values, lag) {
+    const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.autocorrelation(ptr0, len0, lag);
+    return ret;
+}
+
+/**
+ * Run a backtest on a postprocessor.
+ *
+ * @param processor - The postprocessor to evaluate
+ * @param forecasts - All historical point forecasts
+ * @param actuals - All historical actual values
+ * @param config - Backtest configuration
+ * @param {JsPostProcessor} processor
+ * @param {JsPointForecasts} forecasts
+ * @param {Float64Array} actuals
+ * @param {JsBacktestConfig} config
+ * @returns {JsBacktestResult}
+ */
+export function backtestPostProcessor(processor, forecasts, actuals, config) {
+    _assertClass(processor, JsPostProcessor);
+    _assertClass(forecasts, JsPointForecasts);
+    const ptr0 = passArrayF64ToWasm0(actuals, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    _assertClass(config, JsBacktestConfig);
+    var ptr1 = config.__destroy_into_raw();
+    const ret = wasm.backtestPostProcessor(processor.__wbg_ptr, forecasts.__wbg_ptr, ptr0, len0, ptr1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return JsBacktestResult.__wrap(ret[0]);
+}
+
+/**
+ * Generate a bootstrap forecast with empirical prediction intervals.
+ *
+ * Uses residual bootstrap: resamples fitted residuals, generates synthetic
+ * series, re-fits the model, and collects forecast distributions to
+ * compute confidence intervals.
+ *
+ * @param values - Array of numeric values
+ * @param timestamps - Optional array of timestamps as milliseconds since epoch
+ * @param modelType - Model type: "naive", "ses", "holt", "autoarima", "autoets", "autotheta", "sma5", etc.
+ * @param horizon - Number of steps to forecast
+ * @param level - Confidence level (e.g., 0.95 for 95% intervals)
+ * @param nSamples - Number of bootstrap samples (default: 200)
+ * @returns Object with `point`, `lower`, `upper`, `level`, `nSamples`
+ * @param {Float64Array} values
+ * @param {Float64Array | null | undefined} timestamps
+ * @param {string} model_type
+ * @param {number} horizon
+ * @param {number} level
+ * @param {number | null} [n_samples]
+ * @returns {any}
+ */
+export function bootstrapForecast(values, timestamps, model_type, horizon, level, n_samples) {
+    const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(timestamps) ? 0 : passArrayF64ToWasm0(timestamps, wasm.__wbindgen_malloc);
+    var len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(model_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.bootstrapForecast(ptr0, len0, ptr1, len1, ptr2, len2, horizon, level, isLikeNone(n_samples) ? 0x100000001 : (n_samples) >>> 0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Perform time series cross-validation with expanding window.
+ *
+ * Evaluates a forecasting model using multiple train/test splits where
+ * the training window grows with each fold.
+ *
+ * @param values - Array of numeric values
+ * @param timestamps - Optional array of timestamps as milliseconds since epoch
+ * @param modelType - Model type: "naive", "ses", "holt", "autoarima", "autoets", "autotheta", "sma5", etc.
+ * @param horizon - Forecast horizon for each fold
+ * @param initialWindow - Initial training window size (default: max(10, length/3))
+ * @returns Object with `rmse`, `mae`, `mape`, `smape`, `folds`, `maeStd`, `rmseStd`
+ * @param {Float64Array} values
+ * @param {Float64Array | null | undefined} timestamps
+ * @param {string} model_type
+ * @param {number} horizon
+ * @param {number | null} [initial_window]
+ * @returns {any}
+ */
+export function crossValidate(values, timestamps, model_type, horizon, initial_window) {
+    const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(timestamps) ? 0 : passArrayF64ToWasm0(timestamps, wasm.__wbindgen_malloc);
+    var len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(model_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.crossValidate(ptr0, len0, ptr1, len1, ptr2, len2, horizon, isLikeNone(initial_window) ? 0x100000001 : (initial_window) >>> 0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Detect changepoints in a time series using the PELT algorithm.
+ *
+ * Returns an object with `changepoints` (indices), `segments` (boundary pairs),
+ * `cost`, `nChangepoints`, and `segmentMeans`.
+ *
+ * @param values - Array of numeric values
+ * @param penalty - Penalty for each changepoint (controls number of changepoints; higher = fewer)
+ * @param costFunction - Cost function: "l1", "l2" (default), "normal", "poisson", "linearTrend", "meanVariance", or "cusum"
+ * @param minSegmentLength - Minimum segment length (default: 2)
+ * @returns Object with changepoint detection results
+ * @param {Float64Array} values
+ * @param {number} penalty
+ * @param {string | null} [cost_function]
+ * @param {number | null} [min_segment_length]
+ * @returns {any}
+ */
+export function detectChangepoints(values, penalty, cost_function, min_segment_length) {
+    const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(cost_function) ? 0 : passStringToWasm0(cost_function, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    const ret = wasm.detectChangepoints(ptr0, len0, penalty, ptr1, len1, isLikeNone(min_segment_length) ? 0x100000001 : (min_segment_length) >>> 0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Detect changepoints using BIC penalty (penalty = log(n)).
+ *
+ * BIC penalty automatically adapts to series length, providing a good
+ * default for most use cases.
+ *
+ * @param values - Array of numeric values
+ * @param costFunction - Cost function (default: "l2")
+ * @returns Object with changepoint detection results
+ * @param {Float64Array} values
+ * @param {string | null} [cost_function]
+ * @returns {any}
+ */
+export function detectChangepointsBic(values, cost_function) {
+    const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(cost_function) ? 0 : passStringToWasm0(cost_function, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    const ret = wasm.detectChangepointsBic(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Run comprehensive residual diagnostics.
+ *
+ * Combines Ljung-Box (autocorrelation), Durbin-Watson (first-order autocorrelation),
+ * and Jarque-Bera (normality) tests into a single diagnostic report.
+ *
+ * @param residuals - Array of model residuals
+ * @param fittedParams - Number of fitted model parameters (default: 0)
+ * @returns Object with `ljungBox`, `durbinWatson`, `jarqueBera`, `mean`, `variance`, `n`, and `isAdequate`
+ * @param {Float64Array} residuals
+ * @param {number | null} [fitted_params]
+ * @returns {any}
+ */
+export function diagnoseResiduals(residuals, fitted_params) {
+    const ptr0 = passArrayF64ToWasm0(residuals, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.diagnoseResiduals(ptr0, len0, isLikeNone(fitted_params) ? 0x100000001 : (fitted_params) >>> 0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Perform the Durbin-Watson test for first-order autocorrelation.
+ *
+ * The statistic ranges from 0 to 4:
+ * - Near 0: Strong positive autocorrelation
+ * - Near 2: No autocorrelation
+ * - Near 4: Strong negative autocorrelation
+ *
+ * @param residuals - Array of model residuals
+ * @returns Object with `statistic` and `interpretation`
+ * @param {Float64Array} residuals
+ * @returns {any}
+ */
+export function durbinWatson(residuals) {
+    const ptr0 = passArrayF64ToWasm0(residuals, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.durbinWatson(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Initialize the WASM module.
  *
@@ -2613,6 +4649,237 @@ export function init() {
     wasm.init();
 }
 
+/**
+ * Perform the Jarque-Bera test for normality of residuals.
+ *
+ * Tests the null hypothesis that residuals are normally distributed by
+ * examining skewness and kurtosis. A high statistic (low p-value) suggests
+ * non-normality.
+ *
+ * @param residuals - Array of model residuals
+ * @returns Object with `statistic`, `pValue`, `isNormal`, `skewness`, and `excessKurtosis`
+ * @param {Float64Array} residuals
+ * @returns {any}
+ */
+export function jarqueBera(residuals) {
+    const ptr0 = passArrayF64ToWasm0(residuals, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.jarqueBera(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Perform the KPSS test for stationarity.
+ *
+ * Tests the null hypothesis that the series is (level) stationary.
+ * Rejection (high statistic above critical values) implies non-stationarity.
+ *
+ * Note: ADF and KPSS test opposite null hypotheses:
+ * - ADF: H0 = non-stationary, reject = stationary
+ * - KPSS: H0 = stationary, reject = non-stationary
+ *
+ * @param values - Array of numeric values
+ * @param lags - Number of lags for HAC variance (default: 4*(n/100)^0.25)
+ * @returns Object with `statistic`, `pValue`, `lags`, `isStationary`, and `criticalValues`
+ * @param {Float64Array} values
+ * @param {number | null} [lags]
+ * @returns {any}
+ */
+export function kpssTest(values, lags) {
+    const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.kpssTest(ptr0, len0, isLikeNone(lags) ? 0x100000001 : (lags) >>> 0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Compute the excess kurtosis (fourth standardized moment) of a time series.
+ *
+ * Measures the "tailedness" of the distribution. A normal distribution has
+ * excess kurtosis of 0.
+ *
+ * @param values - Array of numeric values
+ * @returns Excess kurtosis, or NaN if fewer than 4 values
+ * @param {Float64Array} values
+ * @returns {number}
+ */
+export function kurtosis(values) {
+    const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.kurtosis(ptr0, len0);
+    return ret;
+}
+
+/**
+ * Perform the Ljung-Box test for autocorrelation in residuals.
+ *
+ * Tests the null hypothesis that residuals are independently distributed
+ * (white noise). A low p-value suggests significant autocorrelation remains.
+ *
+ * @param residuals - Array of model residuals
+ * @param lags - Number of lags to include (default: min(10, n/5))
+ * @param fittedParams - Number of fitted model parameters (for df adjustment, default: 0)
+ * @returns Object with `statistic`, `pValue`, `lags`, `df`, and `isWhiteNoise`
+ * @param {Float64Array} residuals
+ * @param {number | null} [lags]
+ * @param {number | null} [fitted_params]
+ * @returns {any}
+ */
+export function ljungBox(residuals, lags, fitted_params) {
+    const ptr0 = passArrayF64ToWasm0(residuals, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.ljungBox(ptr0, len0, isLikeNone(lags) ? 0x100000001 : (lags) >>> 0, isLikeNone(fitted_params) ? 0x100000001 : (fitted_params) >>> 0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Compute the arithmetic mean of a time series.
+ *
+ * @param values - Array of numeric values
+ * @returns Arithmetic mean, or NaN if empty
+ * @param {Float64Array} values
+ * @returns {number}
+ */
+export function mean(values) {
+    const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mean(ptr0, len0);
+    return ret;
+}
+
+/**
+ * Perform MSTL (Multiple Seasonal-Trend decomposition using LOESS).
+ *
+ * Decomposes a time series with multiple seasonal periods into trend,
+ * multiple seasonal components, and remainder.
+ *
+ * @param values - Array of numeric values
+ * @param periods - Array of seasonal periods (e.g., [7, 365] for daily data)
+ * @returns Object with `trend`, `seasonals` (array of arrays), `seasonalPeriods`, `remainder`, and `trendStrength`
+ * @param {Float64Array} values
+ * @param {Uint32Array} periods
+ * @returns {any}
+ */
+export function mstlDecompose(values, periods) {
+    const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray32ToWasm0(periods, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.mstlDecompose(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Compute the partial autocorrelation of a time series at a specific lag.
+ *
+ * Uses the Durbin-Levinson algorithm.
+ *
+ * @param values - Array of numeric values
+ * @param lag - Lag value (must be >= 1)
+ * @returns Partial autocorrelation coefficient at the given lag
+ * @param {Float64Array} values
+ * @param {number} lag
+ * @returns {number}
+ */
+export function partialAutocorrelation(values, lag) {
+    const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.partialAutocorrelation(ptr0, len0, lag);
+    return ret;
+}
+
+/**
+ * Compute the sample entropy of a time series.
+ *
+ * Measures the complexity/regularity of a time series. Lower values indicate
+ * more regularity. Unlike approximate entropy, excludes self-matches.
+ *
+ * @param values - Array of numeric values
+ * @param m - Embedding dimension (typically 2)
+ * @param r - Tolerance (typically 0.2 * standard deviation)
+ * @returns Sample entropy, or NaN if insufficient data
+ * @param {Float64Array} values
+ * @param {number} m
+ * @param {number} r
+ * @returns {number}
+ */
+export function sampleEntropy(values, m, r) {
+    const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.sampleEntropy(ptr0, len0, m, r);
+    return ret;
+}
+
+/**
+ * Compute the skewness (third standardized moment) of a time series.
+ *
+ * Measures the asymmetry of the distribution.
+ *
+ * @param values - Array of numeric values
+ * @returns Skewness, or NaN if fewer than 3 values
+ * @param {Float64Array} values
+ * @returns {number}
+ */
+export function skewness(values) {
+    const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.skewness(ptr0, len0);
+    return ret;
+}
+
+/**
+ * Perform STL (Seasonal-Trend decomposition using LOESS).
+ *
+ * Decomposes a time series into trend, seasonal, and remainder components.
+ *
+ * @param values - Array of numeric values
+ * @param period - Seasonal period (e.g., 12 for monthly data)
+ * @param robust - Enable robust fitting to reduce outlier influence (default: false)
+ * @returns Object with `trend`, `seasonal`, `remainder`, `seasonalStrength`, and `trendStrength`
+ * @param {Float64Array} values
+ * @param {number} period
+ * @param {boolean | null} [robust]
+ * @returns {any}
+ */
+export function stlDecompose(values, period, robust) {
+    const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.stlDecompose(ptr0, len0, period, isLikeNone(robust) ? 0xFFFFFF : robust ? 1 : 0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Compute the population variance of a time series.
+ *
+ * Uses population formula (n denominator) matching tsfresh.
+ *
+ * @param values - Array of numeric values
+ * @returns Population variance, or NaN if empty
+ * @param {Float64Array} values
+ * @returns {number}
+ */
+export function variance(values) {
+    const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.variance(ptr0, len0);
+    return ret;
+}
+
 /**
  * Get the library version.
  * @returns {string}
@@ -2669,17 +4936,156 @@ function __wbg_get_imports() {
         const ret = Error(getStringFromWasm0(arg0, arg1));
         return ret;
     };
+    imports.wbg.__wbg_String_8f0eb39a4a4c2f66 = function(arg0, arg1) {
+        const ret = String(arg1);
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    imports.wbg.__wbg___wbindgen_is_function_8d400b8b1af978cd = function(arg0) {
+        const ret = typeof(arg0) === 'function';
+        return ret;
+    };
+    imports.wbg.__wbg___wbindgen_is_object_ce774f3490692386 = function(arg0) {
+        const val = arg0;
+        const ret = typeof(val) === 'object' && val !== null;
+        return ret;
+    };
+    imports.wbg.__wbg___wbindgen_is_string_704ef9c8fc131030 = function(arg0) {
+        const ret = typeof(arg0) === 'string';
+        return ret;
+    };
+    imports.wbg.__wbg___wbindgen_is_undefined_f6b95eab589e0269 = function(arg0) {
+        const ret = arg0 === undefined;
+        return ret;
+    };
+    imports.wbg.__wbg___wbindgen_string_get_a2a31e16edf96e42 = function(arg0, arg1) {
+        const obj = arg1;
+        const ret = typeof(obj) === 'string' ? obj : undefined;
+        var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
     imports.wbg.__wbg___wbindgen_throw_dd24417ed36fc46e = function(arg0, arg1) {
         throw new Error(getStringFromWasm0(arg0, arg1));
     };
+    imports.wbg.__wbg_call_3020136f7a2d6e44 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = arg0.call(arg1, arg2);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_call_abb4ff46ce38be40 = function() { return handleError(function (arg0, arg1) {
+        const ret = arg0.call(arg1);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_crypto_574e78ad8b13b65f = function(arg0) {
+        const ret = arg0.crypto;
+        return ret;
+    };
+    imports.wbg.__wbg_getRandomValues_b8f5dbd5f3995a9e = function() { return handleError(function (arg0, arg1) {
+        arg0.getRandomValues(arg1);
+    }, arguments) };
     imports.wbg.__wbg_getTime_ad1e9878a735af08 = function(arg0) {
         const ret = arg0.getTime();
         return ret;
     };
+    imports.wbg.__wbg_length_22ac23eaec9d8053 = function(arg0) {
+        const ret = arg0.length;
+        return ret;
+    };
+    imports.wbg.__wbg_msCrypto_a61aeb35a24c1329 = function(arg0) {
+        const ret = arg0.msCrypto;
+        return ret;
+    };
     imports.wbg.__wbg_new_0_23cedd11d9b40c9d = function() {
         const ret = new Date();
         return ret;
     };
+    imports.wbg.__wbg_new_1ba21ce319a06297 = function() {
+        const ret = new Object();
+        return ret;
+    };
+    imports.wbg.__wbg_new_25f239778d6112b9 = function() {
+        const ret = new Array();
+        return ret;
+    };
+    imports.wbg.__wbg_new_no_args_cb138f77cf6151ee = function(arg0, arg1) {
+        const ret = new Function(getStringFromWasm0(arg0, arg1));
+        return ret;
+    };
+    imports.wbg.__wbg_new_with_length_aa5eaf41d35235e5 = function(arg0) {
+        const ret = new Uint8Array(arg0 >>> 0);
+        return ret;
+    };
+    imports.wbg.__wbg_node_905d3e251edff8a2 = function(arg0) {
+        const ret = arg0.node;
+        return ret;
+    };
+    imports.wbg.__wbg_process_dc0fbacc7c1c06f7 = function(arg0) {
+        const ret = arg0.process;
+        return ret;
+    };
+    imports.wbg.__wbg_prototypesetcall_dfe9b766cdc1f1fd = function(arg0, arg1, arg2) {
+        Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+    };
+    imports.wbg.__wbg_randomFillSync_ac0988aba3254290 = function() { return handleError(function (arg0, arg1) {
+        arg0.randomFillSync(arg1);
+    }, arguments) };
+    imports.wbg.__wbg_require_60cc747a6bc5215a = function() { return handleError(function () {
+        const ret = module.require;
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
+        arg0[arg1] = arg2;
+    };
+    imports.wbg.__wbg_set_7df433eea03a5c14 = function(arg0, arg1, arg2) {
+        arg0[arg1 >>> 0] = arg2;
+    };
+    imports.wbg.__wbg_static_accessor_GLOBAL_769e6b65d6557335 = function() {
+        const ret = typeof global === 'undefined' ? null : global;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_static_accessor_GLOBAL_THIS_60cf02db4de8e1c1 = function() {
+        const ret = typeof globalThis === 'undefined' ? null : globalThis;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_static_accessor_SELF_08f5a74c69739274 = function() {
+        const ret = typeof self === 'undefined' ? null : self;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_static_accessor_WINDOW_a8924b26aa92d024 = function() {
+        const ret = typeof window === 'undefined' ? null : window;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_subarray_845f2f5bce7d061a = function(arg0, arg1, arg2) {
+        const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
+        return ret;
+    };
+    imports.wbg.__wbg_versions_c01dfd4722a88165 = function(arg0) {
+        const ret = arg0.versions;
+        return ret;
+    };
+    imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
+        // Cast intrinsic for `Ref(String) -> Externref`.
+        const ret = getStringFromWasm0(arg0, arg1);
+        return ret;
+    };
+    imports.wbg.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
+        // Cast intrinsic for `U64 -> Externref`.
+        const ret = BigInt.asUintN(64, arg0);
+        return ret;
+    };
+    imports.wbg.__wbindgen_cast_cb9088102bce6b30 = function(arg0, arg1) {
+        // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
+        const ret = getArrayU8FromWasm0(arg0, arg1);
+        return ret;
+    };
+    imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
+        // Cast intrinsic for `F64 -> Externref`.
+        const ret = arg0;
+        return ret;
+    };
     imports.wbg.__wbindgen_init_externref_table = function() {
         const table = wasm.__wbindgen_externrefs;
         const offset = table.grow(4);
@@ -2696,6 +5102,7 @@ function __wbg_get_imports() {
 function __wbg_finalize_init(instance, module) {
     wasm = instance.exports;
     __wbg_init.__wbindgen_wasm_module = module;
+    cachedDataViewMemory0 = null;
     cachedFloat64ArrayMemory0 = null;
     cachedUint32ArrayMemory0 = null;
     cachedUint8ArrayMemory0 = null;