tsbootstrap 0.3.0__tar.gz → 0.4.0__tar.gz

{tsbootstrap-0.3.0/src/tsbootstrap.egg-info → tsbootstrap-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tsbootstrap
-Version: 0.3.0
+Version: 0.4.0
 Summary: A Python package to generate bootstrapped time series
 Author-email: Sankalp Gilda <sankalp.gilda@gmail.com>
 Maintainer-email: Sankalp Gilda <sankalp.gilda@gmail.com>, Franz Kiraly <franz.kiraly@sktime.net>, Benedikt Heidrich <benedikt.heidrich@sktime.net>
@@ -89,6 +89,7 @@ Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-xdist[psutil]; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: pytest-mock; extra == "dev"
+Requires-Dist: pytest-timeout; extra == "dev"
 Requires-Dist: nbmake; extra == "dev"
 Requires-Dist: sktime; extra == "dev"
 Requires-Dist: polars; extra == "dev"
@@ -232,6 +233,15 @@ from tsbootstrap import AR, forecast_intervals
 lower, upper, median = forecast_intervals(x, model=AR(order=2), horizon=12, alpha=0.1)
 ```
 
+For a confidence interval on a statistic of one series, `conf_int` runs the bootstrap
+and reads the interval in one call:
+
+```python
+from tsbootstrap import IID, conf_int
+
+lower, upper, point = conf_int(x, "mean", method=IID(), kind="bca", alpha=0.1)
+```
+
 The conformal pieces (`EnbPIEnsemble` and the calibrators) need the `uq` extra
 (scikit-learn). The interactive
 [tutorial gallery](https://tsbootstrap.readthedocs.io/en/latest/tutorials/index.html)
@@ -278,7 +288,7 @@ the `models` extra is missing.
 
 ## ⚡ Performance
 
-![tsbootstrap 0.3.0: speedup over arch and peak-memory reduction](benchmarks/launch_speed_memory.png)
+![tsbootstrap: speedup over arch and peak-memory reduction](benchmarks/launch_speed_memory.png)
 
 *Left: speedup of the compiled reduce path over the arch library on the four overlapping methods. Right: peak memory before and after on the two headline reduce workloads (baseline = materialize every path, then reduce). Regenerate with `python benchmarks/plot_launch.py`.*
 
@@ -319,7 +329,7 @@ Package layout:
 | Infrastructure | `rng.py`, `validation.py`, `dispatch.py`, `metadata.py` | deterministic RNG contract, input coercion (incl. the narwhals DataFrame boundary), spec to executor dispatch, method metadata |
 | Block methods | `block/` | vectorized index kernels, true Politis-Romano stationary, energy-normalized tapering, PWSD block length, OOB primitives |
 | Model methods | `model/`, `engines/` | model fitting, stability guards, and recursive AR/ARMA/VAR simulation |
-| Uncertainty quantification | `uq/` | EnbPI prediction intervals, the static / sliding-window / ACI / NexCP calibrators, and AR forecast intervals |
+| Uncertainty quantification | `uq/` | classical confidence intervals (percentile, basic, studentized, BCa) via `conf_int`, EnbPI prediction intervals, the static / sliding-window / ACI / NexCP calibrators, and AR forecast intervals |
 | Ecosystem | `adapters/` | skbase / sktime estimator classes over the functional core |
 
 
@@ -327,14 +337,13 @@ Package layout:
 
 The full, living roadmap is [issue #181](https://github.com/astrogilda/tsbootstrap/issues/181). Highlights:
 
-Near term (v0.2.x):
-- Out-of-sample forecast intervals for ARIMA and VAR (v0.2.0 ships AR-only).
-- The tutorial gallery and getting-started notebook ([#46](https://github.com/astrogilda/tsbootstrap/issues/46)).
+Near term:
+- Out-of-sample forecast intervals for ARIMA and VAR (currently AR-only).
 - Python 3.14, once statsmodels publishes a 3.14 wheel ([#202](https://github.com/astrogilda/tsbootstrap/issues/202)).
 
 Candidate methods (good first issues):
 - Generalized block ([#104](https://github.com/astrogilda/tsbootstrap/issues/104)), local block ([#105](https://github.com/astrogilda/tsbootstrap/issues/105)), and frequency-domain ([#107](https://github.com/astrogilda/tsbootstrap/issues/107)) bootstraps.
-- Wild and dependent-wild bootstraps, and a GARCH / volatility residual bootstrap.
+- A GARCH / volatility residual bootstrap, and the smooth-kernel dependent-wild bootstrap.
 
 Distributed execution (`Dask` / `Spark` / `Ray`), an async layer, and a string-keyed
 factory were considered and deliberately left out. The library is a CPU-bound,
@@ -476,6 +485,22 @@ explosive paths.
 `SieveAR` selects an autoregressive order on the original series, then runs the AR recursion;
 suited to data with autoregressive structure.
 
+### Innovation resamplers
+The `innovation` argument on `ResidualBootstrap` and `SieveAR` controls how the centered
+residuals are resampled. It defaults to `IID` (uniform resampling); two wild resamplers relax
+the exchangeability that assumes.
+
+- **Wild** (`Wild(distribution=...)`): multiplies each residual in place by a mean-zero,
+  unit-variance draw (`e*_t = v_t * e_hat_t`), keeping its time position and magnitude, so it
+  stays valid under conditional heteroskedasticity (Wu 1986; Liu 1988; Rademacher default per
+  Davidson-Flachaire 2008).
+- **Block-wild** (`BlockWild(block_length=...)`): holds one multiplier constant across each
+  block of residuals, so serial dependence left by a misspecified mean survives the resampling
+  (piecewise-constant dependent wild bootstrap, Shao 2010).
+
+Both require the host model's `burn_in=0` and `initial="fixed"` defaults so the multipliers
+align one-to-one with the residuals.
+
 ### Deferred to a later release
 Markov resampling, the distribution bootstrap, GARCH/volatility models, and
 frequency-domain / seasonal block methods are planned for a future version. The

{tsbootstrap-0.3.0 → tsbootstrap-0.4.0}/README.md

@@ -116,6 +116,15 @@ from tsbootstrap import AR, forecast_intervals
 lower, upper, median = forecast_intervals(x, model=AR(order=2), horizon=12, alpha=0.1)
 ```
 
+For a confidence interval on a statistic of one series, `conf_int` runs the bootstrap
+and reads the interval in one call:
+
+```python
+from tsbootstrap import IID, conf_int
+
+lower, upper, point = conf_int(x, "mean", method=IID(), kind="bca", alpha=0.1)
+```
+
 The conformal pieces (`EnbPIEnsemble` and the calibrators) need the `uq` extra
 (scikit-learn). The interactive
 [tutorial gallery](https://tsbootstrap.readthedocs.io/en/latest/tutorials/index.html)
@@ -162,7 +171,7 @@ the `models` extra is missing.
 
 ## ⚡ Performance
 
-![tsbootstrap 0.3.0: speedup over arch and peak-memory reduction](benchmarks/launch_speed_memory.png)
+![tsbootstrap: speedup over arch and peak-memory reduction](benchmarks/launch_speed_memory.png)
 
 *Left: speedup of the compiled reduce path over the arch library on the four overlapping methods. Right: peak memory before and after on the two headline reduce workloads (baseline = materialize every path, then reduce). Regenerate with `python benchmarks/plot_launch.py`.*
 
@@ -203,7 +212,7 @@ Package layout:
 | Infrastructure | `rng.py`, `validation.py`, `dispatch.py`, `metadata.py` | deterministic RNG contract, input coercion (incl. the narwhals DataFrame boundary), spec to executor dispatch, method metadata |
 | Block methods | `block/` | vectorized index kernels, true Politis-Romano stationary, energy-normalized tapering, PWSD block length, OOB primitives |
 | Model methods | `model/`, `engines/` | model fitting, stability guards, and recursive AR/ARMA/VAR simulation |
-| Uncertainty quantification | `uq/` | EnbPI prediction intervals, the static / sliding-window / ACI / NexCP calibrators, and AR forecast intervals |
+| Uncertainty quantification | `uq/` | classical confidence intervals (percentile, basic, studentized, BCa) via `conf_int`, EnbPI prediction intervals, the static / sliding-window / ACI / NexCP calibrators, and AR forecast intervals |
 | Ecosystem | `adapters/` | skbase / sktime estimator classes over the functional core |
 
 
@@ -211,14 +220,13 @@ Package layout:
 
 The full, living roadmap is [issue #181](https://github.com/astrogilda/tsbootstrap/issues/181). Highlights:
 
-Near term (v0.2.x):
-- Out-of-sample forecast intervals for ARIMA and VAR (v0.2.0 ships AR-only).
-- The tutorial gallery and getting-started notebook ([#46](https://github.com/astrogilda/tsbootstrap/issues/46)).
+Near term:
+- Out-of-sample forecast intervals for ARIMA and VAR (currently AR-only).
 - Python 3.14, once statsmodels publishes a 3.14 wheel ([#202](https://github.com/astrogilda/tsbootstrap/issues/202)).
 
 Candidate methods (good first issues):
 - Generalized block ([#104](https://github.com/astrogilda/tsbootstrap/issues/104)), local block ([#105](https://github.com/astrogilda/tsbootstrap/issues/105)), and frequency-domain ([#107](https://github.com/astrogilda/tsbootstrap/issues/107)) bootstraps.
-- Wild and dependent-wild bootstraps, and a GARCH / volatility residual bootstrap.
+- A GARCH / volatility residual bootstrap, and the smooth-kernel dependent-wild bootstrap.
 
 Distributed execution (`Dask` / `Spark` / `Ray`), an async layer, and a string-keyed
 factory were considered and deliberately left out. The library is a CPU-bound,
@@ -360,6 +368,22 @@ explosive paths.
 `SieveAR` selects an autoregressive order on the original series, then runs the AR recursion;
 suited to data with autoregressive structure.
 
+### Innovation resamplers
+The `innovation` argument on `ResidualBootstrap` and `SieveAR` controls how the centered
+residuals are resampled. It defaults to `IID` (uniform resampling); two wild resamplers relax
+the exchangeability that assumes.
+
+- **Wild** (`Wild(distribution=...)`): multiplies each residual in place by a mean-zero,
+  unit-variance draw (`e*_t = v_t * e_hat_t`), keeping its time position and magnitude, so it
+  stays valid under conditional heteroskedasticity (Wu 1986; Liu 1988; Rademacher default per
+  Davidson-Flachaire 2008).
+- **Block-wild** (`BlockWild(block_length=...)`): holds one multiplier constant across each
+  block of residuals, so serial dependence left by a misspecified mean survives the resampling
+  (piecewise-constant dependent wild bootstrap, Shao 2010).
+
+Both require the host model's `burn_in=0` and `initial="fixed"` defaults so the multipliers
+align one-to-one with the residuals.
+
 ### Deferred to a later release
 Markov resampling, the distribution bootstrap, GARCH/volatility models, and
 frequency-domain / seasonal block methods are planned for a future version. The

{tsbootstrap-0.3.0 → tsbootstrap-0.4.0}/pyproject.toml

@@ -7,7 +7,7 @@ where = ["src"]
 
 [project]
 name = "tsbootstrap"
-version = "0.3.0"
+version = "0.4.0"
 description = "A Python package to generate bootstrapped time series"
 maintainers = [
     { name = "Sankalp Gilda", email = "sankalp.gilda@gmail.com" },
@@ -114,6 +114,7 @@ dev = [
     "pytest-xdist[psutil]",
     "pytest-cov",
     "pytest-mock",
+    "pytest-timeout",  # hang guard for the mutation ratchet (kills a non-terminating mutant)
     "nbmake",  # execute the tutorial notebooks as a CI test gate (issue #46)
     "sktime",  # validates the skbase/sktime adapter discovery + check_estimator
     "polars",  # exercises the narwhals DataFrame boundary with a second backend
@@ -382,15 +383,80 @@ reportUnnecessaryIsInstance = false
 reportConstantRedefinition = false
 
 [tool.mutmut]
+# STATUS (2026-06-24): in-process mutmut is NOT a blocking CI gate. Root cause, proven this session
+# and reproduced on a clean 16-core box (not CPU contention): mutmut 3.x runs pytest IN-PROCESS via
+# repeated pytest.main(), and numba's @njit(parallel=True) kernels (engines/var.py + block/_compiled.py)
+# DEADLOCK in LLVM finalize_object/parse_assembly when that compile recurs inside one interpreter, so
+# the stats pass times out and the run aborts before any mutant is tested. NUMBA_DISABLE_JIT=1 avoids
+# the deadlock but runs the kernels interpreted, which then blows the per-test timeout. The locked path
+# (cross-family debate 2026-06-24) is a Layer-2 subprocess-per-mutant runner: keep mutmut ONLY for AST
+# mutant generation, execute each mutant in an isolated subprocess so LLVM never churns in one process,
+# run nightly/non-blocking, gate on the new-survivor diff vs tests/mutation_equivalents.md. The config
+# below + tools/mutmut_sitecustomize remain usable for a one-off LOCAL inspection on an idle box, but
+# the durable value already landed is the killing tests + the equivalents registry, not this in-process
+# runner. See ~/.claude/skills/mutation-ratchet and the debate transcript for the subprocess design.
+#
 # Mutation-score ratchet over the engine + model core (the established baseline scope).
-# Run with:  NUMBA_DISABLE_JIT=1 HYPOTHESIS_PROFILE=mutmut mutmut run
-#   - NUMBA_DISABLE_JIT=1: the @njit VAR kernel is otherwise cache-masked, so source mutations to
-#     it never execute; interpreted execution lets them take effect (compiled correctness is
-#     covered separately by test_var_numba_and_numpy_backends_agree in the normal JIT-on suite).
+# Run with:  PYTHONPATH=tools/mutmut_sitecustomize HYPOTHESIS_PROFILE=mutmut uv run mutmut run
+#   - PYTHONPATH=tools/mutmut_sitecustomize (REQUIRED): mutate_only_covered_lines below makes mutmut
+#     run an in-process coverage pass and then UNLOAD every module imported during it
+#     (mutmut.code_coverage._unload_modules_not_in) so the source reloads fresh per mutant. That
+#     unload is fatal to C-extension libraries that cannot re-import in the same process: numpy
+#     ("cannot load module more than once per process" from _multiarray_umath) and numba
+#     ("duplicate registration for PolynomialType"). The sitecustomize on this path patches the
+#     unload to keep numpy/numba/scipy/statsmodels/... resident while still reloading tsbootstrap.
+#     It is gated on HYPOTHESIS_PROFILE=mutmut, so it is inert outside the ratchet. This is an
+#     upstream mutmut-3.x interaction (2.x did not copy + reload this way), not specific to this repo.
 #   - HYPOTHESIS_PROFILE=mutmut: derandomized profile so the property baseline is reproducible.
+#     It also activates the mutmut-only test fixture in tests/conftest.py:
+#       * an ephemeral per-session NUMBA_CACHE_DIR so the @njit VAR kernel recompiles its mutated
+#         source fresh on every mutant (JIT stays ON, at native speed). This replaces the old
+#         NUMBA_DISABLE_JIT=1 workaround, whose interpreted execution cost ~28 minutes per run;
+#         the cache, not the JIT, was what masked source mutations to the compiled kernel.
+#     There is deliberately NO solver-maxiter clamp (see the long note in tests/conftest.py): it
+#     changed the numerics on the unmutated code and broke the clean-baseline ARIMA golden, which
+#     mutmut requires to pass. Spinning mutants are bounded by --timeout below instead.
+# RUN ON AN IDLE / DEDICATED MACHINE. mutmut 3.x runs its stats and per-mutant suites in-process
+# (pytest.main) with --timeout below; under heavy CPU contention (e.g. other multi-hour jobs) the
+# in-process stats pass can exceed the per-test timeout and abort the whole run before any mutant is
+# tested. The full run is reliable on an idle box or a dedicated remote runner. Accepted equivalent
+# survivors are catalogued in tests/mutation_equivalents.md (the ratchet baseline).
 # source_paths is the whole importable tree (subdirs alone yield an incomplete copied package);
 # only_mutate then restricts mutation to the engines+model scope.
 source_paths = ["src/"]
 only_mutate = ["src/tsbootstrap/engines/*", "src/tsbootstrap/model/*"]
+
+# MUST stay false for the subprocess gate. true makes mutmut run an IN-PROCESS coverage pass (the
+# whole suite under coverage.py) before generating, which hits the same numba parallel-JIT LLVM
+# deadlock as the in-process executor -> empty coverage -> ZERO mutants generated. false skips that
+# pass entirely: generation is pure libcst (no suite run, no deadlock) and mutates every in-scope
+# line. The subprocess gate runs all generated mutants anyway, so covered-lines filtering is not
+# needed; uncovered-line survivors are correct signal (a real "no test exercises this line").
+mutate_only_covered_lines = false
+
+# Systemic non-behavioral equivalents, suppressed at the source-pattern level (~164 of these were
+# hand-classified as equivalent in the v0.2.0 mutation work). In mutmut 3.6 do_not_mutate_patterns
+# is a list of PYTHON REGEXES, each re.search()-matched against every raw source LINE; a matching
+# line has its expression nodes excluded from mutation (it is line-granular, NOT AST-node text and
+# NOT a glob). Patterns are therefore anchored to their own kwarg/continuation lines so they do not
+# over-suppress mutation of a real algorithmic expression that happens to share the line.
+#   - code=Codes.X / context={...}: error-construction kwargs (enum tag + diagnostic dict). Mutating
+#     these never changes behavior, only the exception payload, which no test asserts on by value.
+#   - dtype=np.<type>: the dtype-default class (e.g. dtype=np.float64 -> None). Inputs are already
+#     float64/int by construction, so dropping the explicit dtype is behavior-preserving.
+#   - def __<dunder>__ and logger/logging/log.<level>(...) call args: covered for fleet generality
+#     (no occurrences in the current engines+model scope, so inert here, but harmless to keep).
+do_not_mutate_patterns = [
+    "^\\s*code=Codes\\.",
+    "^\\s*context=",
+    "dtype=np\\.",
+    "^\\s*def __[a-zA-Z]+__\\s*\\(",
+    "(?:logger|logging|log)\\.(?:debug|info|warning|error|critical|exception)\\(",
+]
+
 pytest_add_cli_args_test_selection = ["-m", "not slow", "tests/"]
-pytest_add_cli_args = ["-o", "addopts="]
+# -o addopts= drops the project's default addopts (coverage, xdist, durations). The per-test
+# timeout is mutmut's hang guard: a mutant that sends an iterative solver or a recurrence into a
+# non-terminating loop is killed at 60s (thread method, so it interrupts even C-extension calls)
+# instead of stalling the whole run.
+pytest_add_cli_args = ["-o", "addopts=", "--timeout=60", "--timeout-method=thread"]

{tsbootstrap-0.3.0 → tsbootstrap-0.4.0}/src/tsbootstrap/__init__.py

@@ -35,12 +35,14 @@ from tsbootstrap.errors import (
     TSBootstrapError,
     TSBootstrapWarning,
 )
+from tsbootstrap.metadata import MethodMetadata, metadata_for
 from tsbootstrap.methods import (
     AR,
     ARIMA,
     IID,
     VAR,
     BaseMethodSpec,
+    BlockWild,
     CircularBlock,
     MethodSpec,
     MovingBlock,
@@ -49,6 +51,7 @@ from tsbootstrap.methods import (
     SieveAR,
     StationaryBlock,
     TaperedBlock,
+    Wild,
 )
 from tsbootstrap.results import (
     BootstrapResult,
@@ -64,12 +67,21 @@ from tsbootstrap.results import (
 from tsbootstrap.uq import (
     EnbPIEnsemble,
     aci_halfwidths,
+    basic_interval,
+    bca_interval,
+    block_jackknife_se,
+    conf_int,
+    conf_int_panel,
     enbpi_intervals,
     fit_predict_oob,
     forecast_intervals,
+    jackknife_acceleration,
+    jackknife_statistics,
     nexcp_quantile,
+    percentile_interval,
     sliding_window_halfwidths,
     static_halfwidths,
+    studentized_interval,
 )
 
 try:
@@ -84,9 +96,11 @@ __all__ = [
     "bootstrap_iter",
     "bootstrap_reduce",
     "bootstrap_reduce_panel",
-    # diagnostics
+    # diagnostics and method introspection
     "diagnose",
     "Diagnosis",
+    "metadata_for",
+    "MethodMetadata",
     # method specifications
     "IID",
     "MovingBlock",
@@ -94,6 +108,8 @@ __all__ = [
     "StationaryBlock",
     "NonOverlappingBlock",
     "TaperedBlock",
+    "Wild",
+    "BlockWild",
     "AR",
     "ARIMA",
     "VAR",
@@ -115,6 +131,15 @@ __all__ = [
     "nexcp_quantile",
     "static_halfwidths",
     "sliding_window_halfwidths",
+    "percentile_interval",
+    "basic_interval",
+    "jackknife_statistics",
+    "block_jackknife_se",
+    "studentized_interval",
+    "jackknife_acceleration",
+    "bca_interval",
+    "conf_int",
+    "conf_int_panel",
     # errors and warnings
     "Codes",
     "TSBootstrapError",

{tsbootstrap-0.3.0 → tsbootstrap-0.4.0}/src/tsbootstrap/adapters/estimators.py

@@ -22,7 +22,9 @@ from tsbootstrap.methods import (
     IID,
     VAR,
     BlockLength,
+    BlockWild,
     CircularBlock,
+    Innovation,
     MethodSpec,
     MovingBlock,
     NonOverlappingBlock,
@@ -30,6 +32,7 @@ from tsbootstrap.methods import (
     SieveAR,
     StationaryBlock,
     TaperedBlock,
+    Wild,
 )
 
 _Sample = NDArray[np.floating]
@@ -251,17 +254,30 @@ class ARResidualBootstrap(BaseTimeSeriesBootstrap):
     }
 
     def __init__(
-        self, order: int = 1, n_bootstraps: int = 999, random_state: int | None = None
+        self,
+        order: int = 1,
+        innovation: Innovation | None = None,
+        n_bootstraps: int = 999,
+        random_state: int | None = None,
     ) -> None:
         self.order = order
+        self.innovation = innovation
         super().__init__(n_bootstraps=n_bootstraps, random_state=random_state)
 
     def _make_spec(self) -> MethodSpec:
-        return ResidualBootstrap(model=AR(order=self.order))
+        return ResidualBootstrap(
+            model=AR(order=self.order),
+            innovation=self.innovation if self.innovation is not None else IID(),
+        )
 
     @classmethod
     def get_test_params(cls) -> list[dict[str, Any]]:
-        return [{"order": 1, "n_bootstraps": 10}, {"order": 2, "n_bootstraps": 5}]
+        return [
+            {"order": 1, "n_bootstraps": 10},
+            {"order": 2, "n_bootstraps": 5},
+            {"order": 1, "innovation": Wild(), "n_bootstraps": 5},
+            {"order": 1, "innovation": BlockWild(block_length=5), "n_bootstraps": 5},
+        ]
 
 
 class ARIMAResidualBootstrap(BaseTimeSeriesBootstrap):
@@ -276,14 +292,19 @@ class ARIMAResidualBootstrap(BaseTimeSeriesBootstrap):
     def __init__(
         self,
         order: tuple[int, int, int] = (1, 1, 1),
+        innovation: Innovation | None = None,
         n_bootstraps: int = 999,
         random_state: int | None = None,
     ) -> None:
         self.order = order
+        self.innovation = innovation
         super().__init__(n_bootstraps=n_bootstraps, random_state=random_state)
 
     def _make_spec(self) -> MethodSpec:
-        return ResidualBootstrap(model=ARIMA(order=self.order))
+        return ResidualBootstrap(
+            model=ARIMA(order=self.order),
+            innovation=self.innovation if self.innovation is not None else IID(),
+        )
 
     @classmethod
     def get_test_params(cls) -> list[dict[str, Any]]:
@@ -300,13 +321,21 @@ class VARResidualBootstrap(BaseTimeSeriesBootstrap):
     }
 
     def __init__(
-        self, order: int = 1, n_bootstraps: int = 999, random_state: int | None = None
+        self,
+        order: int = 1,
+        innovation: Innovation | None = None,
+        n_bootstraps: int = 999,
+        random_state: int | None = None,
     ) -> None:
         self.order = order
+        self.innovation = innovation
         super().__init__(n_bootstraps=n_bootstraps, random_state=random_state)
 
     def _make_spec(self) -> MethodSpec:
-        return ResidualBootstrap(model=VAR(order=self.order))
+        return ResidualBootstrap(
+            model=VAR(order=self.order),
+            innovation=self.innovation if self.innovation is not None else IID(),
+        )
 
     @classmethod
     def get_test_params(cls) -> list[dict[str, Any]]:
@@ -327,16 +356,23 @@ class SieveBootstrap(BaseTimeSeriesBootstrap):
         min_lag: int = 1,
         max_lag: int | None = None,
         criterion: Literal["aic", "bic", "hqic"] = "bic",
+        innovation: Innovation | None = None,
         n_bootstraps: int = 999,
         random_state: int | None = None,
     ) -> None:
         self.min_lag = min_lag
         self.max_lag = max_lag
         self.criterion: Literal["aic", "bic", "hqic"] = criterion
+        self.innovation = innovation
         super().__init__(n_bootstraps=n_bootstraps, random_state=random_state)
 
     def _make_spec(self) -> MethodSpec:
-        return SieveAR(min_lag=self.min_lag, max_lag=self.max_lag, criterion=self.criterion)
+        return SieveAR(
+            min_lag=self.min_lag,
+            max_lag=self.max_lag,
+            criterion=self.criterion,
+            innovation=self.innovation if self.innovation is not None else IID(),
+        )
 
     @classmethod
     def get_test_params(cls) -> list[dict[str, Any]]:

{tsbootstrap-0.3.0 → tsbootstrap-0.4.0}/src/tsbootstrap/block/_compiled.py

@@ -2114,6 +2114,12 @@ def compiled_supports(method: object) -> bool:
     if isinstance(method, ResidualBootstrap):
         # The recursive residual AR and VAR fast paths are built; ARIMA models stay
         # on the numpy backend (the unified entry raises the typed error for them).
+        # The residual kernels resample IID innovations inside the compiled loop, so
+        # any other innovation (the wild multiplier family, block innovations) must be
+        # rejected here: running the IID kernel for them would silently return a
+        # different bootstrap distribution than the one the spec asks for.
+        if not isinstance(method.innovation, IID):
+            return False
         return isinstance(method.model, (AR, VAR))
     return isinstance(
         method, (IID, MovingBlock, CircularBlock, StationaryBlock, NonOverlappingBlock)
@@ -2122,6 +2128,24 @@ def compiled_supports(method: object) -> bool:
 
 def unsupported_method_error(method: object) -> MethodConfigError:
     """The typed error raised when the compiled backend has no kernel for a method."""
+    from tsbootstrap.methods import AR, IID, VAR, ResidualBootstrap
+
+    # A residual bootstrap whose MODEL is supported but whose INNOVATION is not:
+    # name the innovation, not the method, so the message does not falsely imply
+    # that ResidualBootstrap itself lacks a compiled kernel.
+    if (
+        isinstance(method, ResidualBootstrap)
+        and isinstance(method.model, (AR, VAR))
+        and not isinstance(method.innovation, IID)
+    ):
+        innovation_name = type(method.innovation).__name__
+        return MethodConfigError(
+            f"backend='compiled' does not support {innovation_name} innovations; "
+            "the compiled residual kernels resample IID innovations only",
+            code=Codes.INVALID_PARAMETER,
+            context={"method": type(method).__name__, "innovation": innovation_name},
+            hint="Use the default backend='numpy' for wild-type or block innovations.",
+        )
     return MethodConfigError(
         f"backend='compiled' does not support {type(method).__name__}; "
         f"supported methods: {list(_SUPPORTED_METHOD_NAMES)}.",

{tsbootstrap-0.3.0 → tsbootstrap-0.4.0}/src/tsbootstrap/mcp.py

@@ -40,6 +40,7 @@ from tsbootstrap.methods import (
     StationaryBlock,
     TaperedBlock,
 )
+from tsbootstrap.uq.classical import percentile_interval
 
 if TYPE_CHECKING:  # pragma: no cover - import only for type checkers
     from mcp.server.fastmcp import FastMCP
@@ -373,15 +374,13 @@ def bootstrap_confidence_interval(
         return _error(f"bootstrap run failed: {result.failure_reason}")
 
     replicate_stats = np.asarray(result.statistics, dtype=np.float64).reshape(-1)
-    alpha = 1.0 - confidence_level
-    lower_q = 100.0 * (alpha / 2.0)
-    upper_q = 100.0 * (1.0 - alpha / 2.0)
+    ci_lower, ci_upper = percentile_interval(replicate_stats, alpha=1.0 - confidence_level)
 
     return {
         "point_estimate": float(reducer(arr)),
         "standard_error": float(np.std(replicate_stats, ddof=0)),
-        "ci_lower": float(np.percentile(replicate_stats, lower_q)),
-        "ci_upper": float(np.percentile(replicate_stats, upper_q)),
+        "ci_lower": float(ci_lower),
+        "ci_upper": float(ci_upper),
         "confidence_level": float(confidence_level),
         "n_bootstraps": int(n_bootstraps),
         "method": method_name,

{tsbootstrap-0.3.0 → tsbootstrap-0.4.0}/src/tsbootstrap/metadata.py

@@ -118,7 +118,14 @@ METHODS: dict[type, MethodMetadata] = {
         supports_indices=False,
         supports_oob=False,
         preserves_temporal_dependence=True,
-        references=("Efron-Tibshirani 1993", "Kreiss-Lahiri 2012"),
+        references=(
+            "Efron-Tibshirani 1993",
+            "Kreiss-Lahiri 2012",
+            "Wu 1986 (wild innovations)",
+            "Mammen 1993 (wild innovations)",
+            "Davidson-Flachaire 2008 (Rademacher default)",
+            "Shao 2010 (block-wild innovations)",
+        ),
         complexity="O(B*n*p) AR; O(B*n*p*d^2) VAR",
         failure_modes=("model misspecification", "near-unit-root instability"),
     ),

{tsbootstrap-0.3.0 → tsbootstrap-0.4.0}/src/tsbootstrap/methods.py

@@ -14,6 +14,8 @@ Composition:
 
 - Observation-resampling specs (:class:`IID`, the ``*Block`` family) double as
   the ``innovation`` resampler for residual/sieve bootstraps.
+- :class:`Wild` and :class:`BlockWild` are innovation-only specs (multiplier
+  resamplers); they are valid as ``innovation`` but not as a top-level method.
 - :class:`ResidualBootstrap` pairs a model (:class:`AR`/:class:`ARIMA`/
   :class:`VAR`) with an innovation resampler.
 """
@@ -121,6 +123,56 @@ class TaperedBlock(BaseMethodSpec):
     _v = field_validator("block_length", mode="before")(_check_block_length)
 
 
+# --------------------------------------------------------------------------- #
+# Innovation-only specs (valid ONLY as an `innovation` resampler, never as a
+# top-level method: they transform residuals in place rather than resample
+# observations, so no observation indices exist).
+# --------------------------------------------------------------------------- #
+WildDistribution = Literal["rademacher", "gaussian", "mammen"]
+
+
+class Wild(BaseMethodSpec):
+    """Wild bootstrap innovations (Wu 1986; Liu 1988): ``e*_t = v_t * e_hat_t``.
+
+    Each centered residual keeps its time position and magnitude; an i.i.d.
+    external multiplier ``v_t`` (mean 0, variance 1) randomizes its sign/scale.
+    Valid under conditional heteroskedasticity of unknown form, where index
+    resampling would average the variance profile away. The default Rademacher
+    multiplier follows Davidson and Flachaire (2008); ``"mammen"`` is the
+    two-point distribution of Mammen (1993) matching the third moment;
+    ``"gaussian"`` is the standard normal multiplier.
+
+    Requires ``burn_in=0`` and ``initial="fixed"`` on the host model spec: the
+    multiplier stream is aligned one-to-one with the residuals, conditional on
+    the observed initial values.
+    """
+
+    kind: Literal["wild"] = "wild"
+    distribution: WildDistribution = "rademacher"
+
+
+class BlockWild(BaseMethodSpec):
+    """Block-wild bootstrap innovations: multipliers constant on time blocks.
+
+    One multiplier is drawn per contiguous non-overlapping block of the
+    residual sequence and repeated across that block, so within-block residual
+    dependence survives the resampling (a piecewise-constant special case of
+    the dependent wild bootstrap of Shao 2010; the block-constant construction
+    mirrors the wild cluster bootstrap of Cameron, Gelbach, and Miller 2008
+    with time blocks as clusters). ``block_length=1`` degenerates to
+    :class:`Wild`. ``"auto"`` resolves the block length from the centered
+    residuals via the Politis-White rule at fit time.
+
+    Same host-model constraints as :class:`Wild` (``burn_in=0``,
+    ``initial="fixed"``).
+    """
+
+    kind: Literal["block_wild"] = "block_wild"
+    distribution: WildDistribution = "rademacher"
+    block_length: BlockLength = "auto"
+    _v = field_validator("block_length", mode="before")(_check_block_length)
+
+
 # --------------------------------------------------------------------------- #
 # Model specs (the conditional mean for residual bootstraps).
 # --------------------------------------------------------------------------- #
@@ -160,7 +212,7 @@ class VAR(_RecursiveInitSpec):
 
 
 Innovation = Annotated[
-    Union[IID, MovingBlock, CircularBlock, StationaryBlock, NonOverlappingBlock],
+    Union[IID, MovingBlock, CircularBlock, StationaryBlock, NonOverlappingBlock, Wild, BlockWild],
     Field(discriminator="kind"),
 ]
 ModelSpec = Annotated[Union[AR, ARIMA, VAR], Field(discriminator="kind")]
@@ -223,6 +275,9 @@ __all__ = [
     "StationaryBlock",
     "NonOverlappingBlock",
     "TaperedBlock",
+    "Wild",
+    "BlockWild",
+    "WildDistribution",
     "AR",
     "ARIMA",
     "VAR",