health.gestational-age Unreviewed

pub fn gestational_age(lmp_date: &str, on_date: &str, cycle_length_days: i64) -> GestationalAge

/// Gestational age as weeks+days, and the estimated due date.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct GestationalAge {
    /// completed weeks
    pub weeks: i64,
    /// days beyond the completed weeks, 0 to 6
    pub days: i64,
    /// gestational age in days
    pub total_days: i64,
    /// estimated due date, 40+0 weeks
    pub due_date: String,
}

fune!(health.gestational-age@^1);  // then call gestational_age(…)

use super::funejson::Value;  ← the fune runtime: the JSON value the test vectors use; fune build keeps it only where a signature takes one
use super::dates_add_days::{add_days, days_between, parse_iso_date};  ← from dates.add-days ^1.0.0 · built alongside by fune

/// Naegele's rule: 280 days (40+0 weeks) from the LMP for a 28-day cycle.
const TERM_DAYS: i64 = 280;
/// 44+0 weeks: beyond this the dates are almost certainly wrong.
const MAX_DAYS: i64 = 308;

/// Gestational age and estimated due date from the last menstrual period. A
/// cycle longer or shorter than 28 days moves ovulation, so both are shifted by
/// the difference, as the NHS due date calculator does.
///
/// # Panics
/// Panics on a cycle length outside 20..=44, a malformed date, or a
/// gestational age below zero or above 44+0 weeks.
pub fn gestational_age(lmp_date: &str, on_date: &str, cycle_length_days: i64) -> GestationalAge {
    if !(20..=44).contains(&cycle_length_days) {
        panic!("cycleLengthDays must be a whole number from 20 to 44, received {}", cycle_length_days);
    }
    parse_iso_date(lmp_date);
    parse_iso_date(on_date);
    let shift = cycle_length_days - 28;
    let total_days = days_between(lmp_date, on_date) - shift;
    if total_days < 0 {
        panic!("onDate {} is before the adjusted start of pregnancy", on_date);
    }
    if total_days > MAX_DAYS {
        panic!("gestational age of {} days is more than 44+0 weeks: check the dates", total_days);
    }
    GestationalAge {
        weeks: total_days / 7,
        days: total_days % 7,
        total_days,
        due_date: add_days(lmp_date, TERM_DAYS + shift),
    }
}

pub fn gestational_age_to_value(age: &GestationalAge) -> Value {
    Value::obj(vec![
        ("weeks", Value::Int(age.weeks)),
        ("days", Value::Int(age.days)),
        ("totalDays", Value::Int(age.total_days)),
        ("dueDate", Value::str(&age.due_date)),
    ])
}

fn date_arg(value: &Value) -> &str {
    match value {
        Value::Str(s) => s.as_str(),
        _ => panic!("{:?} is not an ISO date (YYYY-MM-DD)", value),
    }
}

pub fn fune_vector(args: &[Value]) -> Value {
    // Refuse what the typed signature cannot hold, with the wording TypeScript
    // and Python use, rather than let the conversion below quietly change it.
    let cycle = match args[2] {
        Value::Int(i) => i,
        _ => panic!("cycleLengthDays must be a whole number from 20 to 44, received {:?}", args[2]),
    };
    gestational_age_to_value(&gestational_age(date_arg(&args[0]), date_arg(&args[1]), cycle))
}

Install

fune build

With that line in your source, in a Rust project (language rust in fune.project), fune build resolves it and its 1 dependency, pins them in fune.lock, downloads only the Rust package of each, and builds the code above into your project’s .fune/build, one readable file per capability with a header linking back here. A crate’s build.rs runs it before every compile. Or pin a range in fune.project and build in one step:

fune add health.gestational-age

The manifest, vectors and README with only the Rust implementation. Install it without the registry with fune add ./health.gestational-age-1.0.1-rust.fune, or fetch it from a terminal with fune pull health.gestational-age@1.0.1:rust.

The whole function, every language, is one file too: health.gestational-age-1.0.1.fune, 16,397 bytes, sha256 3a8338b49fe1e3953ced98e28cc50e831e4fb21b826a63e9a294e9106686c903. It installs into a project of any language.

// fune: before health.gestational-age

// fune: after health.gestational-age

// fune: replace dates.add-days in health.gestational-age

// fune: step health.gestational-age after <n|label>

More from the author

**The rule.** Naegele's rule puts the due date 280 days (40+0 weeks) after the LMP, which assumes a 28-day cycle with ovulation on day 14. A longer or shorter cycle moves ovulation, so both the due date and the gestational age are shifted by the difference from 28 days:

dueDate = LMP + 280 + (cycleLengthDays - 28) totalDays = (onDate - LMP) - (cycleLengthDays - 28) weeks = totalDays div 7, days = totalDays mod 7

With a 35-day cycle the due date is a week later and the pregnancy is a week less advanced on any date. Pass 28 for the unadjusted rule. This is exactly what the NHS due date calculator does, and its published answers are among the vectors (LMP 15 March 2026: due 20 December 2026 on a 28-day cycle, 27 December on 35 days, 12 December on 20 days, 5 January 2027 on 44 days).

**Limits, and why they are errors.**

- `cycleLengthDays` must be a whole number from 20 to 44, the range the NHS calculator accepts. - A measuring date before the adjusted start of pregnancy (the LMP plus the cycle shift) is an error, not a negative age: with a 35-day cycle, three days after the LMP is not yet 0+0. - A gestational age above 44+0 weeks (308 days) is an error asking for the dates to be checked. Pregnancy normally lasts 37 to 42 weeks from the LMP; 44 weeks is a guard rail against a wrong year or a transposed date, not a clinical threshold, and a clinician should confirm it.

Dates are ISO `YYYY-MM-DD`; the measuring date is always an argument, never today's date. Leap days are counted like any other day.

## Sources

- NHS, "Due date calculator" (nhs.uk): takes the first day of the last period and a cycle length that "must be between 20 and 44 days"; pregnancy "normally lasts from 37 weeks to 42 weeks from the first day of your last period". Its outputs for the dates above were checked on 23 September 2026. https://www.nhs.uk/pregnancy/finding-out/due-date-calculator/ - NICE guideline NG201, "Antenatal care" (2021), recommendation 1.2.14: offer an ultrasound scan between 11+2 and 14+1 weeks to determine gestational age. https://www.nice.org.uk/guidance/ng201/chapter/Recommendations

## Before you rely on this

**Not professional advice.** This capability calculates health figures from published rules. It is a software component for developers, not medical advice. Rules change and every rate here has an effective date. Check that the dates cover your case. Verify results against the official sources listed above, and have a midwife or obstetrician review how you use it, before anyone relies on the output. Provided "as is" under its licence, without warranty.

**Not a medical device.** It is not intended to diagnose, treat or support clinical decisions about any individual. Anyone building it into clinical software is responsible for that software's regulatory status, and must validate it under their own clinical governance.

**Not for clinical use; regulatory review pending.** Whether publishing this capability makes it a medical device is under regulatory review. Until that is settled it is a developer library only.

**Unreviewed.** This capability's implementations agree in every language and pass its published test vectors, which were worked out from the official sources cited. But no qualified midwife or obstetrician has yet checked those vectors, or confirmed that the capability covers the cases it claims. Treat it as a draft. Do not use it for real people, money or decisions without your own expert review. Once a qualified reviewer signs off, this notice is replaced with their name, qualification and the date. Each new version needs fresh sign-off.

1.0.1 marks it unreviewed (not for clinical use; regulatory review pending). The code and the tests are unchanged.

Files