diff-diff 3.11.0__tar.gz → 3.11.1__tar.gz

{diff_diff-3.11.0 → diff_diff-3.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diff-diff
-Version: 3.11.0
+Version: 3.11.1
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Science/Research
 Classifier: Operating System :: OS Independent

{diff_diff-3.11.0 → diff_diff-3.11.1}/diff_diff/__init__.py

@@ -371,7 +371,7 @@ def __getattr__(name: str) -> _Any:
     raise AttributeError(f"module 'diff_diff' has no attribute {name!r}")
 
 
-__version__ = "3.11.0"
+__version__ = "3.11.1"
 __all__ = [
     # Estimators
     "DifferenceInDifferences",

{diff_diff-3.11.0 → diff_diff-3.11.1}/diff_diff/_staggered_triple_diff_engine.py

@@ -295,8 +295,20 @@ class _StaggeredTripleDiffEngineMixin:
             if resolved_survey is not None and survey_metadata is not None:
                 resolved_survey_unit = precomputed.get("resolved_survey_unit")
                 if resolved_survey_unit is not None:
-                    unit_w = resolved_survey_unit.weights
-                    survey_metadata = compute_survey_metadata(resolved_survey_unit, unit_w)
+                    from diff_diff.survey import _extract_unit_survey_weights
+
+                    # Raw (pre-normalization) unit weights for metadata
+                    # provenance: compute_survey_metadata expects the ORIGINAL
+                    # scale (resolve() rescales pweights to mean 1, so the
+                    # resolved weights would misreport sum_weights/
+                    # weight_range; scale-invariant fields are unaffected
+                    # either way). Read from ``data``: ``df`` has first_treat
+                    # overwritten by this point.
+                    assert survey_design is not None
+                    raw_unit_w = _extract_unit_survey_weights(
+                        data, unit, survey_design, precomputed["all_units"]
+                    )
+                    survey_metadata = compute_survey_metadata(resolved_survey_unit, raw_unit_w)
 
             # Survey df for t-distribution critical values
             df_survey = precomputed.get("df_survey")

{diff_diff-3.11.0 → diff_diff-3.11.1}/diff_diff/chaisemartin_dhaultfoeuille.py

@@ -51,7 +51,7 @@ from diff_diff.chaisemartin_dhaultfoeuille_results import (
     DCDHBootstrapResults,
 )
 from diff_diff.linalg import solve_ols
-from diff_diff.utils import safe_inference
+from diff_diff.utils import safe_inference, validate_n_bootstrap
 
 __all__ = [
     "ChaisemartinDHaultfoeuille",
@@ -762,8 +762,8 @@ class ChaisemartinDHaultfoeuille(ChaisemartinDHaultfoeuilleBootstrapMixin, BaseE
             )
         if not 0.0 < alpha < 1.0:
             raise ValueError(f"alpha must be in (0, 1), got {alpha}")
-        if n_bootstrap < 0:
-            raise ValueError(f"n_bootstrap must be non-negative, got {n_bootstrap}")
+        # Shared type guard (rejects bool/float, floor stays 0).
+        validate_n_bootstrap(n_bootstrap)
         if by_path is not None:
             if isinstance(by_path, bool) or not isinstance(by_path, int):
                 raise ValueError(
@@ -836,8 +836,9 @@ class ChaisemartinDHaultfoeuille(ChaisemartinDHaultfoeuilleBootstrapMixin, BaseE
             )
         if not 0.0 < self.alpha < 1.0:
             raise ValueError(f"alpha must be in (0, 1), got {self.alpha}")
-        if self.n_bootstrap < 0:
-            raise ValueError(f"n_bootstrap must be non-negative, got {self.n_bootstrap}")
+        # Shared type guard (kept aligned with __init__ so the two sites
+        # cannot drift).
+        validate_n_bootstrap(self.n_bootstrap)
         if self.by_path is not None:
             if isinstance(self.by_path, bool) or not isinstance(self.by_path, int):
                 raise ValueError(

{diff_diff-3.11.0 → diff_diff-3.11.1}/diff_diff/continuous_did.py

@@ -506,6 +506,18 @@ class ContinuousDiD(_ContinuousDiDAggregationMixin, BaseEstimator):
             if col not in df.columns:
                 raise ValueError(f"Column '{col}' not found in data.")
 
+        # Snapshot the raw survey-weight column BEFORE any df mutation
+        # (never-treated dose zeroing, first_treat inf->0, to_numeric): a
+        # design whose weight column aliases a mutable role column (e.g.
+        # weights == dose) must still surface the user's ORIGINAL values in
+        # survey_metadata. Per-unit via groupby-first so the later
+        # dose-filter (which drops whole units) cannot desync alignment.
+        raw_unit_w_meta: Optional[pd.Series] = None
+        if survey_design is not None and survey_design.weights is not None:
+            # `is not None`, not truthiness: resolve() treats any non-None
+            # string — an empty-string column name included — as a column.
+            raw_unit_w_meta = data.groupby(unit)[survey_design.weights].first()
+
         # Covariate-path guards (conditional parallel trends).
         if cov_cols:
             if survey_design is not None:
@@ -770,11 +782,20 @@ class ContinuousDiD(_ContinuousDiDAggregationMixin, BaseEstimator):
                 )
             lowest_dose = d_L
 
-        # Re-resolve survey design on filtered df if rows were dropped
-        # (survey arrays must align with df, not the original data)
+        # Re-resolve survey design on the filtered rows if rows were dropped
+        # (survey arrays must align with df, not the original data). Resolve
+        # from PRISTINE ``data`` rows, not the mutated working frame: the
+        # unfiltered path resolves from ``data``, and df's role-column
+        # coercions (never-treated dose zeroing, first_treat inf->0,
+        # to_numeric) must not leak into a design whose column aliases a
+        # mutated role column — resolving on df previously zero-weighted
+        # every never-treated unit when ``weights == dose``. The dose filter
+        # drops whole units and preserves row order, so the pristine
+        # unit-mask selection is row-for-row identical to df.
         if resolved_survey is not None and len(df) < len(data):
+            _kept_row_mask = data[unit].isin(set(df[unit].unique())).to_numpy()
             resolved_survey, survey_weights, survey_weight_type, survey_metadata = (
-                _resolve_survey_for_fit(survey_design, df, "analytical")
+                _resolve_survey_for_fit(survey_design, data[_kept_row_mask], "analytical")
             )
 
         # 2. Precompute structures
@@ -973,6 +994,39 @@ class ContinuousDiD(_ContinuousDiDAggregationMixin, BaseEstimator):
 
         _survey_df = None  # Set by analytical branch when survey is active
 
+        # Recompute survey_metadata from the UNIT-level design on EVERY arm
+        # (degenerate no-post-cells, bootstrap, analytic) so reported
+        # sum_weights/effective_n/n_psu/df_survey describe one granularity —
+        # the CS/EfficientDiD convention. Construction is byte-identical to
+        # the ones inside _run_bootstrap and _compute_analytical_se.
+        _unit_resolved_shared = None
+        if resolved_survey is not None:
+            # Built ONCE and threaded into the analytical/bootstrap helpers
+            # below (they previously rebuilt it — on replicate designs that
+            # copied the unit-by-replicate matrix twice).
+            _unit_resolved_shared = resolved_survey.subset_to_units_by_row_idx(
+                precomp["unit_first_panel_row"],
+                unit_weights=precomp.get("unit_survey_weights"),
+            )
+        if resolved_survey is not None and survey_metadata is not None:
+            from diff_diff.survey import compute_survey_metadata
+
+            _unit_resolved_meta = _unit_resolved_shared
+            # Raw (pre-normalization) unit weights for metadata provenance:
+            # compute_survey_metadata expects the ORIGINAL scale (resolve()
+            # rescales pweights to mean 1; scale-invariant fields are
+            # unaffected either way). ``raw_unit_w_meta`` was snapshotted
+            # from pristine ``data`` before the df mutations; reindexing to
+            # ``all_units`` (the dose-filtered unit order) keeps alignment —
+            # survey weights are unit-constant (validated at resolve time).
+            assert survey_design is not None
+            raw_w_unit = (
+                raw_unit_w_meta.reindex(precomp["all_units"]).to_numpy(dtype=np.float64)
+                if raw_unit_w_meta is not None
+                else np.ones(precomp["n_units"], dtype=np.float64)
+            )
+            survey_metadata = compute_survey_metadata(_unit_resolved_meta, raw_w_unit)
+
         if len(post_gt) == 0:
             warnings.warn(
                 "No post-treatment (g,t) cells available for aggregation. "
@@ -1040,6 +1094,7 @@ class ContinuousDiD(_ContinuousDiDAggregationMixin, BaseEstimator):
                     agg_acrt_d,
                     event_study_effects,
                     resolved_survey=resolved_survey,
+                    pre_unit_resolved=_unit_resolved_shared,
                 )
                 att_d_se = boot_result["att_d_se"]
                 att_d_ci_lower = boot_result["att_d_ci_lower"]
@@ -1080,6 +1135,7 @@ class ContinuousDiD(_ContinuousDiDAggregationMixin, BaseEstimator):
                     agg_att_d,
                     agg_acrt_d,
                     resolved_survey=resolved_survey,
+                    pre_unit_resolved=_unit_resolved_shared,
                 )
                 att_d_se = analytic["att_d_se"]
                 acrt_d_se = analytic["acrt_d_se"]
@@ -1097,14 +1153,9 @@ class ContinuousDiD(_ContinuousDiDAggregationMixin, BaseEstimator):
                 ):
                     _survey_df = 0
 
-                # Recompute survey_metadata from unit-level design so reported
-                # effective_n/n_psu/df_survey match the inference actually run
-                _unit_resolved = analytic.get("unit_resolved")
-                if _unit_resolved is not None:
-                    from diff_diff.survey import compute_survey_metadata
-
-                    raw_w_unit = _unit_resolved.weights
-                    survey_metadata = compute_survey_metadata(_unit_resolved, raw_w_unit)
+                # (Unit-level survey_metadata is recomputed once for ALL
+                # arms before the post_gt split; only the replicate-df
+                # propagation below is analytic-arm-specific.)
 
                 # Propagate replicate df override to survey_metadata for display
                 # (but not the df=0 sentinel — keep metadata as None for undefined df)
@@ -1234,6 +1285,15 @@ class ContinuousDiD(_ContinuousDiDAggregationMixin, BaseEstimator):
             rank_deficient_action=self.rank_deficient_action,
             event_study_effects=event_study_effects,
             survey_metadata=survey_metadata,
+            # Per-row ES df provenance (M-092 completion): the survey df the
+            # ES rows' safe_inference used. None when no ES surface was
+            # built, on bootstrap fits (_survey_df stays None there), on
+            # non-survey fits, and for the replicate-undefined 0 sentinel.
+            event_study_df=(
+                float(_survey_df)
+                if (event_study_effects is not None and _survey_df is not None and _survey_df > 0)
+                else None
+            ),
         )
         # Post-fit aggregation kit (row M-025): attached on EVERY fit;
         # scalars-only on bootstrap fits (the ES route fails closed there).
@@ -1942,6 +2002,7 @@ class ContinuousDiD(_ContinuousDiDAggregationMixin, BaseEstimator):
         agg_att_d: np.ndarray,
         agg_acrt_d: np.ndarray,
         resolved_survey: Optional["ResolvedSurveyDesign"] = None,
+        pre_unit_resolved: Optional["ResolvedSurveyDesign"] = None,
     ) -> Dict[str, Any]:
         """Compute analytical SEs using influence functions."""
         n_units = precomp["n_units"]
@@ -2042,9 +2103,16 @@ class ContinuousDiD(_ContinuousDiDAggregationMixin, BaseEstimator):
             # The resolved_survey has panel-level arrays (n_obs = n_units * n_periods),
             # but influence functions are unit-level (n_units). Build a unit-level
             # ResolvedSurveyDesign by subsetting to one obs per unit.
-            row_idx = precomp["unit_first_panel_row"]
-            unit_resolved = resolved_survey.subset_to_units_by_row_idx(
-                row_idx, unit_weights=precomp.get("unit_survey_weights")
+            # Reuse the fit-level collapse when supplied (avoids copying
+            # the unit-by-replicate matrix a second time on replicate
+            # designs); construction is byte-identical.
+            unit_resolved = (
+                pre_unit_resolved
+                if pre_unit_resolved is not None
+                else resolved_survey.subset_to_units_by_row_idx(
+                    precomp["unit_first_panel_row"],
+                    unit_weights=precomp.get("unit_survey_weights"),
+                )
             )
 
             X_ones = np.ones((n_units, 1))
@@ -2142,6 +2210,7 @@ class ContinuousDiD(_ContinuousDiDAggregationMixin, BaseEstimator):
         original_acrt_d: np.ndarray,
         event_study_effects: Optional[Dict[int, Dict]],
         resolved_survey: Optional["ResolvedSurveyDesign"] = None,
+        pre_unit_resolved: Optional["ResolvedSurveyDesign"] = None,
     ) -> Dict[str, Any]:
         """Run multiplier bootstrap inference."""
         if self.n_bootstrap < 50:
@@ -2172,9 +2241,15 @@ class ContinuousDiD(_ContinuousDiDAggregationMixin, BaseEstimator):
         # Build unit-level ResolvedSurveyDesign for survey-aware bootstrap
         unit_resolved = None
         if resolved_survey is not None:
-            row_idx = precomp["unit_first_panel_row"]
-            unit_resolved = resolved_survey.subset_to_units_by_row_idx(
-                row_idx, unit_weights=precomp.get("unit_survey_weights")
+            # Reuse the fit-level collapse when supplied (byte-identical
+            # construction; avoids a second unit-by-replicate copy).
+            unit_resolved = (
+                pre_unit_resolved
+                if pre_unit_resolved is not None
+                else resolved_survey.subset_to_units_by_row_idx(
+                    precomp["unit_first_panel_row"],
+                    unit_weights=precomp.get("unit_survey_weights"),
+                )
             )
 
         # Generate bootstrap weights — PSU-level when survey design is present

{diff_diff-3.11.0 → diff_diff-3.11.1}/diff_diff/continuous_did_results.py

@@ -125,6 +125,11 @@ class ContinuousDiDResults(BaseResults, AggregationMixin):
         Random seed used for bootstrap.
     rank_deficient_action : str
         How rank deficiency is handled (``"warn"``, ``"error"``, ``"silent"``).
+    event_study_df : float or None
+        Scalar survey df governing the event-study rows' t-inference.
+        ``None`` on non-survey fits, on bootstrapped fits, when no
+        fit-time event-study surface was built, and for the
+        replicate-undefined ``0`` sentinel.
     """
 
     dose_response_att: DoseResponseCurve
@@ -176,9 +181,16 @@ class ContinuousDiDResults(BaseResults, AggregationMixin):
     # Survey design metadata (SurveyMetadata instance from diff_diff.survey)
     survey_metadata: Optional[Any] = field(default=None)
     # Post-fit aggregation kit (row M-025), attached by ContinuousDiD.fit().
-    # Declared LAST for positional-__init__ compatibility. Only the
-    # 'event_study' recompute reads it; 'simple'/'dose' are views.
+    # New fields are appended AFTER this one (positional-__init__
+    # compatibility). Only the 'event_study' recompute reads it;
+    # 'simple'/'dose' are views.
     _aggregation_kit: Optional[Any] = field(default=None, repr=False, compare=False)
+    # Scalar survey df governing the event-study rows' t-inference. None on
+    # non-survey fits, on bootstrapped fits (percentile inference; the ES
+    # recompute also fails closed there), when no event-study surface was
+    # built, and for the replicate-undefined 0 sentinel. Appended last per
+    # the positional-__init__ convention above.
+    event_study_df: Optional[float] = None
 
     # Post-fit aggregation routing (M-122 contract). ContinuousDiD's extra
     # 'dose' level is documented in the ledger row and v4-design section 6;
@@ -683,12 +695,16 @@ class ContinuousDiDResults(BaseResults, AggregationMixin):
         # cells exist.
         meta = bk["survey_metadata"]
         meta = dataclasses.replace(meta) if meta is not None else None
+        # Per-row df provenance: the kit's survey df is the value this
+        # route's safe_inference calls received; 0-sentinel normalized.
+        _es_df = bk["survey_df"]
         carrier = dataclasses.replace(
             self,
             event_study_effects=es,
             survey_metadata=meta,
             alpha=kit.alpha,
             anticipation=kit.anticipation,
+            event_study_df=(float(_es_df) if _es_df is not None and _es_df > 0 else None),
             # _provenance_kwargs reads base_period off the carrier - it
             # rides the kit like its siblings alpha/anticipation so
             # post-fit mutation of the public field cannot reach

{diff_diff-3.11.0 → diff_diff-3.11.1}/diff_diff/dml_did.py

@@ -1364,15 +1364,43 @@ class DMLDiD(CallawaySantAnnaBootstrapMixin, CallawaySantAnnaAggregationMixin, B
             "control_inf": inf_full[control_idx],
         }
 
-        # Per-cell SE. PSU designs (declared OR bare cluster=) route through
-        # the CS per-cell CR1 helper (3-valued contract: float = use it,
-        # NaN = unidentified clustered variance and MUST propagate,
-        # None = malformed -> fall back). Non-PSU survey designs use the
-        # weighted sqrt-sum (CS mirror: the full design enters aggregate SEs
-        # only); the no-survey branch is verbatim.
+        # Per-cell SE. Replicate designs use IF-reweighting on the Hajek
+        # payload (compute_replicate_if_variance; the same psi the aggregate
+        # _se_from_psi call consumes) — a zero or non-finite replicate
+        # variance is degenerate and fails closed to NaN (stricter than the
+        # shared aggregate clamp; REGISTRY DMLDiD Note). PSU designs
+        # (declared OR bare cluster=) route through the CS per-cell CR1
+        # helper (3-valued contract: float = use it, NaN = unidentified
+        # clustered variance and MUST propagate, None = malformed -> fall
+        # back). Non-PSU survey designs use the weighted sqrt-sum (CS
+        # mirror: the full design enters aggregate SEs only); the no-survey
+        # branch is verbatim.
         se: float
         with np.errstate(over="ignore", invalid="ignore"):
-            if (
+            if resolved_survey_unit is not None and resolved_survey_unit.uses_replicate_variance:
+                from diff_diff.survey import compute_replicate_if_variance
+
+                variance, n_valid_rep = compute_replicate_if_variance(
+                    inf_full, resolved_survey_unit
+                )
+                if not np.isfinite(variance) or variance <= 0.0:
+                    se = float("nan")
+                else:
+                    se = float(np.sqrt(variance))
+                # Per-cell df: min(design df, n_valid - 1) — the dCDH
+                # _effective_df_survey rule, inlined. n_valid is computed
+                # over the WHOLE replicate columns, so it equals R for every
+                # cell in practice (defensive; REGISTRY Note). df_survey is
+                # a CELL-LOCAL binding — never mutate
+                # precomputed["df_survey"], which feeds the post-fit
+                # aggregation kit.
+                if df_survey is not None:
+                    df_survey = min(int(df_survey), int(n_valid_rep) - 1)
+                else:
+                    # Undefined replicate df (QR rank <= 1): df=0 sentinel
+                    # -> NaN inference (CS sentinel parity).
+                    df_survey = 0
+            elif (
                 resolved_survey_unit is not None
                 and getattr(resolved_survey_unit, "psu", None) is not None
             ):
@@ -1386,9 +1414,10 @@ class DMLDiD(CallawaySantAnnaBootstrapMixin, CallawaySantAnnaAggregationMixin, B
             else:
                 se = float(np.sqrt(np.mean(psi_bar**2) / n_cell))
         # NOTE: `se` is deliberately OUTSIDE the non_finite_score gate on the
-        # design-based branches — a NaN from the CR1 helper is the
-        # unidentified-variance signal and must flow to safe_inference as a
-        # NaN-consistent inference tuple on a RETAINED cell.
+        # design-based branches — a NaN from the CR1 helper (or a degenerate
+        # replicate variance) is the unidentified-variance signal and must
+        # flow to safe_inference as a NaN-consistent inference tuple on a
+        # RETAINED cell.
         if resolved_survey_unit is None and not np.isfinite(se):
             diagnostics["skip_reason"] = "non_finite_score"
             return (
@@ -1760,12 +1789,28 @@ class DMLDiD(CallawaySantAnnaBootstrapMixin, CallawaySantAnnaAggregationMixin, B
         }
 
         # Per-cell SE (same dispatch as the panel cell; see the comment
-        # there): PSU designs -> CS per-cell CR1 helper (NaN propagates as
+        # there): replicate designs -> IF-reweighting with the degenerate
+        # fail-closed guard and the cell-local min(df, n_valid - 1) rule;
+        # PSU designs -> CS per-cell CR1 helper (NaN propagates as
         # the deliberate unidentified-variance signal on a RETAINED cell);
         # non-PSU survey -> weighted sqrt-sum; no-survey verbatim.
         se: float
         with np.errstate(over="ignore", invalid="ignore"):
-            if (
+            if resolved_survey_unit is not None and resolved_survey_unit.uses_replicate_variance:
+                from diff_diff.survey import compute_replicate_if_variance
+
+                variance, n_valid_rep = compute_replicate_if_variance(
+                    inf_full, resolved_survey_unit
+                )
+                if not np.isfinite(variance) or variance <= 0.0:
+                    se = float("nan")
+                else:
+                    se = float(np.sqrt(variance))
+                if df_survey is not None:
+                    df_survey = min(int(df_survey), int(n_valid_rep) - 1)
+                else:
+                    df_survey = 0
+            elif (
                 resolved_survey_unit is not None
                 and getattr(resolved_survey_unit, "psu", None) is not None
             ):
@@ -1831,19 +1876,24 @@ class DMLDiD(CallawaySantAnnaBootstrapMixin, CallawaySantAnnaAggregationMixin, B
         Parameters
         ----------
         survey_design : SurveyDesign, optional
-            Complex survey design (pweight-only; full-design TSL —
-            weights/strata/PSU/FPC). Declared designs weight the moment
-            kernels (Hajek p-hat/lambda-hat/theta), pass ``sample_weight``
-            into the nuisance learners (user learner objects must accept
-            ``sample_weight`` by keyword — a learner without it is rejected
-            up front), switch cross-fitting to PSU-cohesive folds when the
-            PSU is strictly coarser than the sampling unit, and route the
-            per-cell and aggregate variances through the design-based
-            kernels with ``df = n_PSU - n_strata`` t-inference. Survey
-            support is a documented library extension of Chang (2020),
-            which assumes i.i.d. sampling — Theorem 2's coverage claim
-            does not carry over (REGISTRY DMLDiD Notes). Replicate-weight
-            designs are not supported yet (fail closed; TODO.md).
+            Complex survey design (pweight-only). Declared designs weight
+            the moment kernels (Hajek p-hat/lambda-hat/theta) and pass
+            ``sample_weight`` into the nuisance learners (user learner
+            objects must accept ``sample_weight`` by keyword — a learner
+            without it is rejected up front). Two variance lanes:
+            full-design TSL (weights/strata/PSU/FPC) switches cross-fitting
+            to PSU-cohesive folds when the PSU is strictly coarser than the
+            sampling unit and routes the per-cell and aggregate variances
+            through the design-based kernels with ``df = n_PSU - n_strata``
+            t-inference; replicate-weight designs (BRR / Fay / JK1 / JKn /
+            SDR) compute per-cell AND aggregate variances by IF-reweighting
+            the cross-fitted scores with ``df = rank(replicate matrix) - 1``
+            t-inference (nuisances are not re-estimated per replicate;
+            REGISTRY DMLDiD Note). Replicate designs reject ``cluster=``
+            and ``n_bootstrap > 0`` combinations. Survey support is a
+            documented library extension of Chang (2020), which assumes
+            i.i.d. sampling — Theorem 2's coverage claim does not carry
+            over (REGISTRY DMLDiD Notes).
         """
         df, covariates = self._validate_and_prepare(
             data, outcome, unit, time, first_treat, covariates
@@ -1866,13 +1916,18 @@ class DMLDiD(CallawaySantAnnaBootstrapMixin, CallawaySantAnnaAggregationMixin, B
             survey_metadata,
         ) = _resolve_survey_for_fit(survey_design, data, "analytical")
 
-        # Replicate designs fail closed FIRST (None-guarded): no replicate
-        # variance path exists for the cross-fitted scores yet.
-        if resolved_survey is not None and resolved_survey.uses_replicate_variance:
+        # Replicate + bootstrap rejected FIRST (before any fit work) —
+        # replicate variance is an analytical alternative, not compatible
+        # with bootstrap (CS parity, staggered.py).
+        if (
+            self.n_bootstrap > 0
+            and resolved_survey is not None
+            and resolved_survey.uses_replicate_variance
+        ):
             raise NotImplementedError(
-                "DMLDiD does not support replicate-weight survey designs yet "
-                "(tracked in TODO.md); use a full-design SurveyDesign "
-                "(weights/strata/psu/fpc) instead."
+                "DMLDiD bootstrap (n_bootstrap > 0) is not supported "
+                "with replicate-weight survey designs. Replicate weights provide "
+                "analytical variance; use n_bootstrap=0 instead."
             )
 
         # Raw (pre-normalization) per-obs design weights, for metadata
@@ -1886,7 +1941,7 @@ class DMLDiD(CallawaySantAnnaBootstrapMixin, CallawaySantAnnaAggregationMixin, B
             assert survey_design is not None
             raw_obs_weights = (
                 data[survey_design.weights].values.astype(np.float64)
-                if survey_design.weights
+                if survey_design.weights is not None
                 else np.ones(len(data), dtype=np.float64)
             )
 
@@ -1902,6 +1957,25 @@ class DMLDiD(CallawaySantAnnaBootstrapMixin, CallawaySantAnnaAggregationMixin, B
                     "drop or impute them before fitting"
                 )
             cluster_ids_for_check = _cluster_col.to_numpy()
+            # Reject replicate-weight + cluster= AFTER the column checks (CS
+            # ordering: a bogus cluster name raises ValueError first).
+            # Replicate IF variance is computed by replicate reweighting and
+            # ignores PSU/cluster entirely (replicate_weights are mutually
+            # exclusive with strata/psu/fpc) — honoring cluster= would
+            # silently have no effect on the variance, and the inject-as-PSU
+            # paths below would violate that mutual exclusion.
+            if resolved_survey is not None and resolved_survey.uses_replicate_variance:
+                raise NotImplementedError(
+                    f"DMLDiD(cluster={self.cluster!r}) is not "
+                    "supported with replicate-weight survey designs. "
+                    "Replicate-weight variance is computed by replicate "
+                    "reweighting (BRR / Fay / JK1 / JKn / SDR) and ignores "
+                    "PSU/cluster entirely — setting cluster= would silently "
+                    "have no effect on the variance estimate. Either omit "
+                    "cluster= (the replicate weights encode the design "
+                    "structure implicitly) or use a non-replicate survey "
+                    "design (with explicit strata/psu/fpc)."
+                )
             if resolved_survey is None:
                 # Bare cluster=: synthesize a PSU-only design. survey_metadata
                 # stays None DELIBERATELY (it is the declared-survey marker:
@@ -2188,15 +2262,31 @@ class DMLDiD(CallawaySantAnnaBootstrapMixin, CallawaySantAnnaAggregationMixin, B
 
         # Overall ATT (simple aggregation over post-treatment finite cells).
         # overall_effective_df is non-None only when replicate variance
-        # dropped replicates — unreachable while replicate designs are
-        # rejected, but kept for structural parity with CS.
+        # dropped replicates (n_valid < R). MIN-CAP, not CS's replace: the
+        # QR-rank design df stays the ceiling (CS's replace convention can
+        # RAISE df above the design df — anti-conservative; deliberate
+        # documented divergence, REGISTRY DMLDiD Note + CS-parity TODO row).
         overall_att, overall_se, overall_effective_df = self._aggregate_simple(
             group_time_effects, influence_func_info, df, unit, precomputed
         )
-        if overall_effective_df is not None:
-            df_survey = overall_effective_df
+        if overall_effective_df is not None and df_survey is not None:
+            df_survey = min(int(df_survey), int(overall_effective_df))
+            # Propagate to survey_metadata for display consistency (CS
+            # parity) — the capped value, never the sentinel below.
+            if survey_metadata is not None:
+                survey_metadata.df_survey = df_survey
+        # Replicate design with undefined df (QR rank <= 1): df=0 sentinel
+        # -> NaN inference, applied to the LOCAL df only (survey_metadata
+        # keeps None).
+        df_overall = df_survey
+        if (
+            df_survey is None
+            and resolved_survey is not None
+            and resolved_survey.uses_replicate_variance
+        ):
+            df_overall = 0
         overall_t_stat, overall_p_value, overall_conf_int = safe_inference(
-            overall_att, overall_se, alpha=self.alpha, df=df_survey
+            overall_att, overall_se, alpha=self.alpha, df=df_overall
         )
 
         # Optional multiplier bootstrap (keyword form; aggregate=None is the

{diff_diff-3.11.0 → diff_diff-3.11.1}/diff_diff/dml_did_results.py

@@ -15,9 +15,12 @@ definition (REGISTRY.md "IF-based variance estimators..." — the default),
 and DMLDiD's augmented-score SE ``sqrt(mean(psi_bar**2)/n)`` is exactly
 that on NO-DESIGN fits — per UNIT on panel fits, per OBSERVATION on
 repeated-cross-section fits (rows are the sampling units there). Under a
-``survey_design=``/``cluster=`` the per-cell SE is the design-based CR1 /
-weighted-IF variance instead (the CS clustered-``hc1`` convention:
-``SurveyDesign(psu=...)`` routed through the shared stratified-PSU meat).
+``survey_design=``/``cluster=`` the per-cell SE is design-based instead:
+full-design TSL fits use the CR1 / weighted-IF variance (the CS
+clustered-``hc1`` convention: ``SurveyDesign(psu=...)`` routed through the
+shared stratified-PSU meat), while replicate-weight fits use IF-reweighting
+via ``compute_replicate_if_variance`` on the same per-cell payload
+(``df = rank(replicate matrix) - 1``; REGISTRY DMLDiD Note).
 """
 
 from dataclasses import dataclass, field

{diff_diff-3.11.0 → diff_diff-3.11.1}/diff_diff/efficient_did.py

@@ -1397,6 +1397,32 @@ class EfficientDiD(EfficientDiDBootstrapMixin, _EfficientAggregationMixin, BaseE
             apply_bootstrap_group_overrides(group_effects, bootstrap_results, self.alpha)
 
         # ----- Build results -----
+        # Raw (pre-normalization) unit weights for the metadata recompute:
+        # compute_survey_metadata expects the ORIGINAL scale (resolve()
+        # rescales pweights to mean 1, so the resolved unit weights would
+        # misreport sum_weights/weight_range; scale-invariant fields are
+        # unaffected either way).
+        raw_unit_w_meta: Optional[np.ndarray] = None
+        if self._unit_resolved_survey is not None:
+            assert survey_design is not None
+            # `is not None`, not truthiness: resolve() treats any non-None
+            # string — an empty-string column name included — as a column.
+            raw_obs_w_meta = (
+                data[survey_design.weights].values.astype(np.float64)
+                if survey_design.weights is not None
+                else np.ones(len(data), dtype=np.float64)
+            )
+            raw_unit_w_meta = raw_obs_w_meta[self._unit_first_panel_row]
+        # Per-row ES df provenance (M-092 completion): the post-overall
+        # survey-df snapshot is the df the ES rows' safe_inference used.
+        # None when no ES surface was built, under bootstrap (percentile
+        # inference used no df — the shipped producer convention), and for
+        # the replicate-undefined 0 sentinel (representable only via
+        # survey_metadata.df_survey).
+        _es_df_final: Optional[float] = None
+        if event_study_effects is not None and bootstrap_results is None:
+            if _survey_df_post_overall is not None and _survey_df_post_overall > 0:
+                _es_df_final = float(_survey_df_post_overall)
         self.results_ = EfficientDiDResults(
             group_time_effects=group_time_effects,
             overall_att=overall_att,
@@ -1416,6 +1442,7 @@ class EfficientDiD(EfficientDiDBootstrapMixin, _EfficientAggregationMixin, BaseE
             bootstrap_weights=self.bootstrap_weights,
             seed=self.seed,
             event_study_effects=event_study_effects,
+            event_study_df=_es_df_final,
             group_effects=group_effects,
             efficient_weights=stored_weights if stored_weights else None,
             omega_condition_numbers=stored_cond if stored_cond else None,
@@ -1452,7 +1479,7 @@ class EfficientDiD(EfficientDiDBootstrapMixin, _EfficientAggregationMixin, BaseE
             kernel_bandwidth=self.kernel_bandwidth,
             omega_ridge=self.omega_ridge,
             survey_metadata=(
-                self._recompute_unit_survey_metadata(survey_metadata)
+                self._recompute_unit_survey_metadata(survey_metadata, raw_unit_w_meta)
                 if survey_metadata is not None
                 else None
             ),
@@ -1483,14 +1510,22 @@ class EfficientDiD(EfficientDiDBootstrapMixin, _EfficientAggregationMixin, BaseE
         self.is_fitted_ = True
         return self.results_
 
-    def _recompute_unit_survey_metadata(self, panel_metadata):
-        """Recompute survey metadata from unit-level design if available."""
+    def _recompute_unit_survey_metadata(self, panel_metadata, raw_unit_weights=None):
+        """Recompute survey metadata from unit-level design if available.
+
+        ``raw_unit_weights`` carries the ORIGINAL-scale (pre-normalization)
+        unit weights and MUST be passed whenever ``_unit_resolved_survey``
+        is set — never fall back to ``_unit_resolved_survey.weights``, which
+        resolve() rescaled to mean 1 and would misreport sum_weights/
+        weight_range (scale-invariant fields are unaffected either way).
+        """
         if self._unit_resolved_survey is not None:
             from diff_diff.survey import compute_survey_metadata
 
+            assert raw_unit_weights is not None
             meta = compute_survey_metadata(
                 self._unit_resolved_survey,
-                self._unit_resolved_survey.weights,
+                raw_unit_weights,
             )
             # Propagate effective replicate df if available
             # (but not the df=0 sentinel — keep metadata as None for undefined df)