diff-diff 3.9.1__tar.gz → 3.10.0__tar.gz

{diff_diff-3.9.1 → diff_diff-3.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diff-diff
-Version: 3.9.1
+Version: 3.10.0
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Science/Research
 Classifier: Operating System :: OS Independent
@@ -21,7 +21,7 @@ Requires-Dist: pytest>=7.0 ; extra == 'dev'
 Requires-Dist: pytest-xdist>=3.0 ; extra == 'dev'
 Requires-Dist: pytest-cov>=4.0 ; extra == 'dev'
 Requires-Dist: black==26.5.1 ; extra == 'dev'
-Requires-Dist: ruff==0.16.2 ; extra == 'dev'
+Requires-Dist: ruff==0.16.3 ; extra == 'dev'
 Requires-Dist: mypy==2.3.0 ; extra == 'dev'
 Requires-Dist: maturin>=1.4,<2.0 ; extra == 'dev'
 Requires-Dist: matplotlib>=3.5 ; extra == 'dev'
@@ -175,6 +175,7 @@ Full guide: `diff_diff.get_llm_guide("practitioner")`.
 - [WooldridgeDiD](https://diff-diff.readthedocs.io/en/stable/api/wooldridge_etwfe.html) - Wooldridge (2023, 2025) ETWFE: saturated OLS, logit/Poisson QMLE (ASF-based ATT). Alias `ETWFE`.
 - [LPDiD](https://diff-diff.readthedocs.io/en/stable/api/lpdid.html) - Dube, Girardi, Jorda & Taylor (2025) Local Projections DiD: per-horizon long-difference event study on clean controls (no negative weighting), variance- or equally-weighted ATT, for absorbing or non-absorbing (reversible) treatment
 - [ChangesInChanges](https://diff-diff.readthedocs.io/en/stable/api/changes_in_changes.html) - Athey & Imbens (2006) nonlinear/distributional DiD for the 2x2 design: full counterfactual distribution and quantile treatment effects via CDF transformation, plus the QDiD comparison estimator via `method="qdid"`; bootstrap inference; R qte parity. Alias `CiC`
+- [LWDiD](https://diff-diff.readthedocs.io/en/stable/api/lwdid.html) - Lee & Wooldridge (2025, 2026) rolling-transformation DiD: unit-specific demean/detrend converts panel to cross-section, staggered adoption, `estimation_method` in `reg`/`ipw`/`dr`/`psm` (the papers' RA/IPW/IPWRA plus propensity-score matching), exact small-N inference on the classical collapsed regression
 - [BaconDecomposition](https://diff-diff.readthedocs.io/en/stable/api/bacon.html) - Goodman-Bacon (2021) decomposition for diagnosing TWFE bias in staggered settings
 
 ## Diagnostics & Sensitivity

{diff_diff-3.9.1 → diff_diff-3.10.0}/README.md

@@ -120,6 +120,7 @@ Full guide: `diff_diff.get_llm_guide("practitioner")`.
 - [WooldridgeDiD](https://diff-diff.readthedocs.io/en/stable/api/wooldridge_etwfe.html) - Wooldridge (2023, 2025) ETWFE: saturated OLS, logit/Poisson QMLE (ASF-based ATT). Alias `ETWFE`.
 - [LPDiD](https://diff-diff.readthedocs.io/en/stable/api/lpdid.html) - Dube, Girardi, Jorda & Taylor (2025) Local Projections DiD: per-horizon long-difference event study on clean controls (no negative weighting), variance- or equally-weighted ATT, for absorbing or non-absorbing (reversible) treatment
 - [ChangesInChanges](https://diff-diff.readthedocs.io/en/stable/api/changes_in_changes.html) - Athey & Imbens (2006) nonlinear/distributional DiD for the 2x2 design: full counterfactual distribution and quantile treatment effects via CDF transformation, plus the QDiD comparison estimator via `method="qdid"`; bootstrap inference; R qte parity. Alias `CiC`
+- [LWDiD](https://diff-diff.readthedocs.io/en/stable/api/lwdid.html) - Lee & Wooldridge (2025, 2026) rolling-transformation DiD: unit-specific demean/detrend converts panel to cross-section, staggered adoption, `estimation_method` in `reg`/`ipw`/`dr`/`psm` (the papers' RA/IPW/IPWRA plus propensity-score matching), exact small-N inference on the classical collapsed regression
 - [BaconDecomposition](https://diff-diff.readthedocs.io/en/stable/api/bacon.html) - Goodman-Bacon (2021) decomposition for diagnosing TWFE bias in staggered settings
 
 ## Diagnostics & Sensitivity

{diff_diff-3.9.1 → diff_diff-3.10.0}/diff_diff/__init__.py

@@ -160,6 +160,8 @@ from diff_diff.local_linear import (
 )
 from diff_diff.lpdid import LPDiD
 from diff_diff.lpdid_results import LPDiDResults
+from diff_diff.lwdid import LWDiD
+from diff_diff.lwdid_results import LWDiDResults
 from diff_diff.mmm import (
     MeridianROIPrior,
     meridian_calibration_mask,
@@ -366,7 +368,7 @@ def __getattr__(name: str) -> _Any:
     raise AttributeError(f"module 'diff_diff' has no attribute {name!r}")
 
 
-__version__ = "3.9.1"
+__version__ = "3.10.0"
 __all__ = [
     # Estimators
     "DifferenceInDifferences",
@@ -459,6 +461,9 @@ __all__ = [
     # LPDiD (Local Projections DiD)
     "LPDiD",
     "LPDiDResults",
+    # LWDiD (Lee & Wooldridge rolling transformation DiD)
+    "LWDiD",
+    "LWDiDResults",
     # Visualization
     "plot_bacon",
     "plot_event_study",

{diff_diff-3.9.1 → diff_diff-3.10.0}/diff_diff/_staggered_triple_diff_engine.py

@@ -145,6 +145,8 @@ class _StaggeredTripleDiffEngineMixin:
             unit: Optional[str] = None,
             precomputed: Any = None,
             cband: bool = True,
+            *,
+            _replay_bitgen_state: Optional[Dict[str, Any]] = None,
         ) -> Any: ...
 
     def _fit_staggered_core(

{diff_diff-3.9.1 → diff_diff-3.10.0}/diff_diff/aggregation.py

@@ -553,7 +553,11 @@ class AggregationKit:
         ``cband_crit_value`` is ``None`` both when bands were disabled and
         when no aggregation ran, so it cannot distinguish the two.
     bootstrap : AggregationKit.BootstrapReplaySpec or None
-        Value-bound bootstrap replay description; ``None`` on analytical fits.
+        Value-bound bootstrap replay description. Populated on
+        CallawaySantAnna and EfficientDiD bootstrapped fits (their recompute
+        levels replay the fit-time multiplier bootstrap from it); ``None``
+        on analytical fits and on pre-replay legacy artifacts (whose
+        bootstrapped recompute levels fail closed with a refit message).
     """
 
     bookkeeping: Dict[str, Any]
@@ -574,9 +578,29 @@ class BootstrapReplaySpec:
     ``set_params(n_bootstrap=...)`` silently changes - and can truncate - the
     replayed stream.
 
-    This records the generator state plus the parameters BY VALUE and rebuilds
-    the stream through a module-level factory, which replays bit-identically,
-    pickles, and is immune to later mutation of the estimator.
+    This records the generator state plus the parameters BY VALUE, which
+    pickles and is immune to later mutation of the estimator. Two usage
+    modes:
+
+    - ``rebuild()`` reconstructs the plain unit-level stream via
+      ``iter_weight_blocks`` (it does NOT cover the survey/FPC/PSU-expansion
+      branches).
+    - The CallawaySantAnna and EfficientDiD post-fit replays are
+      STATE-ONLY: they consume
+      ``bitgen_state``/``n_bootstrap``/``weight_type``/``backend`` and let
+      each engine's ``_run_multiplier_bootstrap`` re-derive the generation
+      branch from the kit bookkeeping - one branch-selection implementation
+      per engine, no drift.
+
+    ``backend`` records the weight-generation backend identity at capture
+    (``"rust"``/``"numpy"`` per
+    :func:`diff_diff.bootstrap_chunking.effective_weight_backend`, or
+    ``"portable"`` for provably backend-independent generation branches).
+    The Rust and NumPy generators produce DIFFERENT draws from the same
+    bit-generator state, so a replay under a different backend must FAIL
+    CLOSED rather than silently regenerate another realization. ``None``
+    means unknown and also fails closed - a permissive default on a safety
+    discriminator would let a future constructor silently bypass the guard.
     """
 
     bitgen_state: Dict[str, Any]
@@ -585,6 +609,7 @@ class BootstrapReplaySpec:
     weight_type: str
     block_size: Optional[int] = None
     expand_index: Optional[np.ndarray] = None
+    backend: Optional[str] = None
 
     def rebuild(self) -> Any:
         """Reconstruct the replayable weight stream."""

{diff_diff-3.9.1 → diff_diff-3.10.0}/diff_diff/bootstrap_chunking.py

@@ -70,6 +70,23 @@ if TYPE_CHECKING:
 _TARGET_BLOCK_BYTES = 256 * 1024 * 1024
 
 
+def effective_weight_backend() -> str:
+    """The weight-generation backend :func:`iter_weight_blocks` would use NOW.
+
+    Returns ``"rust"`` exactly when the generator branch below does — the
+    predicate must stay identical to :func:`iter_weight_blocks`'s own
+    ``rust_gen`` resolution. The two backends produce DIFFERENT draws from
+    the same bit-generator state (Rust draws one base seed and row-seeds
+    Xoshiro absolutely; the NumPy fallback consumes the PCG64 stream
+    directly), so a captured RNG state replays bit-identically only within
+    one backend. Post-fit bootstrap replay (the CallawaySantAnna and
+    EfficientDiD ``BootstrapReplaySpec``) stamps this value at fit and fails
+    closed on a mismatch rather than silently regenerating a different
+    realization.
+    """
+    return "rust" if (HAS_RUST_BACKEND and _rust_bootstrap_weights is not None) else "numpy"
+
+
 def compute_block_size(
     n_units: int, n_bootstrap: int, target_bytes: int = _TARGET_BLOCK_BYTES
 ) -> int:

{diff_diff-3.9.1 → diff_diff-3.10.0}/diff_diff/bootstrap_utils.py

@@ -1,16 +1,18 @@
 """
 Shared bootstrap utilities for multiplier bootstrap inference.
 
-Provides weight generation, percentile CI, and p-value helpers used by
-both CallawaySantAnna and ContinuousDiD estimators.
+Provides weight generation, percentile statistics (CI / p-value / per-effect
+stats), and the percentile-override appliers shared across the estimator
+bootstrap engines.
 """
 
 import warnings
-from typing import TYPE_CHECKING, Optional, Tuple
+from typing import TYPE_CHECKING, Any, Dict, Optional, Protocol, Tuple
 
 import numpy as np
 
 from diff_diff._backend import HAS_RUST_BACKEND, _rust_bootstrap_weights
+from diff_diff.utils import safe_inference_batch
 
 if TYPE_CHECKING:
     from diff_diff.survey import ResolvedSurveyDesign
@@ -29,6 +31,8 @@ __all__ = [
     "compute_effect_bootstrap_stats_batch",
     "warn_bootstrap_failure_rate",
     "stratified_bootstrap_indices",
+    "apply_bootstrap_event_study_overrides",
+    "apply_bootstrap_group_overrides",
 ]
 
 
@@ -366,7 +370,12 @@ def compute_effect_bootstrap_stats(
     se = float(np.std(valid_dist, ddof=1))
 
     # Guard: if SE is not finite or zero, all inference fields must be NaN.
-    if not np.isfinite(se) or se <= 0:
+    # An EXACTLY CONSTANT distribution is degenerate too, even when its
+    # np.std comes back tiny-positive from mean-subtraction roundoff at a
+    # non-zero constant level (e.g. census-FPC zero-weight draws leave every
+    # replicate at the original effect): a t built on that roundoff SE would
+    # be astronomically large and silently "significant".
+    if not np.isfinite(se) or se <= 0 or float(valid_dist.max()) == float(valid_dist.min()):
         warnings.warn(
             f"Bootstrap SE is non-finite or zero (n_valid={n_valid}) in {context}. "
             "Returning NaN for SE/CI/p-value.",
@@ -472,8 +481,13 @@ def compute_effect_bootstrap_stats_batch(
         batch_p = np.minimum(2 * batch_p, 1.0)
         batch_p = np.maximum(batch_p, 1 / (n_bootstrap + 1))
 
-        # Guard: SE must be positive and finite
-        se_valid = np.isfinite(batch_ses) & (batch_ses > 0)
+        # Guard: SE must be positive and finite, and the distribution must
+        # not be EXACTLY CONSTANT (a constant non-zero level can produce a
+        # tiny-positive np.std from mean-subtraction roundoff - e.g.
+        # census-FPC zero-weight draws - which would otherwise leak a
+        # roundoff SE and an astronomically large t past the zero check).
+        is_constant = sub.max(axis=0) == sub.min(axis=0)
+        se_valid = np.isfinite(batch_ses) & (batch_ses > 0) & ~is_constant
         n_bad_se = int(np.sum(~se_valid))
         if n_bad_se > 0:
             warnings.warn(
@@ -948,3 +962,96 @@ def generate_rao_wu_weights_batch(
     for b in range(n_bootstrap):
         result[b] = generate_rao_wu_weights(resolved_survey, rng)
     return result
+
+
+# =============================================================================
+# Bootstrap override helpers (shared by fit and the post-fit replay)
+# =============================================================================
+# Extracted verbatim from CallawaySantAnna.fit()'s inline blocks (and adopted
+# by EfficientDiD's fit/replay) so the post-fit aggregate() replay applies
+# EXACTLY the same percentile overrides the fit-time path applies — one
+# implementation, no twin drift. (The deprecated StaggeredTripleDifference
+# keeps its OWN copy of the group replacement loop; unifying it is sequenced
+# with the M-014 container port.) Note on warning attribution: when the
+# engines run under the post-fit replay their fit-tuned stacklevels resolve
+# into library frames rather than the user's aggregate() call — accepted as
+# cosmetic (recorded decision).
+
+
+class _BootstrapOverrideSource(Protocol):
+    """Structural contract for bootstrap containers the appliers consume.
+
+    Both ``CSBootstrapResults`` and ``EDiDBootstrapResults`` satisfy it by
+    field name; a Protocol keeps this module free of estimator imports.
+    """
+
+    event_study_ses: Optional[Dict[Any, float]]
+    event_study_cis: Optional[Dict[Any, Tuple[float, float]]]
+    event_study_p_values: Optional[Dict[Any, float]]
+    group_effect_ses: Optional[Dict[Any, float]]
+    group_effect_cis: Optional[Dict[Any, Tuple[float, float]]]
+    group_effect_p_values: Optional[Dict[Any, float]]
+
+
+def apply_bootstrap_event_study_overrides(
+    event_study_effects: Optional[Dict[int, Dict[str, Any]]],
+    bootstrap_results: _BootstrapOverrideSource,
+    alpha: float,
+) -> None:
+    """Overwrite per-event-time se/CI/p with percentile-bootstrap values.
+
+    Mutates ``event_study_effects`` in place; t is recomputed from the
+    percentile SE via ``safe_inference_batch``. No-op when either side has
+    no event-study surface.
+    """
+    if (
+        event_study_effects is not None
+        and bootstrap_results.event_study_ses is not None
+        and bootstrap_results.event_study_cis is not None
+        and bootstrap_results.event_study_p_values is not None
+    ):
+        es_keys = [e for e in event_study_effects if e in bootstrap_results.event_study_ses]
+        if es_keys:
+            es_effects_arr = np.array([float(event_study_effects[e]["effect"]) for e in es_keys])
+            es_ses_arr = np.array([float(bootstrap_results.event_study_ses[e]) for e in es_keys])
+            es_t_stats, _, _, _ = safe_inference_batch(es_effects_arr, es_ses_arr, alpha=alpha)
+            for idx, e in enumerate(es_keys):
+                event_study_effects[e]["se"] = bootstrap_results.event_study_ses[e]
+                event_study_effects[e]["conf_int"] = bootstrap_results.event_study_cis[e]
+                event_study_effects[e]["p_value"] = bootstrap_results.event_study_p_values[e]
+                event_study_effects[e]["t_stat"] = float(es_t_stats[idx])
+
+
+def apply_bootstrap_group_overrides(
+    group_effects: Optional[Dict[Any, Dict[str, Any]]],
+    bootstrap_results: _BootstrapOverrideSource,
+    alpha: float,
+) -> None:
+    """Overwrite per-group se/CI/p with percentile-bootstrap values.
+
+    Mutates ``group_effects`` in place and clears each row's ``df_used``
+    (the percentile inference never used the analytical df, so keeping it
+    would claim a t-reference that governed nothing). No-op when either
+    side has no group surface.
+    """
+    if (
+        group_effects is not None
+        and bootstrap_results.group_effect_ses is not None
+        and bootstrap_results.group_effect_cis is not None
+        and bootstrap_results.group_effect_p_values is not None
+    ):
+        grp_keys = [g for g in group_effects if g in bootstrap_results.group_effect_ses]
+        if grp_keys:
+            grp_effects_arr = np.array([float(group_effects[g]["effect"]) for g in grp_keys])
+            grp_ses_arr = np.array([float(bootstrap_results.group_effect_ses[g]) for g in grp_keys])
+            grp_t_stats, _, _, _ = safe_inference_batch(grp_effects_arr, grp_ses_arr, alpha=alpha)
+            for idx, g in enumerate(grp_keys):
+                group_effects[g]["se"] = bootstrap_results.group_effect_ses[g]
+                group_effects[g]["conf_int"] = bootstrap_results.group_effect_cis[g]
+                group_effects[g]["p_value"] = bootstrap_results.group_effect_p_values[g]
+                group_effects[g]["t_stat"] = float(grp_t_stats[idx])
+                # Same clearing rule the ES df provenance follows: these
+                # se/p/CI are now percentile-bootstrap values that never used
+                # the analytical df, so keeping df_used would claim a
+                # t-reference that governed nothing.
+                group_effects[g]["df_used"] = None

{diff_diff-3.9.1 → diff_diff-3.10.0}/diff_diff/datasets.py

@@ -1681,7 +1681,11 @@ def load_walmart(force_download: bool = False) -> pd.DataFrame:
     ... )
     """
     url = "http://fmwww.bc.edu/repec/bocode/l/lw_walmart.dta"
-    sha256 = "410885572143dceb9daa643a8097768f1bc3493f9437451a9e4d1d5dc1e18d14"
+    # Re-pinned 2026-08-20: upstream re-saved the .dta (container bytes
+    # changed); every shared column verified numerically identical to the
+    # previously pinned copy (29,371 rows, 1,277 counties) before adopting.
+    # The Stata golden's provenance block keeps the capture-time hash.
+    sha256 = "cf1b2d4aee396f0858fb315d0413ff82359e16e84dad68ce1d9be51e8c3e35ac"
 
     source = "lwdid_ssc_ancillary"
     try:

{diff_diff-3.9.1 → diff_diff-3.10.0}/diff_diff/diagnostic_report.py

@@ -16,7 +16,10 @@ Design principles:
   recompute — for ImputationDiD a panel-backed recompute, for TwoStageDiD
   a fresh Stage-2 OLS + GMM sandwich over the retained frame; used only
   when the raw ``event_study_effects`` field is absent, and failing
-  closed to an explicit skip on bootstrapped / kit-less fits), or
+  closed to an explicit skip on kit-less/legacy-pickle fits, the sibling
+  estimators' bootstrap gates, and backend-mismatched CS bootstrap
+  replays — bootstrapped CS fits themselves derive successfully via the
+  percentile-bootstrap replay), or
   produced by an existing diff-diff utility. May call
   ``check_parallel_trends`` / ``BaconDecomposition`` /
   ``EfficientDiD.hausman_pretest`` when the caller supplies the panel +
@@ -840,8 +843,11 @@ class DiagnosticReport:
                         surface = candidate
                         surface_dict = _surface_to_event_study_dict(candidate)
             except Exception as exc:  # noqa: BLE001 — fail-soft by design:
-                # expected failures are NotImplementedError (bootstrap
-                # gates, pretrends+replicate) and ValueError (missing kit),
+                # expected failures are NotImplementedError (the sibling
+                # estimators' bootstrap gates, pretrends+replicate, CS
+                # legacy-pickle/backend-mismatch replay refusals — a
+                # bootstrapped CS fit itself now derives via the replay)
+                # and ValueError (missing kit),
                 # but the surface builder can raise bare TypeError and this
                 # resolver runs on the applicable_checks path with no outer
                 # guard; an escaped exception would hard-fail the report.

{diff_diff-3.9.1 → diff_diff-3.10.0}/diff_diff/efficient_did.py

@@ -30,7 +30,11 @@ import pandas as pd
 
 from diff_diff._base import BaseEstimator
 from diff_diff._deprecation import NOT_SUPPLIED
-from diff_diff.aggregation import AggregationKit
+from diff_diff.aggregation import AggregationKit, BootstrapReplaySpec
+from diff_diff.bootstrap_utils import (
+    apply_bootstrap_event_study_overrides,
+    apply_bootstrap_group_overrides,
+)
 from diff_diff.efficient_did_aggregation import (
     _cluster_aggregate,
     _compute_se_from_eif,
@@ -118,6 +122,7 @@ def _build_edid_aggregation_kit(
     df_survey: Optional[float],
     alpha: float,
     anticipation: int,
+    bootstrap_results: Optional[EDiDBootstrapResults] = None,
 ) -> Optional[AggregationKit]:
     """Bundle the retained EIF payload + bookkeeping for post-fit aggregate().
 
@@ -138,6 +143,21 @@ def _build_edid_aggregation_kit(
         # Unreachable after fit()'s empty-effects raise; kept for the CS
         # guard shape (a kit with nothing to re-aggregate is not attached).
         return None
+    # STATE-ONLY replay carrier (the CS contract): the spec retains the RNG
+    # snapshot + generation-branch identity the run recorded, BY VALUE, so
+    # post-fit aggregate() can replay the fit-time multiplier bootstrap
+    # through the same engine. Its rebuild() factory is unused here — the
+    # engine re-derives the generation branch from the kit bookkeeping.
+    # None on analytical fits, where the recompute levels stay analytical.
+    replay_spec = None
+    if bootstrap_results is not None and bootstrap_results._replay_bitgen_state is not None:
+        replay_spec = BootstrapReplaySpec(
+            bitgen_state=bootstrap_results._replay_bitgen_state,
+            n_bootstrap=bootstrap_results.n_bootstrap,
+            n_units=int(n_units),
+            weight_type=bootstrap_results.weight_type,
+            backend=bootstrap_results._replay_backend,
+        )
     return AggregationKit(
         bookkeeping={
             # PRIVATE SNAPSHOTS of the aggregation inputs (CI review P0):
@@ -165,7 +185,7 @@ def _build_edid_aggregation_kit(
         alpha=alpha,
         anticipation=anticipation,
         cband=False,
-        bootstrap=None,
+        bootstrap=replay_spec,
     )
 
 
@@ -513,20 +533,23 @@ class EfficientDiD(EfficientDiDBootstrapMixin, _EfficientAggregationMixin, BaseE
             ``.aggregate('group')`` / ``.aggregate('simple')`` /
             ``.aggregate('total')``.  On
             bootstrapped fits (``n_bootstrap > 0``) the post-fit
-            RECOMPUTE levels (``'event_study'``/``'group'``) fail closed
-            — the deprecated fit-time path remains the supported route
-            for those bootstrapped aggregated surfaces —  while
-            ``aggregate('simple')`` and, where supported,
-            ``aggregate('total')`` relay the stored bootstrap
-            inference and stay available (the per-level policy
-            converged with row M-027).
+            RECOMPUTE levels (``'event_study'``/``'group'``) REPLAY the
+            fit-time multiplier bootstrap from the kit-retained RNG
+            state (percentile inference, allclose to a fit-time
+            aggregation; no refit needed), while ``aggregate('simple')``
+            and, where supported, ``aggregate('total')`` relay the
+            stored bootstrap inference (the per-level policy converged
+            with row M-027).
         balance_e : int, optional
             DEPRECATED (3.9, removed in 4.0, row M-120): moves onto
             post-fit ``aggregate()`` —
             ``results.aggregate('event_study', balance_e=2)``.  EDiD's
             balance rule is the ANCHOR-HORIZON rule (keep cohorts with a
-            finite effect at ``e == balance_e``), the same rule
-            CallawaySantAnna uses.
+            finite effect at the anchor horizon), the same rule shape
+            CallawaySantAnna uses — with one keying-granularity
+            difference: EDiD anchors on the ``int(t - g)`` bucket while
+            CS keys raw ``t - g`` (identical on integer-period panels;
+            see the REGISTRY truncation Note).
         survey_design : SurveyDesign, optional
             Survey design specification for design-based inference.
             Applies survey weights to all means, covariances, and cohort
@@ -1364,46 +1387,14 @@ class EfficientDiD(EfficientDiDBootstrapMixin, _EfficientAggregationMixin, BaseE
                     se = float(group_time_effects[gt]["se"])
                     group_time_effects[gt]["t_stat"] = safe_inference(eff, se, alpha=self.alpha)[0]
 
-            es_cis = bootstrap_results.event_study_cis
-            es_pvs = bootstrap_results.event_study_p_values
-            if (
-                event_study_effects is not None
-                and bootstrap_results.event_study_ses is not None
-                and es_cis is not None
-                and es_pvs is not None
-            ):
-                for e in event_study_effects:
-                    if e in bootstrap_results.event_study_ses:
-                        event_study_effects[e]["se"] = bootstrap_results.event_study_ses[e]
-                        event_study_effects[e]["conf_int"] = es_cis[e]
-                        event_study_effects[e]["p_value"] = es_pvs[e]
-                        eff = float(event_study_effects[e]["effect"])
-                        se = float(event_study_effects[e]["se"])
-                        event_study_effects[e]["t_stat"] = safe_inference(
-                            eff, se, alpha=self.alpha
-                        )[0]
-
-            g_cis = bootstrap_results.group_effect_cis
-            g_pvs = bootstrap_results.group_effect_p_values
-            if (
-                group_effects is not None
-                and bootstrap_results.group_effect_ses is not None
-                and g_cis is not None
-                and g_pvs is not None
-            ):
-                for g in group_effects:
-                    if g in bootstrap_results.group_effect_ses:
-                        group_effects[g]["se"] = bootstrap_results.group_effect_ses[g]
-                        group_effects[g]["conf_int"] = g_cis[g]
-                        group_effects[g]["p_value"] = g_pvs[g]
-                        eff = float(group_effects[g]["effect"])
-                        se = float(group_effects[g]["se"])
-                        group_effects[g]["t_stat"] = safe_inference(eff, se, alpha=self.alpha)[0]
-                        # Percentile-bootstrap inference has no analytical df;
-                        # clear the provenance key the analytical pass recorded
-                        # (the CS precedent) so bootstrap rows never publish an
-                        # analytical survey df beside percentile p/CI.
-                        group_effects[g]["df_used"] = None
+            # ES/group percentile overrides via the shared appliers (the same
+            # implementations the post-fit aggregate() replay runs — one
+            # code path, no fit-vs-replay drift). The appliers carry the
+            # availability guards and the group df_used clearing internally.
+            apply_bootstrap_event_study_overrides(
+                event_study_effects, bootstrap_results, self.alpha
+            )
+            apply_bootstrap_group_overrides(group_effects, bootstrap_results, self.alpha)
 
         # ----- Build results -----
         self.results_ = EfficientDiDResults(
@@ -1487,6 +1478,7 @@ class EfficientDiD(EfficientDiDBootstrapMixin, _EfficientAggregationMixin, BaseE
             df_survey=_survey_df_post_overall,
             alpha=self.alpha,
             anticipation=self.anticipation,
+            bootstrap_results=bootstrap_results,
         )
         self.is_fitted_ = True
         return self.results_
@@ -1637,8 +1629,12 @@ class EfficientDiD(EfficientDiDBootstrapMixin, _EfficientAggregationMixin, BaseE
         ) -> Dict[int, Tuple[float, np.ndarray]]:
             """Aggregate (g,t) effects to post-treatment ES(e) with WIF-corrected EIF."""
             by_e: Dict[int, List[Tuple[Tuple, float, float, np.ndarray]]] = {}
+            _has_fractional = False
             for (g, t), d in gt_effects.items():
-                e = int(t - g)
+                raw_e = t - g
+                e = int(raw_e)
+                if raw_e != e:
+                    _has_fractional = True
                 if e < -ant:
                     continue
                 if not np.isfinite(d["effect"]):
@@ -1653,6 +1649,15 @@ class EfficientDiD(EfficientDiDBootstrapMixin, _EfficientAggregationMixin, BaseE
                     by_e[e] = []
                 by_e[e].append(((g, t), d["effect"], pg, eif_vec))
 
+            if _has_fractional:
+                warnings.warn(
+                    "Fractional relative times detected: Hausman pre-test "
+                    "horizons are bucketed by int(t - g) (truncation toward "
+                    "zero). See the EfficientDiD REGISTRY truncation Note.",
+                    UserWarning,
+                    stacklevel=3,
+                )
+
             result: Dict[int, Tuple[float, np.ndarray]] = {}
             for e, items in by_e.items():
                 if e < 0:

{diff_diff-3.9.1 → diff_diff-3.10.0}/diff_diff/efficient_did_aggregation.py

@@ -22,10 +22,13 @@ Contents:
   is what keeps ``aggregate()`` off an ``_estimator_ref``.
 
 The numerical content of every function in this module is byte-identical to
-its pre-extraction form, with ONE additive exception recorded in the M-023
-ledger notes: ``_aggregate_by_group`` records a per-row ``df_used`` key (the
+its pre-extraction form, with the exceptions recorded in the M-023 ledger
+notes: ``_aggregate_by_group`` records a per-row ``df_used`` key (the
 ``self._survey_df`` value at that row's ``safe_inference`` call) so the
-post-fit group relay can publish exact per-row df provenance.
+post-fit group relay can publish exact per-row df provenance;
+``_aggregate_event_study`` counts DISTINCT cohorts in ``n_groups`` (identity
+on integer panels) and warns once when fractional horizons are truncation-
+bucketed (see the EfficientDiD REGISTRY truncation Note).
 """
 
 import warnings
@@ -325,7 +328,12 @@ class _EfficientAggregationMixin:
         cluster_indices: Optional[np.ndarray] = None,
         n_clusters: Optional[int] = None,
     ) -> Dict[int, Dict[str, Any]]:
-        """Aggregate ATT(g,t) by relative time e = t - g.
+        """Aggregate ATT(g,t) by relative time ``e = int(t - g)``.
+
+        On integer-period panels the ``int()`` is the identity. Fractional-
+        period panels are truncation-bucketed toward zero (a documented
+        deviation from the exact-relative-time equation — see the
+        EfficientDiD REGISTRY truncation Note) and emit a ``UserWarning``.
 
         Parameters
         ----------
@@ -346,15 +354,30 @@ class _EfficientAggregationMixin:
         unit_cohorts : ndarray, optional
             Cohort assignment for each unit (for WIF correction).
         """
-        # Organize by relative time
+        # Organize by relative time. Fractional horizons truncation-bucket
+        # (int() toward zero) — a lossy, documented convention that must not
+        # stay invisible to the user (no-silent-failures).
+        _has_fractional = False
         effects_by_e: Dict[int, List[Tuple[Tuple[Any, Any], float, float]]] = {}
         for (g, t), data in group_time_effects.items():
             if not np.isfinite(data["effect"]):
                 continue
-            e = int(t - g)
+            raw_e = t - g
+            e = int(raw_e)
+            if raw_e != e:
+                _has_fractional = True
             if e not in effects_by_e:
                 effects_by_e[e] = []
             effects_by_e[e].append(((g, t), data["effect"], cohort_fractions.get(g, 0.0)))
+        if _has_fractional:
+            warnings.warn(
+                "Fractional relative times detected: event-study horizons are "
+                "bucketed by int(t - g) (truncation toward zero), pooling "
+                "fractional horizons into integer buckets. See the "
+                "EfficientDiD REGISTRY truncation Note.",
+                UserWarning,
+                stacklevel=2,
+            )
 
         # Balance if requested
         if balance_e is not None:
@@ -441,7 +464,13 @@ class _EfficientAggregationMixin:
                 "t_stat": t_stat,
                 "p_value": p_val,
                 "conf_int": ci,
-                "n_groups": len(elist),
+                # DISTINCT cohorts in the bucket (the cohort-count n column): identity
+                # with len(elist) on integer panels (one cell per cohort per
+                # bucket); on fractional panels truncation-bucketing pools
+                # multiple cells per cohort and a raw cell count would
+                # over-count. Weights above remain per-cell (cell-mass within
+                # the bucket — see the REGISTRY truncation Note).
+                "n_groups": len({gt[0] for gt in gt_pairs}),
             }
 
         return result