Prepare for CRAN submission

Simplify:
- Vectorize loglik exact/right hot path; cache extract_md_data in closure
  so optim/numDeriv don't re-validate; unify left/interval branches;
  short-circuit runif when p=0; drop unused closure captures

Architecture:
- Promote maskedcauses from Suggests to Imports so the series_md protocol
  generics (conditional_cause_probability, cause_probability) come from
  exactly one place; delete redeclared stubs; re-export for API continuity

Vignettes:
- Add four vignettes: maskedhaz (overview), custom-components (mixed
  distribution series), censoring-and-masking (four omega types plus
  cross-validation against maskedcauses), hypothesis-tests (LRT, Wald,
  score, test algebra via hypothesize). All build cleanly.

Examples and documentation:
- Add @examples to every exported method (13 total); all verified via
  devtools::run_examples(run_donttest = TRUE)
- Add inst/WORDLIST for technical terms
- Write cran-comments.md
- Expand NEWS.md to describe the 0.1.0 release in detail

Infrastructure:
- R CMD check --as-cran: 0 errors, 0 warnings, 0 notes (besides the
  sandbox "unable to verify current time" that disappears on CRAN)
- 148 tests passing, coverage 96.81%
- rhub v2 GitHub Actions workflow for multi-platform checks

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: queelius

.Rbuildignore

@@ -7,3 +7,4 @@
 ^pkgdown$
 ^\.github$
 ^CLAUDE\.md$
+^cran-comments\.md$

.github/workflows/rhub.yaml

@@ -0,0 +1,95 @@
+# R-hub's generic GitHub Actions workflow file. It's canonical location is at
+# https://github.com/r-hub/actions/blob/v1/workflows/rhub.yaml
+# You can update this file to a newer version using the rhub2 package:
+#
+# rhub::rhub_setup()
+#
+# It is unlikely that you need to modify this file manually.
+
+name: R-hub
+run-name: "${{ github.event.inputs.id }}: ${{ github.event.inputs.name || format('Manually run by {0}', github.triggering_actor) }}"
+
+on:
+  workflow_dispatch:
+    inputs:
+      config:
+        description: 'A comma separated list of R-hub platforms to use.'
+        type: string
+        default: 'linux,windows,macos'
+      name:
+        description: 'Run name. You can leave this empty now.'
+        type: string
+      id:
+        description: 'Unique ID. You can leave this empty now.'
+        type: string
+
+jobs:
+
+  setup:
+    runs-on: ubuntu-latest
+    outputs:
+      containers: ${{ steps.rhub-setup.outputs.containers }}
+      platforms: ${{ steps.rhub-setup.outputs.platforms }}
+
+    steps:
+    # NO NEED TO CHECKOUT HERE
+    - uses: r-hub/actions/setup@v1
+      with:
+        config: ${{ github.event.inputs.config }}
+      id: rhub-setup
+
+  linux-containers:
+    needs: setup
+    if: ${{ needs.setup.outputs.containers != '[]' }}
+    runs-on: ubuntu-latest
+    name: ${{ matrix.config.label }}
+    strategy:
+      fail-fast: false
+      matrix:
+        config: ${{ fromJson(needs.setup.outputs.containers) }}
+    container:
+      image: ${{ matrix.config.container }}
+
+    steps:
+      - uses: r-hub/actions/checkout@v1
+      - uses: r-hub/actions/platform-info@v1
+        with:
+          token: ${{ secrets.RHUB_TOKEN }}
+          job-config: ${{ matrix.config.job-config }}
+      - uses: r-hub/actions/setup-deps@v1
+        with:
+          token: ${{ secrets.RHUB_TOKEN }}
+          job-config: ${{ matrix.config.job-config }}
+      - uses: r-hub/actions/run-check@v1
+        with:
+          token: ${{ secrets.RHUB_TOKEN }}
+          job-config: ${{ matrix.config.job-config }}
+
+  other-platforms:
+    needs: setup
+    if: ${{ needs.setup.outputs.platforms != '[]' }}
+    runs-on: ${{ matrix.config.os }}
+    name: ${{ matrix.config.label }}
+    strategy:
+      fail-fast: false
+      matrix:
+        config: ${{ fromJson(needs.setup.outputs.platforms) }}
+
+    steps:
+      - uses: r-hub/actions/checkout@v1
+      - uses: r-hub/actions/setup-r@v1
+        with:
+          job-config: ${{ matrix.config.job-config }}
+          token: ${{ secrets.RHUB_TOKEN }}
+      - uses: r-hub/actions/platform-info@v1
+        with:
+          token: ${{ secrets.RHUB_TOKEN }}
+          job-config: ${{ matrix.config.job-config }}
+      - uses: r-hub/actions/setup-deps@v1
+        with:
+          job-config: ${{ matrix.config.job-config }}
+          token: ${{ secrets.RHUB_TOKEN }}
+      - uses: r-hub/actions/run-check@v1
+        with:
+          job-config: ${{ matrix.config.job-config }}
+          token: ${{ secrets.RHUB_TOKEN }}

DESCRIPTION

@@ -22,12 +22,14 @@ Imports:
     flexhaz,
     algebraic.dist,
     likelihood.model,
+    maskedcauses,
     generics,
     numDeriv,
     stats
 Suggests:
     testthat (>= 3.0.0),
-    maskedcauses,
+    algebraic.mle,
+    hypothesize,
     knitr,
     rmarkdown
 VignetteBuilder: knitr

NAMESPACE

@@ -37,7 +37,6 @@ export(sample_components)
 export(sampler)
 export(score)
 export(surv)
-importFrom(algebraic.dist,cdf)
 importFrom(algebraic.dist,hazard)
 importFrom(algebraic.dist,params)
 importFrom(algebraic.dist,sampler)
@@ -54,6 +53,8 @@ importFrom(likelihood.model,hess_loglik)
 importFrom(likelihood.model,loglik)
 importFrom(likelihood.model,rdata)
 importFrom(likelihood.model,score)
+importFrom(maskedcauses,cause_probability)
+importFrom(maskedcauses,conditional_cause_probability)
 importFrom(numDeriv,grad)
 importFrom(numDeriv,hessian)
 importFrom(serieshaz,component)

NEWS.md

@@ -1,10 +1,34 @@
 # maskedhaz 0.1.0
 
-* Initial release
-* `dfr_series_md()` constructor for masked-cause likelihood models
-* Log-likelihood supporting exact, right, left, and interval censoring
-* Score and Hessian via `numDeriv`
-* MLE fitting via `optim` returning `fisher_mle` objects
-* Data generation with configurable censoring and masking
-* Conditional and marginal cause-of-failure probabilities
-* Cross-validated against `maskedcauses` for exponential components
+Initial CRAN release.
+
+## Features
+
+* `dfr_series_md()` constructor builds a masked-cause likelihood model for a
+  series system whose components are arbitrary `dfr_dist` objects from the
+  `flexhaz` and `serieshaz` packages. The resulting model implements the
+  `series_md` protocol defined in `maskedcauses`.
+* Full support for four observation types via the `omega` column:
+  `"exact"`, `"right"`, `"left"`, `"interval"`. Left- and interval-censored
+  contributions use `stats::integrate()`; exact and right-censored rows use
+  vectorised closed-form expressions.
+* `loglik()`, `score()`, `hess_loglik()`, `fit()`, and `rdata()` methods
+  that dispatch through the `likelihood.model` generics. `fit()` returns a
+  `fisher_mle` object, which realises the `mle_fit` and `algebraic.dist`
+  interfaces, so standard MLE diagnostics (`coef`, `vcov`, `confint`, `se`,
+  `bias`, `observed_fim`, `as_dist`, `sampler`, `expectation`) all work
+  uniformly.
+* Methods for the `maskedcauses` domain generics
+  `conditional_cause_probability()` and `cause_probability()`.
+* Cross-validated against the closed-form exponential-series likelihood
+  from `maskedcauses` to confirm the numerical integration path matches
+  analytical results to integrator tolerance.
+
+## Vignettes
+
+* `maskedhaz` (overview): protocol, component, and MLE-result stacks;
+  quick tour from construction to diagnostics.
+* `custom-components`: mixed-distribution series with Weibull, exponential,
+  Gompertz, and log-logistic components.
+* `censoring-and-masking`: the four observation types with worked examples
+  and cross-validation against `maskedcauses`.

R/dfr_series_md.R

@@ -124,6 +124,12 @@ dfr_series_md <- function(series = NULL, components = NULL,
 #'
 #' @param x Object to test.
 #' @return Logical scalar.
+#' @examples
+#' model <- dfr_series_md(components = list(
+#'   dfr_exponential(0.1), dfr_exponential(0.2)
+#' ))
+#' is_dfr_series_md(model)    # TRUE
+#' is_dfr_series_md(42)       # FALSE
 #' @export
 is_dfr_series_md <- function(x) {
   inherits(x, "dfr_series_md")
@@ -135,21 +141,23 @@ is_dfr_series_md <- function(x) {
 #' @param x A \code{dfr_series_md} object.
 #' @param ... Additional arguments (unused).
 #' @return Invisibly returns \code{x}.
+#' @examples
+#' model <- dfr_series_md(components = list(
+#'   dfr_weibull(shape = 2, scale = 100),
+#'   dfr_exponential(0.05)
+#' ))
+#' print(model)
 #' @export
 print.dfr_series_md <- function(x, ...) {
-  m <- x$series$m
+  series <- x$series
+  m <- series$m
   cat(sprintf("Masked-cause likelihood model (%d-component series)\n", m))
   for (j in seq_len(m)) {
-    np <- x$series$n_par[j]
-    par_j <- if (!is.null(x$series$par)) {
-      x$series$par[x$series$layout[[j]]]
-    }
-    par_str <- if (!is.null(par_j)) {
+    par_j <- if (is.null(series$par)) NULL else series$par[series$layout[[j]]]
+    par_str <- if (is.null(par_j)) "unknown" else
       paste(format(par_j, digits = 4), collapse = ", ")
-    } else {
-      "unknown"
-    }
-    cat(sprintf("  Component %d: %d param(s) [%s]\n", j, np, par_str))
+    cat(sprintf("  Component %d: %d param(s) [%s]\n",
+                j, series$n_par[j], par_str))
   }
   cat("Data columns:", x$lifetime, "(lifetime),",
       x$omega, "(type),", x$candset, "* (candidates)\n")

R/fit.R

@@ -11,9 +11,23 @@
 #'
 #' @details
 #' Uses \code{\link[stats]{optim}} to maximize the log-likelihood. The score
-#' function (gradient) is provided for gradient-based methods. The Hessian at
-#' the MLE is computed for variance-covariance estimation.
+#' function (gradient) is computed from the same \code{\link{loglik}} closure
+#' via \code{\link[numDeriv]{grad}}, and the Hessian at the MLE via
+#' \code{\link[numDeriv]{hessian}}. One-parameter problems auto-upgrade from
+#' Nelder-Mead to BFGS with a warning, because Nelder-Mead is unreliable in
+#' one dimension.
 #'
+#' @examples
+#' \donttest{
+#' model <- dfr_series_md(components = list(
+#'   dfr_exponential(0.1), dfr_exponential(0.2)
+#' ))
+#' set.seed(1)
+#' df <- rdata(model)(theta = c(0.1, 0.2), n = 200, tau = 10, p = 0)
+#' solver <- fit(model)
+#' result <- solver(df, par = c(0.15, 0.15))
+#' coef(result)
+#' }
 #' @importFrom generics fit
 #' @importFrom likelihood.model fisher_mle
 #' @importFrom stats optim
@@ -22,38 +36,37 @@
 #' @export
 fit.dfr_series_md <- function(object, ...) {
   ll_fn <- loglik(object)
-  s_fn <- score(object)
-  H_fn <- hess_loglik(object)
 
   function(df, par,
            method = c("Nelder-Mead", "BFGS", "SANN", "CG",
                        "L-BFGS-B", "Brent"),
            ..., control = list()) {
     stopifnot(!is.null(par))
-    defaults <- list(fnscale = -1)
-    control <- modifyList(defaults, control)
+    user_picked_method <- !missing(method)
     method <- match.arg(method)
+    control <- modifyList(list(fnscale = -1), control)
 
-    if (length(par) == 1 && method == "Nelder-Mead")
+    if (length(par) == 1 && method == "Nelder-Mead") {
+      if (user_picked_method)
+        warning("Nelder-Mead is unreliable for 1-parameter problems; ",
+                "switching to BFGS.")
       method <- "BFGS"
+    }
+
+    obj <- function(p) ll_fn(df, p)
+    gr  <- function(p) numDeriv::grad(obj, p)
 
     sol <- optim(
-      par = par,
-      fn = function(p) ll_fn(df, p),
-      gr = if (method == "SANN") NULL else function(p) s_fn(df, p),
-      hessian = FALSE,
-      method = method,
-      control = control
+      par = par, fn = obj,
+      gr = if (method == "SANN") NULL else gr,
+      hessian = FALSE, method = method, control = control
     )
 
-    hessian <- H_fn(df, sol$par)
-    score_at_mle <- s_fn(df, sol$par)
-
     fisher_mle(
       par = sol$par,
       loglik_val = sol$value,
-      hessian = hessian,
-      score_val = score_at_mle,
+      hessian = numDeriv::hessian(obj, sol$par),
+      score_val = numDeriv::grad(obj, sol$par),
       nobs = nrow(df),
       converged = (sol$convergence == 0)
     )