@sipemu/anofox-forecast 0.4.9 → 0.5.1

package/anofox_forecast_js.js

@@ -12,6 +12,71 @@ function _assertClass(instance, klass) {
     }
 }
 
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
 function getArrayF64FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
@@ -224,6 +289,10 @@ const EnsembleForecasterFinalization = (typeof FinalizationRegistry === 'undefin
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_ensembleforecaster_free(ptr >>> 0, 1));
 
+const FeatureGeneratorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_featuregenerator_free(ptr >>> 0, 1));
+
 const ForecastFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_forecast_free(ptr >>> 0, 1));
@@ -252,6 +321,14 @@ const JsBacktestResultFinalization = (typeof FinalizationRegistry === 'undefined
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_jsbacktestresult_free(ptr >>> 0, 1));
 
+const JsBootstrapPredictorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jsbootstrappredictor_free(ptr >>> 0, 1));
+
+const JsBootstrapResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jsbootstrapresult_free(ptr >>> 0, 1));
+
 const JsConformalPredictorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_jsconformalpredictor_free(ptr >>> 0, 1));
@@ -280,6 +357,10 @@ const JsNormalResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_jsnormalresult_free(ptr >>> 0, 1));
 
+const JsPerStepConformalResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jsperstepconformalresult_free(ptr >>> 0, 1));
+
 const JsPointForecastsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_jspointforecasts_free(ptr >>> 0, 1));
@@ -1953,6 +2034,162 @@ export class EnsembleForecaster {
 }
 if (Symbol.dispose) EnsembleForecaster.prototype[Symbol.dispose] = EnsembleForecaster.prototype.free;
 
+/**
+ * Deterministic feature generator for timestamp-based regressors.
+ *
+ * Builds Fourier terms, one-hot calendar indicators, cyclical sin/cos
+ * encodings, binary flags and advanced numeric features from timestamps
+ * alone. Because features are purely deterministic they are safe for
+ * cross-validation and can be shared across models.
+ *
+ * Use the builder pattern to configure features, then call `generate()`
+ * to produce a JS object mapping feature names to `Float64Array` values.
+ *
+ * @example
+ * ```js
+ * const gen = new FeatureGenerator();
+ * gen.fourier(7, 3);
+ * gen.dayOfWeek();
+ * gen.cyclical("month");
+ * gen.binary("weekend");
+ * gen.advanced("days_in_month");
+ *
+ * const features = gen.generate(timestamps); // { fourier_7_sin1: [...], ... }
+ * const names = gen.featureNames(); // sorted array of column names
+ * ```
+ */
+export class FeatureGenerator {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        FeatureGeneratorFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_featuregenerator_free(ptr, 0);
+    }
+    /**
+     * Add day-of-week one-hot indicators (Mon-Sat, Sunday dropped).
+     */
+    dayOfWeek() {
+        wasm.featuregenerator_dayOfWeek(this.__wbg_ptr);
+    }
+    /**
+     * Return the sorted list of column names this generator will produce.
+     *
+     * @returns Array of feature name strings
+     * @returns {any}
+     */
+    featureNames() {
+        const ret = wasm.featuregenerator_featureNames(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Add month-of-year one-hot indicators (Feb-Dec, January dropped).
+     */
+    monthOfYear() {
+        wasm.featuregenerator_monthOfYear(this.__wbg_ptr);
+    }
+    /**
+     * Create an empty feature generator.
+     */
+    constructor() {
+        const ret = wasm.featuregenerator_new();
+        this.__wbg_ptr = ret >>> 0;
+        FeatureGeneratorFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Add a binary (0/1) calendar indicator.
+     *
+     * @param indicator - One of: "weekend", "month_start", "month_end",
+     *   "quarter_start", "quarter_end", "year_start", "year_end"
+     * @param {string} indicator
+     */
+    binary(indicator) {
+        const ptr0 = passStringToWasm0(indicator, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.featuregenerator_binary(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Add Fourier terms for a given period and order.
+     *
+     * Produces `2 * order` columns (`fourier_{period}_sin{k}`,
+     * `fourier_{period}_cos{k}` for k in 1..=order).
+     *
+     * @param period - Period in observation units (e.g. 7 for weekly in daily data)
+     * @param order  - Number of harmonics
+     * @param {number} period
+     * @param {number} order
+     */
+    fourier(period, order) {
+        wasm.featuregenerator_fourier(this.__wbg_ptr, period, order);
+    }
+    /**
+     * Add quarter one-hot indicators (Q2-Q4, Q1 dropped).
+     */
+    quarter() {
+        wasm.featuregenerator_quarter(this.__wbg_ptr);
+    }
+    /**
+     * Add an advanced numeric calendar feature.
+     *
+     * @param feature - One of: "leap_year", "days_in_month"
+     * @param {string} feature
+     */
+    advanced(feature) {
+        const ptr0 = passStringToWasm0(feature, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.featuregenerator_advanced(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Add cyclical sin/cos encoding of a time component.
+     *
+     * Produces 2 columns: `{name}_sin` and `{name}_cos`.
+     *
+     * @param component - One of: "month", "quarter", "semester",
+     *   "week_of_year", "day_of_week", "day_of_month", "day_of_year",
+     *   "hour", "minute", "second"
+     * @param {string} component
+     */
+    cyclical(component) {
+        const ptr0 = passStringToWasm0(component, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.featuregenerator_cyclical(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Generate features for the given timestamps.
+     *
+     * @param timestamps - Array of timestamps as milliseconds since Unix epoch
+     * @returns Object mapping feature names to Float64Array values
+     * @param {Float64Array} timestamps
+     * @returns {any}
+     */
+    generate(timestamps) {
+        const ptr0 = passArrayF64ToWasm0(timestamps, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.featuregenerator_generate(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+}
+if (Symbol.dispose) FeatureGenerator.prototype[Symbol.dispose] = FeatureGenerator.prototype.free;
+
 /**
  * Forecast result wrapper for JavaScript.
  *
@@ -2548,6 +2785,198 @@ export class JsBacktestResult {
 }
 if (Symbol.dispose) JsBacktestResult.prototype[Symbol.dispose] = JsBacktestResult.prototype.free;
 
+/**
+ * Bootstrap predictor for distribution-free prediction intervals.
+ *
+ * Resamples forecast residuals to simulate future error paths, producing
+ * per-step prediction intervals where uncertainty grows with horizon.
+ */
+export class JsBootstrapPredictor {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(JsBootstrapPredictor.prototype);
+        obj.__wbg_ptr = ptr;
+        JsBootstrapPredictorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsBootstrapPredictorFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jsbootstrappredictor_free(ptr, 0);
+    }
+    /**
+     * Use block bootstrap with the given block size.
+     *
+     * Preserves autocorrelation in residuals.
+     *
+     * @param size - Block size (0 falls back to IID)
+     * @param {number} size
+     * @returns {JsBootstrapPredictor}
+     */
+    blockSize(size) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.jsbootstrappredictor_blockSize(ptr, size);
+        return JsBootstrapPredictor.__wrap(ret);
+    }
+    /**
+     * Set the number of bootstrap replicates (default: 1000).
+     *
+     * @param n - Number of replicates (minimum 10)
+     * @param {number} n
+     * @returns {JsBootstrapPredictor}
+     */
+    nReplicates(n) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.jsbootstrappredictor_nReplicates(ptr, n);
+        return JsBootstrapPredictor.__wrap(ret);
+    }
+    /**
+     * Generate prediction intervals for new point forecasts.
+     *
+     * Returns a JsPredictionIntervals with lower and upper bounds.
+     *
+     * @param result - A fitted JsBootstrapResult from fit()
+     * @param pointForecasts - New point forecast values
+     * @param {JsBootstrapResult} result
+     * @param {Float64Array} point_forecasts
+     * @returns {JsPredictionIntervals}
+     */
+    predictIntervals(result, point_forecasts) {
+        _assertClass(result, JsBootstrapResult);
+        const ptr0 = passArrayF64ToWasm0(point_forecasts, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.jsbootstrappredictor_predictIntervals(this.__wbg_ptr, result.__wbg_ptr, ptr0, len0);
+        return JsPredictionIntervals.__wrap(ret);
+    }
+    /**
+     * Generate quantile forecasts at multiple quantile levels.
+     *
+     * Returns a serialized object with `quantiles` (levels) and `values` (matrix).
+     *
+     * @param result - A fitted JsBootstrapResult from fit()
+     * @param pointForecasts - New point forecast values
+     * @param levels - Quantile levels in (0, 1), e.g. [0.1, 0.25, 0.5, 0.75, 0.9]
+     * @param {JsBootstrapResult} result
+     * @param {Float64Array} point_forecasts
+     * @param {Float64Array} levels
+     * @returns {any}
+     */
+    predictQuantiles(result, point_forecasts, levels) {
+        _assertClass(result, JsBootstrapResult);
+        const ptr0 = passArrayF64ToWasm0(point_forecasts, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(levels, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.jsbootstrappredictor_predictQuantiles(this.__wbg_ptr, result.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Fit the predictor on historical forecasts and actuals.
+     *
+     * Computes residuals and stores them for resampling.
+     *
+     * @param forecasts - Historical point forecast values
+     * @param actuals - Corresponding actual observed values
+     * @param {Float64Array} forecasts
+     * @param {Float64Array} actuals
+     * @returns {JsBootstrapResult}
+     */
+    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.jsbootstrappredictor_fit(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return JsBootstrapResult.__wrap(ret[0]);
+    }
+    /**
+     * Create a bootstrap predictor with the given coverage level.
+     *
+     * @param coverage - Target coverage level in (0, 1), e.g. 0.90
+     * @param {number} coverage
+     */
+    constructor(coverage) {
+        const ret = wasm.jsbootstrappredictor_new(coverage);
+        this.__wbg_ptr = ret >>> 0;
+        JsBootstrapPredictorFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Set random seed for reproducibility.
+     *
+     * @param seed - Random seed value
+     * @param {bigint} seed
+     * @returns {JsBootstrapPredictor}
+     */
+    seed(seed) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.jsbootstrappredictor_seed(ptr, seed);
+        return JsBootstrapPredictor.__wrap(ret);
+    }
+}
+if (Symbol.dispose) JsBootstrapPredictor.prototype[Symbol.dispose] = JsBootstrapPredictor.prototype.free;
+
+/**
+ * Bootstrap result — stores residuals and configuration from fitting.
+ */
+export class JsBootstrapResult {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(JsBootstrapResult.prototype);
+        obj.__wbg_ptr = ptr;
+        JsBootstrapResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsBootstrapResultFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jsbootstrapresult_free(ptr, 0);
+    }
+    /**
+     * Get the number of replicates.
+     * @returns {number}
+     */
+    get nReplicates() {
+        const ret = wasm.jsbootstrapresult_nReplicates(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get the coverage level.
+     * @returns {number}
+     */
+    get coverage() {
+        const ret = wasm.jsbootstrapresult_coverage(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get the residuals used for resampling.
+     * @returns {Float64Array}
+     */
+    residuals() {
+        const ret = wasm.jsbootstrapresult_residuals(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) JsBootstrapResult.prototype[Symbol.dispose] = JsBootstrapResult.prototype.free;
+
 /**
  * Conformal predictor for distribution-free prediction intervals.
  *
@@ -2571,6 +3000,25 @@ export class JsConformalPredictor {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_jsconformalpredictor_free(ptr, 0);
     }
+    /**
+     * Fit per-horizon-step conformal intervals.
+     *
+     * Each horizon step gets its own interval half-width, allowing tighter
+     * intervals for near-horizon steps and wider for far-horizon steps.
+     *
+     * @param foldForecasts - Per-fold forecast arrays (array of arrays), each of length `horizon`
+     * @param foldActuals - Per-fold actual arrays (array of arrays), each of length `horizon`
+     * @param {any} fold_forecasts
+     * @param {any} fold_actuals
+     * @returns {JsPerStepConformalResult}
+     */
+    fitPerStep(fold_forecasts, fold_actuals) {
+        const ret = wasm.jsconformalpredictor_fitPerStep(this.__wbg_ptr, fold_forecasts, fold_actuals);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return JsPerStepConformalResult.__wrap(ret[0]);
+    }
     /**
      * Create a conformal predictor with the Jackknife+ method.
      *
@@ -2598,6 +3046,31 @@ export class JsConformalPredictor {
         const ret = wasm.jsconformalpredictor_predictIntervals(this.__wbg_ptr, result.__wbg_ptr, ptr0, len0);
         return JsPredictionIntervals.__wrap(ret);
     }
+    /**
+     * Generate quantile forecasts at multiple quantile levels.
+     *
+     * Returns a serialized object with `quantiles` (levels) and `values` (matrix).
+     *
+     * @param result - A fitted JsConformalResult from calibrate()
+     * @param pointForecasts - New point forecast values
+     * @param levels - Quantile levels in (0, 1), e.g. [0.1, 0.5, 0.9]
+     * @param {JsConformalResult} result
+     * @param {Float64Array} point_forecasts
+     * @param {Float64Array} levels
+     * @returns {any}
+     */
+    predictQuantiles(result, point_forecasts, levels) {
+        _assertClass(result, JsConformalResult);
+        const ptr0 = passArrayF64ToWasm0(point_forecasts, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(levels, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.jsconformalpredictor_predictQuantiles(this.__wbg_ptr, result.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Create a split conformal predictor.
      *
@@ -2690,7 +3163,7 @@ export class JsConformalResult {
      * @returns {number}
      */
     get coverage() {
-        const ret = wasm.jsconformalresult_coverage(this.__wbg_ptr);
+        const ret = wasm.jsbootstrapresult_coverage(this.__wbg_ptr);
         return ret;
     }
 }
@@ -2953,7 +3426,7 @@ export class JsModelDiagnostics {
      * @returns {number}
      */
     get heteroscedasticityPvalue() {
-        const ret = wasm.jsconformalresult_coverage(this.__wbg_ptr);
+        const ret = wasm.jsbootstrapresult_coverage(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -3090,6 +3563,92 @@ export class JsNormalResult {
 }
 if (Symbol.dispose) JsNormalResult.prototype[Symbol.dispose] = JsNormalResult.prototype.free;
 
+/**
+ * Per-step conformal result — each horizon step has its own interval half-width.
+ *
+ * Step h=1 gets a tighter interval than step h=12 when forecast error grows
+ * with horizon.
+ */
+export class JsPerStepConformalResult {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(JsPerStepConformalResult.prototype);
+        obj.__wbg_ptr = ptr;
+        JsPerStepConformalResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsPerStepConformalResultFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jsperstepconformalresult_free(ptr, 0);
+    }
+    /**
+     * Get the per-step interval half-widths.
+     * @returns {Float64Array}
+     */
+    get halfWidths() {
+        const ret = wasm.jsperstepconformalresult_halfWidths(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Apply per-step intervals to a point forecast.
+     *
+     * Returns a JsPredictionIntervals with per-step lower and upper bounds.
+     *
+     * @param pointForecasts - Point forecast values (length must match horizon)
+     * @param {Float64Array} point_forecasts
+     * @returns {JsPredictionIntervals}
+     */
+    predictIntervals(point_forecasts) {
+        const ptr0 = passArrayF64ToWasm0(point_forecasts, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.jsperstepconformalresult_predictIntervals(this.__wbg_ptr, ptr0, len0);
+        return JsPredictionIntervals.__wrap(ret);
+    }
+    /**
+     * Get the number of horizon steps.
+     * @returns {number}
+     */
+    get horizon() {
+        const ret = wasm.jsperstepconformalresult_horizon(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Apply per-step intervals and return lower/upper as a plain object.
+     *
+     * Returns a serialized object with `lower` and `upper` arrays.
+     *
+     * @param pointForecasts - Point forecast values (length must match horizon)
+     * @param {Float64Array} point_forecasts
+     * @returns {any}
+     */
+    predict(point_forecasts) {
+        const ptr0 = passArrayF64ToWasm0(point_forecasts, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.jsperstepconformalresult_predict(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Get the coverage level.
+     * @returns {number}
+     */
+    get coverage() {
+        const ret = wasm.jsconformalresult_quantileValue(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) JsPerStepConformalResult.prototype[Symbol.dispose] = JsPerStepConformalResult.prototype.free;
+
 /**
  * Point forecasts — a sequence of predicted values.
  *
@@ -3366,7 +3925,7 @@ if (Symbol.dispose) JsTrainedModel.prototype[Symbol.dispose] = JsTrainedModel.pr
 /**
  * Kalman filter forecaster for state-space models.
  *
- * Supports local level and local linear trend models out of the box.
+ * Supports local level, local linear trend, and custom state-space models.
  */
 export class KalmanForecaster {
     static __wrap(ptr) {
@@ -3399,6 +3958,22 @@ export class KalmanForecaster {
         const ret = wasm.kalmanforecaster_localLevel(obs_noise, state_noise);
         return KalmanForecaster.__wrap(ret);
     }
+    /**
+     * Compute the log-likelihood of the observations under the model.
+     *
+     * @param series - TimeSeries to evaluate
+     * @returns Log-likelihood value
+     * @param {TimeSeries} series
+     * @returns {number}
+     */
+    logLikelihood(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.kalmanforecaster_logLikelihood(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
     /**
      * Create a local linear trend model.
      *
@@ -3460,9 +4035,52 @@ export class KalmanForecaster {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Get the number of observation dimensions.
+     * @returns {number}
+     */
+    get nObs() {
+        const ret = wasm.kalmanforecaster_nObs(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Create a custom state-space model from matrices.
+     *
+     * @param transition - State transition matrix F (n_state x n_state), flat row-major
+     * @param observation - Observation matrix H (n_obs x n_state), flat row-major
+     * @param processNoise - Process noise covariance Q (n_state x n_state), flat row-major
+     * @param observationNoise - Observation noise covariance R (n_obs x n_obs), flat row-major
+     * @param nState - Number of state dimensions
+     * @param nObs - Number of observation dimensions
+     * @param {Float64Array} transition
+     * @param {Float64Array} observation
+     * @param {Float64Array} process_noise
+     * @param {Float64Array} observation_noise
+     * @param {number} n_state
+     * @param {number} n_obs
+     * @returns {KalmanForecaster}
+     */
+    static custom(transition, observation, process_noise, observation_noise, n_state, n_obs) {
+        const ptr0 = passArrayF64ToWasm0(transition, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(observation, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArrayF64ToWasm0(process_noise, wasm.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passArrayF64ToWasm0(observation_noise, wasm.__wbindgen_malloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.kalmanforecaster_custom(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, n_state, n_obs);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return KalmanForecaster.__wrap(ret[0]);
+    }
     /**
      * Apply the Kalman smoother (RTS smoother) and return smoothed observations.
      *
+     * Uses the same state-space model that was configured (local level, local linear
+     * trend, or custom). Fits the filter first, then runs the RTS smoother.
+     *
      * @param series - TimeSeries to smooth
      * @returns Array of smoothed observation values
      * @param {TimeSeries} series
@@ -3478,6 +4096,14 @@ export class KalmanForecaster {
         wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
         return v1;
     }
+    /**
+     * Get the number of state dimensions.
+     * @returns {number}
+     */
+    get nState() {
+        const ret = wasm.kalmanforecaster_nState(this.__wbg_ptr);
+        return ret >>> 0;
+    }
     /**
      * Predict future values.
      *
@@ -4706,6 +5332,26 @@ export class TimeSeries {
         }
         return TimeSeries.__wrap(ret[0]);
     }
+    /**
+     * Generate future timestamps by inferring the series frequency.
+     *
+     * Detects whether the data is daily, weekly, monthly, quarterly, or
+     * yearly from the existing timestamps and extrapolates forward.
+     *
+     * @param horizon - Number of future timestamps to generate
+     * @returns Array of timestamps as milliseconds since Unix epoch
+     * @param {number} horizon
+     * @returns {Float64Array}
+     */
+    futureTimestamps(horizon) {
+        const ret = wasm.timeseries_futureTimestamps(this.__wbg_ptr, horizon);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
     /**
      * Check if the series has missing values (NaN).
      * @returns {boolean}
@@ -5201,6 +5847,31 @@ export function durbinWatson(residuals) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Generate future timestamps starting after a given last timestamp.
+ *
+ * @param lastTimestampMs - Last known timestamp as milliseconds since epoch
+ * @param frequency - Polars-style frequency string: "1d", "1w", "1mo",
+ *   "1q", "1y", "1h", "30m", "30s", etc.
+ * @param horizon - Number of future timestamps to generate
+ * @returns Float64Array of timestamps as milliseconds since epoch
+ * @param {number} last_timestamp_ms
+ * @param {string} frequency
+ * @param {number} horizon
+ * @returns {Float64Array}
+ */
+export function generateFutureTimestamps(last_timestamp_ms, frequency, horizon) {
+    const ptr0 = passStringToWasm0(frequency, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.generateFutureTimestamps(last_timestamp_ms, ptr0, len0, horizon);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Initialize the WASM module.
  *
@@ -5504,6 +6175,18 @@ function __wbg_get_imports() {
         getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
         getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
     };
+    imports.wbg.__wbg___wbindgen_boolean_get_dea25b33882b895b = function(arg0) {
+        const v = arg0;
+        const ret = typeof(v) === 'boolean' ? v : undefined;
+        return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+    };
+    imports.wbg.__wbg___wbindgen_debug_string_adfb662ae34724b6 = function(arg0, arg1) {
+        const ret = debugString(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;
@@ -5521,6 +6204,16 @@ function __wbg_get_imports() {
         const ret = arg0 === undefined;
         return ret;
     };
+    imports.wbg.__wbg___wbindgen_jsval_loose_eq_766057600fdd1b0d = function(arg0, arg1) {
+        const ret = arg0 == arg1;
+        return ret;
+    };
+    imports.wbg.__wbg___wbindgen_number_get_9619185a74197f95 = function(arg0, arg1) {
+        const obj = arg1;
+        const ret = typeof(obj) === 'number' ? obj : undefined;
+        getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+    };
     imports.wbg.__wbg___wbindgen_string_get_a2a31e16edf96e42 = function(arg0, arg1) {
         const obj = arg1;
         const ret = typeof(obj) === 'string' ? obj : undefined;
@@ -5544,6 +6237,10 @@ function __wbg_get_imports() {
         const ret = arg0.crypto;
         return ret;
     };
+    imports.wbg.__wbg_done_62ea16af4ce34b24 = function(arg0) {
+        const ret = arg0.done;
+        return ret;
+    };
     imports.wbg.__wbg_getRandomValues_b8f5dbd5f3995a9e = function() { return handleError(function (arg0, arg1) {
         arg0.getRandomValues(arg1);
     }, arguments) };
@@ -5555,6 +6252,20 @@ function __wbg_get_imports() {
         const ret = arg0[arg1 >>> 0];
         return ret;
     };
+    imports.wbg.__wbg_get_af9dab7e9603ea93 = function() { return handleError(function (arg0, arg1) {
+        const ret = Reflect.get(arg0, arg1);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_instanceof_ArrayBuffer_f3320d2419cd0355 = function(arg0) {
+        let result;
+        try {
+            result = arg0 instanceof ArrayBuffer;
+        } catch (_) {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
     imports.wbg.__wbg_instanceof_Float64Array_9fefccd7bfa2fefe = function(arg0) {
         let result;
         try {
@@ -5565,6 +6276,24 @@ function __wbg_get_imports() {
         const ret = result;
         return ret;
     };
+    imports.wbg.__wbg_instanceof_Uint8Array_da54ccc9d3e09434 = function(arg0) {
+        let result;
+        try {
+            result = arg0 instanceof Uint8Array;
+        } catch (_) {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
+    imports.wbg.__wbg_isArray_51fd9e6422c0a395 = function(arg0) {
+        const ret = Array.isArray(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_iterator_27b7c8b35ab3e86b = function() {
+        const ret = Symbol.iterator;
+        return ret;
+    };
     imports.wbg.__wbg_length_22ac23eaec9d8053 = function(arg0) {
         const ret = arg0.length;
         return ret;
@@ -5593,6 +6322,14 @@ function __wbg_get_imports() {
         const ret = new Array();
         return ret;
     };
+    imports.wbg.__wbg_new_6421f6084cc5bc5a = function(arg0) {
+        const ret = new Uint8Array(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_new_b546ae120718850e = function() {
+        const ret = new Map();
+        return ret;
+    };
     imports.wbg.__wbg_new_no_args_cb138f77cf6151ee = function(arg0, arg1) {
         const ret = new Function(getStringFromWasm0(arg0, arg1));
         return ret;
@@ -5609,6 +6346,14 @@ function __wbg_get_imports() {
         const ret = new Uint8Array(arg0 >>> 0);
         return ret;
     };
+    imports.wbg.__wbg_next_138a17bbf04e926c = function(arg0) {
+        const ret = arg0.next;
+        return ret;
+    };
+    imports.wbg.__wbg_next_3cfe5c0fe2a4cc53 = function() { return handleError(function (arg0) {
+        const ret = arg0.next();
+        return ret;
+    }, arguments) };
     imports.wbg.__wbg_node_905d3e251edff8a2 = function(arg0) {
         const ret = arg0.node;
         return ret;
@@ -5639,6 +6384,10 @@ function __wbg_get_imports() {
     imports.wbg.__wbg_set_7df433eea03a5c14 = function(arg0, arg1, arg2) {
         arg0[arg1 >>> 0] = arg2;
     };
+    imports.wbg.__wbg_set_efaaf145b9377369 = function(arg0, arg1, arg2) {
+        const ret = arg0.set(arg1, arg2);
+        return ret;
+    };
     imports.wbg.__wbg_static_accessor_GLOBAL_769e6b65d6557335 = function() {
         const ret = typeof global === 'undefined' ? null : global;
         return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
@@ -5659,6 +6408,10 @@ function __wbg_get_imports() {
         const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
         return ret;
     };
+    imports.wbg.__wbg_value_57b7b035e117f7ee = function(arg0) {
+        const ret = arg0.value;
+        return ret;
+    };
     imports.wbg.__wbg_versions_c01dfd4722a88165 = function(arg0) {
         const ret = arg0.versions;
         return ret;