construction-gantt 0.1.0

package/dist/index.js

@@ -0,0 +1,3461 @@
+function __insertCSS(code) {
+  if (!code || typeof document == 'undefined') return
+  let head = document.head || document.getElementsByTagName('head')[0]
+  let style = document.createElement('style')
+  style.type = 'text/css'
+  head.appendChild(style)
+  ;style.styleSheet ? (style.styleSheet.cssText = code) : style.appendChild(document.createTextNode(code))
+}
+
+import { useRef, useReducer, useMemo, forwardRef, useImperativeHandle } from 'react';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { Gantt as Gantt$1 } from '@svar-ui/react-gantt';
+import '@svar-ui/react-gantt/style.css';
+import { XMLParser, XMLBuilder } from 'fast-xml-parser';
+
+// Analysis helpers — consumer-facing summary queries over a scheduled
+// Project. Useful for dashboards, management-focus views, and CI-style
+// programme-health checks.
+//
+// Assumes the project has been through `schedule()` (tasks have
+// `computed` populated). If not, the helpers return safe defaults
+// rather than throwing.
+/**
+ * Return the critical-path leaf tasks (summary tasks excluded), ordered
+ * by `earlyStart` ascending. A construction PM reading this list is
+ * looking at "the tasks that, if any of them slip, the contract finish
+ * slips."
+ *
+ * The list mirrors what `task.computed.isCritical` says — i.e., includes
+ * tasks with negative total slack (already-late tasks).
+ */ function getCriticalPath(project) {
+    const leaves = project.tasks.filter((t)=>t.type !== 'summary');
+    const critical = leaves.filter((t)=>t.computed?.isCritical === true);
+    return critical.slice().sort((a, b)=>{
+        const aTime = a.computed?.earlyStart.getTime() ?? 0;
+        const bTime = b.computed?.earlyStart.getTime() ?? 0;
+        return aTime - bTime;
+    });
+}
+/**
+ * Summary statistics over a scheduled Project. Useful for status
+ * dashboards, programme-health badges in management views, and CI
+ * checks that flag "did the critical path grow this commit?".
+ */ function getProjectStats(project) {
+    const leaves = project.tasks.filter((t)=>t.type !== 'summary');
+    if (leaves.length === 0) {
+        return {
+            totalTasks: 0,
+            criticalTasks: 0,
+            lateTasks: 0,
+            weightedProgress: 0
+        };
+    }
+    let criticalTasks = 0;
+    let lateTasks = 0;
+    let projectFinishMs = Number.NEGATIVE_INFINITY;
+    let totalDuration = 0;
+    let progressDurationProduct = 0;
+    for (const t of leaves){
+        if (t.computed?.isCritical) criticalTasks++;
+        if ((t.computed?.totalSlack ?? 0) < 0) lateTasks++;
+        const finish = t.computed?.earlyFinish?.getTime() ?? t.end.getTime();
+        if (finish > projectFinishMs) projectFinishMs = finish;
+        totalDuration += t.duration;
+        progressDurationProduct += t.duration * t.progress;
+    }
+    const weightedProgress = totalDuration > 0 ? progressDurationProduct / totalDuration : 0;
+    return {
+        totalTasks: leaves.length,
+        criticalTasks,
+        lateTasks,
+        projectFinish: Number.isFinite(projectFinishMs) ? new Date(projectFinishMs) : undefined,
+        weightedProgress
+    };
+}
+
+function isWorkingDay(date, calendar) {
+    return getIntervalsForDay(date, calendar).length > 0;
+}
+function getDayWorkingMinutes(date, calendar) {
+    return getIntervalsForDay(date, calendar).reduce((sum, iv)=>sum + (iv.endMinutes - iv.startMinutes), 0);
+}
+/**
+ * Add `minutes` of working time to `start`, skipping non-working time
+ * (weekends, holidays, partial-day shift gaps). The result is the wall-clock
+ * Date exactly `minutes` working-time-minutes after `start`.
+ *
+ * If `start` falls in a non-working moment (weekend, after-hours, lunch
+ * break), the working-time clock begins from the next working interval.
+ *
+ * Note: not DST-aware. Working hours are wall-clock; cross-DST scheduling
+ * is approximate. Real DST handling is a future enhancement.
+ */ function addWorkingMinutes(start, minutes, calendar) {
+    if (minutes <= 0) return new Date(start);
+    let current = new Date(start);
+    let remaining = minutes;
+    while(remaining > 0){
+        const interval = findNextWorkingInterval(current, calendar);
+        if (!interval) {
+            throw new Error('Calendar has no working time within ~1 year after the given date');
+        }
+        if (current < interval.start) current = new Date(interval.start);
+        const availableMinutes = (interval.end.getTime() - current.getTime()) / 60_000;
+        if (remaining <= availableMinutes) {
+            return new Date(current.getTime() + remaining * 60_000);
+        }
+        remaining -= availableMinutes;
+        current = new Date(interval.end);
+    }
+    return current;
+}
+/**
+ * Subtract `minutes` of working time from `end`, walking backward through
+ * working intervals. Backward-pass mirror of {@link addWorkingMinutes}.
+ *
+ * If `end` falls in a non-working moment, the clock begins from the end of
+ * the most recent working interval.
+ */ function subtractWorkingMinutes(end, minutes, calendar) {
+    if (minutes <= 0) return new Date(end);
+    let current = new Date(end);
+    let remaining = minutes;
+    while(remaining > 0){
+        const interval = findPreviousWorkingInterval(current, calendar);
+        if (!interval) {
+            throw new Error('Calendar has no working time within ~1 year before the given date');
+        }
+        if (current > interval.end) current = new Date(interval.end);
+        const availableMinutes = (current.getTime() - interval.start.getTime()) / 60_000;
+        if (remaining <= availableMinutes) {
+            return new Date(current.getTime() - remaining * 60_000);
+        }
+        remaining -= availableMinutes;
+        current = new Date(interval.start);
+    }
+    return current;
+}
+/**
+ * Return the next working moment at or after `date`. If `date` already falls
+ * inside a working interval, returns it unchanged. If it falls in non-working
+ * time (weekend, after-hours, lunch break, holiday), returns the start of the
+ * next working interval.
+ */ function snapToNextWorkingMoment(date, calendar) {
+    const interval = findNextWorkingInterval(date, calendar);
+    if (!interval) {
+        throw new Error('Calendar has no working time within ~1 year after the given date');
+    }
+    return date < interval.start ? new Date(interval.start) : new Date(date);
+}
+/**
+ * Return the previous working moment at or before `date`. Mirror of
+ * {@link snapToNextWorkingMoment} for backward-pass scheduling.
+ */ function snapToPreviousWorkingMoment(date, calendar) {
+    const interval = findPreviousWorkingInterval(date, calendar);
+    if (!interval) {
+        throw new Error('Calendar has no working time within ~1 year before the given date');
+    }
+    return date > interval.end ? new Date(interval.end) : new Date(date);
+}
+/**
+ * Working-minute distance from `a` to `b`. Positive if `a` is earlier than
+ * `b`, negative if `a` is later. Used to compute slack (lateStart - earlyStart
+ * in working time).
+ */ function workingMinutesBetween(a, b, calendar) {
+    if (a.getTime() === b.getTime()) return 0;
+    const reverse = a > b;
+    const start = reverse ? b : a;
+    const end = reverse ? a : b;
+    let current = new Date(start);
+    let total = 0;
+    while(current < end){
+        const interval = findNextWorkingInterval(current, calendar);
+        if (!interval) break;
+        if (current < interval.start) current = new Date(interval.start);
+        if (current >= end) break;
+        if (interval.end >= end) {
+            total += (end.getTime() - current.getTime()) / 60_000;
+            break;
+        }
+        total += (interval.end.getTime() - current.getTime()) / 60_000;
+        current = new Date(interval.end);
+    }
+    return reverse ? -total : total;
+}
+/**
+ * Find the earliest working interval whose end is strictly after `date`.
+ * Walks forward up to ~1 year before giving up.
+ */ function findNextWorkingInterval(date, calendar) {
+    const msPerDay = 24 * 60 * 60 * 1000;
+    let day = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+    for(let i = 0; i < 366; i++){
+        const intervals = getIntervalsForDay(day, calendar);
+        for (const iv of intervals){
+            const intervalStart = new Date(day.getFullYear(), day.getMonth(), day.getDate(), 0, iv.startMinutes);
+            const intervalEnd = new Date(day.getFullYear(), day.getMonth(), day.getDate(), 0, iv.endMinutes);
+            if (intervalEnd > date) {
+                return {
+                    start: intervalStart,
+                    end: intervalEnd
+                };
+            }
+        }
+        day = new Date(day.getTime() + msPerDay);
+    }
+    return null;
+}
+/**
+ * Find the latest working interval whose start is strictly before `date`.
+ * Walks backward up to ~1 year before giving up.
+ */ function findPreviousWorkingInterval(date, calendar) {
+    const msPerDay = 24 * 60 * 60 * 1000;
+    let day = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+    for(let i = 0; i < 366; i++){
+        const intervals = getIntervalsForDay(day, calendar);
+        for(let j = intervals.length - 1; j >= 0; j--){
+            const iv = intervals[j];
+            if (!iv) continue;
+            const intervalStart = new Date(day.getFullYear(), day.getMonth(), day.getDate(), 0, iv.startMinutes);
+            const intervalEnd = new Date(day.getFullYear(), day.getMonth(), day.getDate(), 0, iv.endMinutes);
+            if (intervalStart < date) {
+                return {
+                    start: intervalStart,
+                    end: intervalEnd
+                };
+            }
+        }
+        day = new Date(day.getTime() - msPerDay);
+    }
+    return null;
+}
+function getIntervalsForDay(date, calendar) {
+    const exception = findException(date, calendar);
+    if (exception) {
+        return exception.isWorking ? exception.intervals ?? [] : [];
+    }
+    return calendar.workWeek[date.getDay()] ?? [];
+}
+function findException(date, calendar) {
+    return calendar.exceptions.find((ex)=>isSameCalendarDay(ex.date, date));
+}
+function isSameCalendarDay(a, b) {
+    return a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth() && a.getDate() === b.getDate();
+}
+
+// Baseline capture + variance API.
+//
+// Baselines snapshot the schedule at a point in time so we can compare the
+// live programme against it later. Construction PMs need multiple
+// baselines for variation-claim delay analysis under NZS 3910 / AS 4000
+// (per ADR-003). We match MS Project's data model: up to 11 baselines
+// (BaselineIndex 0..10) per project.
+/**
+ * Snapshot the current schedule (task starts, ends, durations) as a baseline
+ * at the given index. Returns a new Project with the baseline added; the
+ * input is not mutated. If a baseline already exists at this index, it is
+ * replaced (matches MS Project "Save Baseline" behavior).
+ */ function captureBaseline(project, index, options) {
+    const tasks = new Map();
+    for (const task of project.tasks){
+        tasks.set(task.id, {
+            start: new Date(task.start),
+            end: new Date(task.end),
+            duration: task.duration
+        });
+    }
+    const baseline = {
+        index,
+        name: options?.name,
+        capturedAt: options?.capturedAt ? new Date(options.capturedAt) : new Date(),
+        tasks
+    };
+    const existing = project.baselines.findIndex((b)=>b.index === index);
+    const newBaselines = [
+        ...project.baselines
+    ];
+    if (existing >= 0) {
+        newBaselines[existing] = baseline;
+    } else {
+        newBaselines.push(baseline);
+    }
+    return {
+        ...project,
+        baselines: newBaselines
+    };
+}
+/**
+ * Compute baseline variance for every task in `project`. Returns a Map
+ * keyed by TaskId. Tasks not present in the named baseline are omitted
+ * from the returned map.
+ *
+ * `baselineIndex` selects the baseline on `project.baselines`. If the
+ * project has no baseline at that index, returns an empty Map (caller
+ * decides whether to treat this as a soft error or hard error).
+ *
+ * The calendar used for working-time variance arithmetic is the project
+ * default calendar, looked up by `project.defaultCalendarId`. If that
+ * lookup fails, throw an Error (consistent with `schedule()`'s behavior
+ * on a missing default calendar).
+ */ function getTaskBaselineVarianceAll(project, baselineIndex) {
+    const baseline = project.baselines.find((b)=>b.index === baselineIndex);
+    if (!baseline) return new Map();
+    const calendar = project.calendars.find((c)=>c.id === project.defaultCalendarId);
+    if (!calendar) {
+        throw new Error(`Default calendar '${project.defaultCalendarId}' not found. Cannot compute baseline variance.`);
+    }
+    const result = new Map();
+    for (const task of project.tasks){
+        const variance = getTaskBaselineVariance(task, baseline, calendar);
+        if (variance !== undefined) {
+            result.set(task.id, variance);
+        }
+    }
+    return result;
+}
+/**
+ * Compute working-time variance between a task's current dates and its
+ * snapshot in a baseline. Returns undefined if the task isn't in the
+ * baseline (added after the baseline was captured).
+ */ function getTaskBaselineVariance(task, baseline, calendar) {
+    const snap = baseline.tasks.get(task.id);
+    if (!snap) return undefined;
+    return {
+        startVariance: workingMinutesBetween(snap.start, task.start, calendar),
+        finishVariance: workingMinutesBetween(snap.end, task.end, calendar),
+        durationVariance: task.duration - snap.duration
+    };
+}
+
+/**
+ * Canterbury Anniversary Day observance dates. Unlike Matariki, this
+ * holiday is set annually by the Canterbury A&P Association — the Friday
+ * of Show Week — and doesn't reduce to a closed-form rule.
+ *
+ * Source: https://www.employment.govt.nz/leave-and-holidays/public-holidays/public-holidays-and-anniversary-dates/
+ *
+ * The governing rule (from date-holidays NZ.yaml and employment.govt.nz):
+ * "the Friday after the 2nd Tuesday in November" (Christchurch Show Day).
+ * This rule was used to derive and verify every entry below. 2026 was
+ * additionally confirmed directly from employment.govt.nz. 2027–2028 are
+ * rule-derived only (not yet published by employment.govt.nz at time of
+ * implementation).
+ *
+ * Every entry verified against the official listing on implementation.
+ * A typo or transcription error produces a silent wrong-date bug for
+ * every Canterbury-region consumer in the affected year.
+ *
+ * Years past `CANTERBURY_RANGE.maxYear` are unpublished and produce a
+ * specific error from the public API rather than a fabricated date.
+ */ // month is 1-indexed for readability against employment.govt.nz; converted
+// to JS's 0-indexed month when constructing the Date.
+const RAW$1 = [
+    [
+        2022,
+        11,
+        11
+    ],
+    [
+        2023,
+        11,
+        17
+    ],
+    [
+        2024,
+        11,
+        15
+    ],
+    [
+        2025,
+        11,
+        14
+    ],
+    [
+        2026,
+        11,
+        13
+    ],
+    [
+        2027,
+        11,
+        12
+    ],
+    [
+        2028,
+        11,
+        17
+    ]
+];
+const CANTERBURY_DATES = Object.freeze(Object.fromEntries(RAW$1.map(([y, m, d])=>[
+        y,
+        new Date(y, m - 1, d)
+    ])));
+const years = RAW$1.map(([y])=>y);
+const CANTERBURY_RANGE = Object.freeze({
+    minYear: Math.min(...years),
+    maxYear: Math.max(...years)
+});
+
+/**
+ * Returns the Date for Easter Sunday in the given year, using the
+ * Anonymous Gregorian algorithm (Meeus/Jones/Butcher). Pure-integer
+ * arithmetic; valid for any year in the Gregorian calendar (1583+).
+ *
+ * Reference: Astronomical Algorithms (Meeus, 1991), §8.
+ */ function computeEasterSunday(year) {
+    const a = year % 19;
+    const b = Math.floor(year / 100);
+    const c = year % 100;
+    const d = Math.floor(b / 4);
+    const e = b % 4;
+    const f = Math.floor((b + 8) / 25);
+    const g = Math.floor((b - f + 1) / 3);
+    const h = (19 * a + b - d - g + 15) % 30;
+    const i = Math.floor(c / 4);
+    const k = c % 4;
+    const l = (32 + 2 * e + 2 * i - h - k) % 7;
+    const m = Math.floor((a + 11 * h + 22 * l) / 451);
+    const monthZeroIndexed = Math.floor((h + l - 7 * m + 114) / 31) - 1; // March=2, April=3
+    const day = (h + l - 7 * m + 114) % 31 + 1;
+    return new Date(year, monthZeroIndexed, day);
+}
+
+/**
+ * Tiny shared date-arithmetic helpers used across the calendars module.
+ * Kept module-private (not re-exported from the package entry).
+ */ function dayOfWeek(date) {
+    // 0 = Sun … 6 = Sat
+    return date.getDay();
+}
+function addDays(date, days) {
+    return new Date(date.getFullYear(), date.getMonth(), date.getDate() + days);
+}
+
+function mondayiseSingle(date) {
+    const dow = dayOfWeek(date);
+    if (dow === 6) return addDays(date, 2); // Sat → Mon
+    if (dow === 0) return addDays(date, 1); // Sun → Mon
+    return new Date(date);
+}
+/**
+ * Apply the pair rule to a [first, second] pair where `second` is exactly
+ * one calendar day after `first` (Jan 1 / 2 Jan or Dec 25 / 26). Returns
+ * the observed [first, second] pair.
+ */ function mondayisePair(first, second) {
+    const firstDow = dayOfWeek(first);
+    // First on Sat → first observed Mon (+2), second observed Tue (+2)
+    if (firstDow === 6) {
+        return [
+            addDays(first, 2),
+            addDays(second, 2)
+        ];
+    }
+    // First on Sun → first observed Mon (+1), second observed Tue (+1).
+    // (Second's natural day is Mon, which is now taken by first; bump to Tue.)
+    if (firstDow === 0) {
+        return [
+            addDays(first, 1),
+            addDays(second, 1)
+        ];
+    }
+    // First on Fri → first stays Fri; second (originally Sat) shifts to Mon (+2).
+    if (firstDow === 5) {
+        return [
+            new Date(first),
+            addDays(second, 2)
+        ];
+    }
+    // First on Mon-Thu → no shift; second is naturally Tue–Fri.
+    return [
+        new Date(first),
+        new Date(second)
+    ];
+}
+
+/**
+ * The N-th Monday of the given month. `month` is zero-indexed (Jan = 0).
+ * `n` is 1-indexed (1 = first Monday).
+ */ function nthMondayOfMonth(year, month, n) {
+    const firstOfMonth = new Date(year, month, 1);
+    const firstDow = dayOfWeek(firstOfMonth);
+    // Days to add to reach the first Monday of the month.
+    // (8 - dow) % 7: Sun(0)→1, Mon(1)→0, Tue(2)→6, Wed(3)→5, Thu(4)→4, Fri(5)→3, Sat(6)→2
+    const offsetToFirstMonday = (8 - firstDow) % 7;
+    return new Date(year, month, 1 + offsetToFirstMonday + (n - 1) * 7);
+}
+/**
+ * The first Monday strictly after the given date.
+ */ function firstMondayAfter(date) {
+    const dow = dayOfWeek(date);
+    // Days from `date` to the next Monday strictly after it.
+    // Sun(0): +1, Mon(1): +7, Tue(2): +6, Wed(3): +5, Thu(4): +4, Fri(5): +3, Sat(6): +2
+    const delta = dow === 0 ? 1 : (8 - dow) % 7 || 7;
+    return addDays(date, delta);
+}
+/**
+ * The Friday immediately before the given date. Used for Hawke's Bay
+ * (Friday before Labour Day).
+ */ function fridayBefore(date) {
+    const dow = dayOfWeek(date);
+    // Days BACK from `date` to the most recent Friday strictly before it.
+    // Sun(0): -2, Mon(1): -3, Tue(2): -4, Wed(3): -5, Thu(4): -6, Fri(5): -7, Sat(6): -1
+    const delta = -((dow + 2) % 7 || 7);
+    return addDays(date, delta);
+}
+/**
+ * The Monday nearest the given calendar date. No tie-break logic needed:
+ * no day-of-week produces equidistant prev/next Monday — the function is
+ * well-defined for all 7 inputs.
+ *
+ * `month` is zero-indexed.
+ */ function nearestMondayTo(year, month, day) {
+    const target = new Date(year, month, day);
+    const dow = dayOfWeek(target);
+    if (dow === 1) return target; // Already Monday
+    // Distance to previous Monday: dow - 1 days back if dow ≥ 1 else 6.
+    // Distance to next Monday: 8 - dow if dow ≥ 1 else 1.
+    const distPrev = dow === 0 ? 6 : dow - 1;
+    const distNext = dow === 0 ? 1 : 8 - dow;
+    return distPrev <= distNext ? addDays(target, -distPrev) : addDays(target, distNext);
+}
+
+/**
+ * Matariki observance dates per the Te Kāhui o Matariki Public Holiday Act
+ * 2022, Schedule 1. Pre-announced for 30 years (2022–2052); the Act sets
+ * each date explicitly rather than via formula.
+ *
+ * Primary source: Te Kāhui o Matariki Public Holiday Act 2022, Schedule 1
+ *   https://www.legislation.govt.nz/act/public/2022/0014/latest/whole.html
+ *   (legislation.govt.nz returned HTTP 403 to WebFetch; cross-referenced via:)
+ *
+ * Verified sources used during implementation:
+ *   1. https://raw.githubusercontent.com/commenthol/date-holidays/master/data/countries/NZ.yaml
+ *      (date-holidays library, tracks official NZ public holiday data)
+ *   2. https://github.com/commenthol/date-holidays/blob/master/data/countries/NZ.yaml
+ *      (same data, HTML view — identical 31-entry list)
+ *   3. Wikipedia "Matariki" article (2022–2035 confirmed matching)
+ *   4. Local JS Date validation: all 31 entries confirmed as Friday, June/July
+ *
+ * Every entry was verified to be a Friday falling in June or July. A typo
+ * here is invisible to typecheck and rule-tests — it produces a silent
+ * wrong-date bug for every consumer in the affected year.
+ */ const MATARIKI_RANGE = {
+    minYear: 2022,
+    maxYear: 2052
+};
+// month is 1-indexed for readability against the Act text; converted to
+// JS's 0-indexed month when constructing the Date.
+const RAW = [
+    [
+        2022,
+        6,
+        24
+    ],
+    [
+        2023,
+        7,
+        14
+    ],
+    [
+        2024,
+        6,
+        28
+    ],
+    [
+        2025,
+        6,
+        20
+    ],
+    [
+        2026,
+        7,
+        10
+    ],
+    [
+        2027,
+        6,
+        25
+    ],
+    [
+        2028,
+        7,
+        14
+    ],
+    [
+        2029,
+        7,
+        6
+    ],
+    [
+        2030,
+        6,
+        21
+    ],
+    [
+        2031,
+        7,
+        11
+    ],
+    [
+        2032,
+        7,
+        2
+    ],
+    [
+        2033,
+        6,
+        24
+    ],
+    [
+        2034,
+        7,
+        7
+    ],
+    [
+        2035,
+        6,
+        29
+    ],
+    [
+        2036,
+        7,
+        18
+    ],
+    [
+        2037,
+        7,
+        10
+    ],
+    [
+        2038,
+        6,
+        25
+    ],
+    [
+        2039,
+        7,
+        15
+    ],
+    [
+        2040,
+        7,
+        6
+    ],
+    [
+        2041,
+        7,
+        19
+    ],
+    [
+        2042,
+        7,
+        11
+    ],
+    [
+        2043,
+        7,
+        3
+    ],
+    [
+        2044,
+        6,
+        24
+    ],
+    [
+        2045,
+        7,
+        7
+    ],
+    [
+        2046,
+        6,
+        29
+    ],
+    [
+        2047,
+        7,
+        19
+    ],
+    [
+        2048,
+        7,
+        3
+    ],
+    [
+        2049,
+        6,
+        25
+    ],
+    [
+        2050,
+        7,
+        15
+    ],
+    [
+        2051,
+        6,
+        30
+    ],
+    [
+        2052,
+        6,
+        21
+    ]
+];
+const MATARIKI_DATES = Object.freeze(Object.fromEntries(RAW.map(([y, m, d])=>[
+        y,
+        new Date(y, m - 1, d)
+    ])));
+
+// NZ public-holiday + regional-anniversary pre-seed for the working-time
+// calendar engine. Hybrid generation: pure-TS rules for the holidays whose
+// observed date reduces to a formula; small static tables for the ones
+// that don't (Matariki — set by Act; Canterbury Show Day — set annually).
+//
+// Range supported: 2022 (Matariki Act adoption) through 2052 (last year
+// the Act pre-announces). Calls outside that range throw RangeError.
+const MIN_YEAR = MATARIKI_RANGE.minYear; // 2022
+const MAX_YEAR = MATARIKI_RANGE.maxYear; // 2052
+const DEFAULT_INTERVAL = {
+    startMinutes: 8 * 60,
+    endMinutes: 17 * 60
+};
+const DEFAULT_WORK_WEEK = [
+    [],
+    [
+        DEFAULT_INTERVAL
+    ],
+    [
+        DEFAULT_INTERVAL
+    ],
+    [
+        DEFAULT_INTERVAL
+    ],
+    [
+        DEFAULT_INTERVAL
+    ],
+    [
+        DEFAULT_INTERVAL
+    ],
+    []
+];
+function nzPublicHolidays(years, region) {
+    const yearList = normaliseYears(years);
+    const all = [];
+    for (const year of yearList){
+        all.push(...nationalHolidays(year));
+        if (region) {
+            const regional = regionalAnniversary(year, region);
+            if (regional) all.push(regional);
+        }
+    }
+    return all.sort((a, b)=>a.date.getTime() - b.date.getTime());
+}
+function normaliseYears(input) {
+    const list = Array.isArray(input) ? [
+        ...new Set(input)
+    ] : [
+        input
+    ];
+    for (const y of list){
+        if (y < MIN_YEAR || y > MAX_YEAR) {
+            throw new RangeError(`nzPublicHolidays: year ${y} out of supported range ${MIN_YEAR}-${MAX_YEAR}. ` + `Range is bounded by the Te Kāhui o Matariki Public Holiday Act 2022 Schedule 1.`);
+        }
+    }
+    return list.sort((a, b)=>a - b);
+}
+function nationalHolidays(year) {
+    const out = [];
+    // New Year + 2 January (pair rule)
+    const [ny, jan2] = mondayisePair(new Date(year, 0, 1), new Date(year, 0, 2));
+    out.push(makeException(ny, "New Year's Day", new Date(year, 0, 1)));
+    out.push(makeException(jan2, '2 January', new Date(year, 0, 2)));
+    // Waitangi Day (single-day mondayisation)
+    const waitangi = mondayiseSingle(new Date(year, 1, 6));
+    out.push(makeException(waitangi, 'Waitangi Day', new Date(year, 1, 6)));
+    // Good Friday + Easter Monday (Easter Sunday ± 2 / +1)
+    const easterSun = computeEasterSunday(year);
+    const goodFri = new Date(year, easterSun.getMonth(), easterSun.getDate() - 2);
+    const easterMon = new Date(year, easterSun.getMonth(), easterSun.getDate() + 1);
+    out.push(makeException(goodFri, 'Good Friday'));
+    out.push(makeException(easterMon, 'Easter Monday'));
+    // ANZAC Day (single-day mondayisation)
+    const anzac = mondayiseSingle(new Date(year, 3, 25));
+    out.push(makeException(anzac, 'ANZAC Day', new Date(year, 3, 25)));
+    // King's Birthday (first Monday of June)
+    out.push(makeException(nthMondayOfMonth(year, 5, 1), "King's Birthday"));
+    // Matariki (static table — guaranteed in range by the gate above)
+    // biome-ignore lint/style/noNonNullAssertion: year is range-gated 2022-2052; entry always present
+    out.push(makeException(MATARIKI_DATES[year], 'Matariki'));
+    // Labour Day (fourth Monday of October)
+    out.push(makeException(nthMondayOfMonth(year, 9, 4), 'Labour Day'));
+    // Christmas + Boxing Day (pair rule)
+    const [christmas, boxing] = mondayisePair(new Date(year, 11, 25), new Date(year, 11, 26));
+    out.push(makeException(christmas, 'Christmas Day', new Date(year, 11, 25)));
+    out.push(makeException(boxing, 'Boxing Day', new Date(year, 11, 26)));
+    return out;
+}
+function regionalAnniversary(year, region) {
+    switch(region){
+        case 'auckland':
+            return makeException(nearestMondayTo(year, 0, 29), 'Auckland Anniversary');
+        case 'wellington':
+            return makeException(nearestMondayTo(year, 0, 22), 'Wellington Anniversary');
+        case 'nelson':
+            return makeException(nearestMondayTo(year, 1, 1), 'Nelson Anniversary');
+        case 'otago':
+            return makeException(nearestMondayTo(year, 2, 23), 'Otago Anniversary');
+        case 'taranaki':
+            return makeException(nthMondayOfMonth(year, 2, 2), 'Taranaki Anniversary');
+        case 'southland':
+            {
+                const easterSun = computeEasterSunday(year);
+                const easterTue = new Date(year, easterSun.getMonth(), easterSun.getDate() + 2);
+                return makeException(easterTue, 'Southland Anniversary');
+            }
+        case 'south-canterbury':
+            return makeException(nthMondayOfMonth(year, 8, 4), 'South Canterbury Anniversary');
+        case 'hawkes-bay':
+            {
+                const labourDay = nthMondayOfMonth(year, 9, 4);
+                return makeException(fridayBefore(labourDay), "Hawke's Bay Anniversary");
+            }
+        case 'marlborough':
+            {
+                const labourDay = nthMondayOfMonth(year, 9, 4);
+                return makeException(firstMondayAfter(labourDay), 'Marlborough Anniversary');
+            }
+        case 'canterbury':
+            {
+                const date = CANTERBURY_DATES[year];
+                if (!date) {
+                    throw new RangeError(`nzPublicHolidays: Canterbury Anniversary Day for ${year} is not in the verified ` + `static table (range ${CANTERBURY_RANGE.minYear}-${CANTERBURY_RANGE.maxYear}). ` + `Show Day is set annually by the Canterbury A&P Association; ` + `add the verified date from employment.govt.nz to canterbury-table.ts to extend coverage.`);
+                }
+                return makeException(date, 'Canterbury Anniversary');
+            }
+        case 'westland':
+            return makeException(nthMondayOfMonth(year, 11, 1), 'Westland Anniversary');
+        case 'chatham-islands':
+            return makeException(nearestMondayTo(year, 10, 30), 'Chatham Islands Anniversary');
+        case 'northland':
+            // Per Holidays Act 2003: Northland observes Waitangi Day as its
+            // anniversary. No extra exception is added.
+            return null;
+    }
+}
+function makeException(observedDate, baseName, statutoryDate) {
+    const moved = statutoryDate && (observedDate.getFullYear() !== statutoryDate.getFullYear() || observedDate.getMonth() !== statutoryDate.getMonth() || observedDate.getDate() !== statutoryDate.getDate());
+    return {
+        date: new Date(observedDate.getFullYear(), observedDate.getMonth(), observedDate.getDate()),
+        isWorking: false,
+        name: moved ? `${baseName} (observed)` : baseName
+    };
+}
+function nzDefaultCalendar(options) {
+    const { years, region, workWeek, id, name } = options;
+    return {
+        id: id ?? 'nz-default',
+        name: name ?? 'New Zealand Standard',
+        workWeek: workWeek ?? DEFAULT_WORK_WEEK,
+        exceptions: nzPublicHolidays(years, region)
+    };
+}
+
+/**
+ * Thrown when an EditCommand's pre-conditions fail (e.g. target task
+ * doesn't exist, FS-link-to-self, malformed patch). Caught at the hook
+ * boundary so consumers see a typed error rather than a generic Error.
+ */ class EditError extends Error {
+    constructor(message, commandKind){
+        super(message);
+        this.name = 'EditError';
+        this.commandKind = commandKind;
+    }
+}
+
+class CreateTaskCommand {
+    constructor(task, insertAt){
+        this.task = task;
+        this.insertAt = insertAt;
+        this.kind = 'create-task';
+        this.label = `Create task "${task.text}"`;
+    }
+    apply(project) {
+        if (project.tasks.some((t)=>t.id === this.task.id)) {
+            throw new EditError(`duplicate task id ${String(this.task.id)}`, this.kind);
+        }
+        const tasks = [
+            ...project.tasks
+        ];
+        if (this.insertAt === undefined) {
+            tasks.push(this.task);
+        } else {
+            tasks.splice(this.insertAt, 0, this.task);
+        }
+        return {
+            ...project,
+            tasks
+        };
+    }
+    inverse(_project) {
+        return new DeleteTaskCommand(this.task.id);
+    }
+}
+class UpdateTaskCommand {
+    constructor(taskId, patch, customLabel){
+        this.taskId = taskId;
+        this.patch = patch;
+        this.kind = 'update-task';
+        if (customLabel !== undefined) {
+            this.label = customLabel;
+        } else {
+            const keys = Object.keys(patch);
+            this.label = keys.length === 1 ? `Update task "${String(taskId)}" (${keys[0]})` : `Update task "${String(taskId)}"`;
+        }
+    }
+    apply(project) {
+        const idx = project.tasks.findIndex((t)=>t.id === this.taskId);
+        if (idx === -1) {
+            throw new EditError(`missing task ${String(this.taskId)}`, this.kind);
+        }
+        const tasks = [
+            ...project.tasks
+        ];
+        this.originalTask = tasks[idx];
+        tasks[idx] = Object.assign({}, tasks[idx], this.patch);
+        return {
+            ...project,
+            tasks
+        };
+    }
+    inverse(_project) {
+        if (!this.originalTask) {
+            throw new EditError(`inverse: apply() was not called on this command`, this.kind);
+        }
+        // Capture the value of each patched key from the original task.
+        const previousPatch = {};
+        for (const key of Object.keys(this.patch)){
+            const k = key;
+            previousPatch[k] = this.originalTask[k];
+        }
+        return new UpdateTaskCommand(this.taskId, previousPatch);
+    }
+}
+class DeleteTaskCommand {
+    constructor(taskId){
+        this.taskId = taskId;
+        this.kind = 'delete-task';
+        this.label = `Delete task "${String(taskId)}"`;
+    }
+    apply(project) {
+        const target = project.tasks.find((t)=>t.id === this.taskId);
+        if (!target) {
+            throw new EditError(`missing task ${String(this.taskId)}`, this.kind);
+        }
+        const taskIndex = project.tasks.indexOf(target);
+        // Capture incident links with their original indices.
+        const incidentLinkPositions = [];
+        for(let i = 0; i < project.links.length; i++){
+            const link = project.links[i];
+            if (link && (link.source === this.taskId || link.target === this.taskId)) {
+                incidentLinkPositions.push([
+                    i,
+                    link
+                ]);
+            }
+        }
+        this.snapshot = {
+            task: target,
+            taskIndex,
+            incidentLinkPositions
+        };
+        const tasks = project.tasks.filter((t)=>t.id !== this.taskId);
+        const links = project.links.filter((l)=>l.source !== this.taskId && l.target !== this.taskId);
+        return {
+            ...project,
+            tasks,
+            links
+        };
+    }
+    inverse(_project) {
+        if (!this.snapshot) {
+            throw new EditError(`inverse: apply() was not called on this command`, this.kind);
+        }
+        const snapshotData = this.snapshot;
+        const { task: snapshotTask, taskIndex, incidentLinkPositions } = snapshotData;
+        // Return an ad-hoc EditCommand that restores both task + links atomically.
+        // Not exported — only reachable as the inverse of DeleteTaskCommand.
+        const restoreCommand = {
+            kind: 'restore-task',
+            label: `Restore task "${String(this.taskId)}"`,
+            apply (p) {
+                if (p.tasks.some((t)=>t.id === snapshotTask.id)) {
+                    throw new EditError(`duplicate task id ${String(snapshotTask.id)}`, 'restore-task');
+                }
+                // Restore task at original index (clamped to current length).
+                const tasks = [
+                    ...p.tasks
+                ];
+                const insertTaskAt = Math.min(taskIndex, tasks.length);
+                tasks.splice(insertTaskAt, 0, snapshotTask);
+                // Restore links at their original indices, adjusting for deletions.
+                // INVARIANT: incidentLinkPositions is guaranteed ascending-by-index
+                // because the capture loop in apply() walks 0..N. Splice-in-place
+                // only produces the correct final order when fed sorted-ascending
+                // positions — if a future refactor breaks the capture order, this
+                // restoration breaks silently. If insertion order ever becomes
+                // unsortable, switch to a single-pass rebuild keyed on original idx.
+                const links = [
+                    ...p.links
+                ];
+                for (const [originalIdx, link] of incidentLinkPositions){
+                    links.splice(originalIdx, 0, link);
+                }
+                return {
+                    ...p,
+                    tasks,
+                    links
+                };
+            },
+            inverse (_p) {
+                return new DeleteTaskCommand(snapshotTask.id);
+            }
+        };
+        return restoreCommand;
+    }
+}
+class CreateLinkCommand {
+    constructor(link){
+        this.link = link;
+        this.kind = 'create-link';
+        this.label = `Link ${String(link.source)} → ${String(link.target)}`;
+    }
+    apply(project) {
+        if (this.link.source === this.link.target) {
+            throw new EditError(`self-link not allowed (${String(this.link.source)})`, this.kind);
+        }
+        if (project.links.some((l)=>l.id === this.link.id)) {
+            throw new EditError(`duplicate link id ${String(this.link.id)}`, this.kind);
+        }
+        if (!project.tasks.some((t)=>t.id === this.link.source)) {
+            throw new EditError(`source task ${String(this.link.source)} not found`, this.kind);
+        }
+        if (!project.tasks.some((t)=>t.id === this.link.target)) {
+            throw new EditError(`target task ${String(this.link.target)} not found`, this.kind);
+        }
+        return {
+            ...project,
+            links: [
+                ...project.links,
+                this.link
+            ]
+        };
+    }
+    inverse(_project) {
+        return new DeleteLinkCommand(this.link.id);
+    }
+}
+class UpdateLinkCommand {
+    constructor(linkId, patch, customLabel){
+        this.linkId = linkId;
+        this.patch = patch;
+        this.kind = 'update-link';
+        this.label = customLabel ?? `Update link "${String(linkId)}"`;
+    }
+    apply(project) {
+        const target = project.links.find((l)=>l.id === this.linkId);
+        if (!target) {
+            throw new EditError(`missing link ${String(this.linkId)}`, this.kind);
+        }
+        const idx = project.links.indexOf(target);
+        const links = [
+            ...project.links
+        ];
+        this.originalLink = target;
+        links[idx] = Object.assign({}, target, this.patch);
+        return {
+            ...project,
+            links
+        };
+    }
+    inverse(_project) {
+        if (!this.originalLink) {
+            throw new EditError(`inverse: apply() was not called on this command`, this.kind);
+        }
+        const previousPatch = {};
+        for (const key of Object.keys(this.patch)){
+            const k = key;
+            previousPatch[k] = this.originalLink[k];
+        }
+        return new UpdateLinkCommand(this.linkId, previousPatch);
+    }
+}
+class DeleteLinkCommand {
+    constructor(linkId){
+        this.linkId = linkId;
+        this.kind = 'delete-link';
+        this.label = `Delete link "${String(linkId)}"`;
+    }
+    apply(project) {
+        const target = project.links.find((l)=>l.id === this.linkId);
+        if (!target) {
+            throw new EditError(`missing link ${String(this.linkId)}`, this.kind);
+        }
+        const linkIndex = project.links.indexOf(target);
+        this.snapshot = {
+            link: target,
+            linkIndex
+        };
+        return {
+            ...project,
+            links: project.links.filter((l)=>l.id !== this.linkId)
+        };
+    }
+    inverse(_project) {
+        if (!this.snapshot) {
+            throw new EditError(`inverse: apply() was not called on this command`, this.kind);
+        }
+        const { link: snapshotLink, linkIndex } = this.snapshot;
+        const linkId = this.linkId;
+        // Ad-hoc 'restore-link' command — not exported. Unlike DeleteTaskCommand's
+        // 'restore-task' (which also restores incident links), a link has no
+        // incident dependencies — just re-insert it at its original index.
+        const restoreCommand = {
+            kind: 'restore-link',
+            label: `Restore link "${String(linkId)}"`,
+            apply (p) {
+                if (p.links.some((l)=>l.id === snapshotLink.id)) {
+                    throw new EditError(`duplicate link id ${String(snapshotLink.id)}`, 'restore-link');
+                }
+                const links = [
+                    ...p.links
+                ];
+                const insertAt = Math.min(linkIndex, links.length);
+                links.splice(insertAt, 0, snapshotLink);
+                return {
+                    ...p,
+                    links
+                };
+            },
+            inverse (_p) {
+                return new DeleteLinkCommand(snapshotLink.id);
+            }
+        };
+        return restoreCommand;
+    }
+}
+
+/**
+ * Ergonomic factory functions for constructing edit commands with
+ * descriptive labels. Consumers call these instead of `new
+ * UpdateTaskCommand(...)` so undo UI shows "Rename task to 'Foundation'"
+ * rather than the generic "Update task 'a' (text)".
+ */ function renameTask(id, text) {
+    return new UpdateTaskCommand(id, {
+        text
+    }, `Rename task to "${text}"`);
+}
+function setTaskStart(id, start) {
+    return new UpdateTaskCommand(id, {
+        start
+    }, `Move task "${String(id)}" (Start)`);
+}
+function setTaskDuration(id, minutes) {
+    return new UpdateTaskCommand(id, {
+        duration: minutes
+    }, `Change duration of task "${String(id)}"`);
+}
+function setTaskProgress(id, percent) {
+    return new UpdateTaskCommand(id, {
+        progress: percent
+    }, `Update progress of task "${String(id)}" to ${percent}%`);
+}
+function updateTask(id, patch) {
+    return new UpdateTaskCommand(id, patch);
+}
+function createTask(task, _parent, _insertAfter) {
+    // _parent and _insertAfter are accepted at the public surface but not
+    // wired into the underlying CreateTaskCommand in v0.4 foundation —
+    // hierarchy reordering and parent-changes are downstream concerns.
+    return new CreateTaskCommand(task);
+}
+function deleteTask(id) {
+    return new DeleteTaskCommand(id);
+}
+/**
+ * Creates a CreateLinkCommand with a **deterministic** link id derived
+ * from `${source}->${target}`. This means calling `linkTasks('a', 'b')`
+ * twice produces the same id — and the second `apply()` will throw
+ * `EditError: duplicate link id`. By design: duplicate enqueues are a
+ * consumer bug we surface loudly rather than silently coalesce.
+ *
+ * Consumers who legitimately need to re-add a previously-deleted link
+ * (e.g. delete A→B, then re-create it without bringing the deleted one
+ * back via undo) should use `new CreateLinkCommand({ id: customId, … })`
+ * directly with a fresh id.
+ */ function linkTasks(source, target, type = 'FS', lag = 0) {
+    const link = {
+        id: `${String(source)}->${String(target)}`,
+        source,
+        target,
+        type,
+        lag
+    };
+    return new CreateLinkCommand(link);
+}
+function updateLink(id, patch) {
+    return new UpdateLinkCommand(id, patch);
+}
+function deleteLink(id) {
+    return new DeleteLinkCommand(id);
+}
+
+/**
+ * Order tasks so that every predecessor appears before its successors.
+ *
+ * Operates on link-based ordering only (all dependency types FS/SS/FF/SF
+ * establish "source must be visited before target" for scheduling-pass
+ * purposes). Hierarchy (parent/summary) is not considered here — summary
+ * task dates are derived from children after the forward/backward pass.
+ *
+ * Throws if the link graph contains a cycle.
+ */ function topologicalSort(tasks, links) {
+    const taskById = new Map(tasks.map((t)=>[
+            t.id,
+            t
+        ]));
+    const successors = new Map();
+    const inDegree = new Map();
+    for (const t of tasks){
+        successors.set(t.id, []);
+        inDegree.set(t.id, 0);
+    }
+    for (const link of links){
+        if (!taskById.has(link.source) || !taskById.has(link.target)) continue;
+        successors.get(link.source)?.push(link.target);
+        inDegree.set(link.target, (inDegree.get(link.target) ?? 0) + 1);
+    }
+    const queue = [];
+    for (const t of tasks){
+        if ((inDegree.get(t.id) ?? 0) === 0) queue.push(t.id);
+    }
+    const ordered = [];
+    while(queue.length > 0){
+        const id = queue.shift();
+        const t = taskById.get(id);
+        if (t) ordered.push(t);
+        for (const succId of successors.get(id) ?? []){
+            const newDegree = (inDegree.get(succId) ?? 0) - 1;
+            inDegree.set(succId, newDegree);
+            if (newDegree === 0) queue.push(succId);
+        }
+    }
+    if (ordered.length !== tasks.length) {
+        throw new Error('Link graph contains a cycle; topological sort is not possible');
+    }
+    return ordered;
+}
+
+// Forward + backward pass + critical path + constraint resolution.
+//
+// Algorithm:
+// 1. Kahn-ordered topological sort over the link graph.
+// 2. Forward pass: compute earlyStart/earlyFinish per task. After
+//    predecessor-based candidates, apply forward-direction constraints
+//    (ASAP/MSO/MFO/SNET/FNET).
+// 3. Backward pass: compute lateStart/lateFinish per task working right to
+//    left. After successor-based candidates, apply backward-direction
+//    constraints (MSO/MFO/SNLT/FNLT). MSO/MFO are hard pins — they lock
+//    both early and late dates to the constraint, so predecessors that
+//    can't deliver in time get negative slack on themselves.
+// 4. Slack: totalSlack = workingMinutesBetween(earlyStart, lateStart) in
+//    working time. freeSlack = min working gap to earliest successor's
+//    required start. isCritical = totalSlack <= 0.
+//
+// Per ADR-003, negative slack is preserved, not clipped to zero. A task
+// with negative slack is already late against a downstream constraint;
+// surfacing that is the differentiator vs every existing alternative.
+//
+// ALAP semantics (consume slack to push the task to its latest position)
+// are deferred — full ALAP requires a second forward pass after the
+// backward pass to re-flow downstream dates. For now ALAP is parsed but
+// behaves like ASAP.
+function schedule(project) {
+    const calendar = getDefaultCalendar(project);
+    const sorted = topologicalSort(project.tasks, project.links);
+    const taskById = new Map(sorted.map((t)=>[
+            t.id,
+            t
+        ]));
+    const childrenByParent = groupChildrenByParent(project.tasks);
+    const summariesByDepthDesc = summariesDeepestFirst(project.tasks);
+    // Forward pass — leaves first, summaries bottom-up after.
+    const forwardById = new Map();
+    const projectFloor = snapToNextWorkingMoment(project.start, calendar);
+    for (const task of sorted){
+        if (task.type === 'summary') continue; // aggregated below
+        if (task.scheduleMode === 'manual') {
+            // Manual: user-set dates are authoritative. Skip predecessor logic and
+            // constraint application — MS Project semantics. We still populate
+            // forwardById so the backward pass can compute slack against the
+            // network the user has drawn.
+            forwardById.set(task.id, {
+                earlyStart: new Date(task.start),
+                earlyFinish: new Date(task.end)
+            });
+            continue;
+        }
+        let earliest = projectFloor;
+        for (const link of incomingLinks(task.id, project.links)){
+            const source = taskById.get(link.source);
+            const sourceFwd = forwardById.get(link.source);
+            if (!source || !sourceFwd) continue;
+            const fromLink = earliestStartFromLink(link, source, task, sourceFwd, calendar);
+            if (fromLink > earliest) earliest = fromLink;
+        }
+        forwardById.set(task.id, applyForwardConstraint(task, earliest, calendar));
+    }
+    // Summary forward aggregation: min(child earlyStart), max(child earlyFinish).
+    // Deepest-first so a summary that contains other summaries sees its
+    // descendants already aggregated.
+    for (const summary of summariesByDepthDesc){
+        const aggregated = aggregateFromChildren(summary, childrenByParent, forwardById);
+        if (aggregated) forwardById.set(summary.id, aggregated);
+    }
+    // Backward pass — leaves first (reverse-sorted), summaries bottom-up after.
+    const projectCeiling = projectFinishAnchor(project, forwardById, calendar);
+    const backwardById = new Map();
+    for (const task of [
+        ...sorted
+    ].reverse()){
+        if (task.type === 'summary') continue;
+        let latest = projectCeiling;
+        for (const link of outgoingLinks(task.id, project.links)){
+            const target = taskById.get(link.target);
+            const targetBwd = backwardById.get(link.target);
+            if (!target || !targetBwd) continue;
+            const fromLink = latestFinishFromLink(link, task, target, targetBwd, calendar);
+            if (fromLink < latest) latest = fromLink;
+        }
+        const fwd = forwardById.get(task.id);
+        if (!fwd) continue;
+        backwardById.set(task.id, applyBackwardConstraint(task, latest, fwd, calendar));
+    }
+    // Summary backward aggregation: min(child lateStart), max(child lateFinish).
+    for (const summary of summariesByDepthDesc){
+        const aggregated = aggregateBackwardFromChildren(summary, childrenByParent, backwardById);
+        if (aggregated) backwardById.set(summary.id, aggregated);
+    }
+    // Assemble final tasks with computed slack + critical.
+    // For auto-mode tasks, write the scheduled dates back to task.start/end
+    // (MS Project default behavior). Manual-mode tasks keep their user-set
+    // dates regardless.
+    const newTasks = project.tasks.map((t)=>{
+        const f = forwardById.get(t.id);
+        const b = backwardById.get(t.id);
+        if (!f || !b) return t;
+        const totalSlack = workingMinutesBetween(f.earlyStart, b.lateStart, calendar);
+        const freeSlack = computeFreeSlack(t, f, forwardById, project.links, calendar);
+        const computed = {
+            earlyStart: f.earlyStart,
+            earlyFinish: f.earlyFinish,
+            lateStart: b.lateStart,
+            lateFinish: b.lateFinish,
+            totalSlack,
+            freeSlack,
+            isCritical: totalSlack <= 0
+        };
+        if (t.type === 'summary') {
+            // Summary: dates + duration derived from child span; always overwritten.
+            return {
+                ...t,
+                start: new Date(f.earlyStart),
+                end: new Date(f.earlyFinish),
+                duration: workingMinutesBetween(f.earlyStart, f.earlyFinish, calendar),
+                computed
+            };
+        }
+        if (t.scheduleMode === 'auto') {
+            return {
+                ...t,
+                start: new Date(f.earlyStart),
+                end: new Date(f.earlyFinish),
+                computed
+            };
+        }
+        return {
+            ...t,
+            computed
+        };
+    });
+    return {
+        ...project,
+        tasks: newTasks
+    };
+}
+// ---------------------------------------------------------------------------
+// Constraint application
+// ---------------------------------------------------------------------------
+function applyForwardConstraint(task, predecessorEarliestStart, calendar) {
+    const baseStart = snapToNextWorkingMoment(predecessorEarliestStart, calendar);
+    const baseFinish = addWorkingMinutes(baseStart, task.duration, calendar);
+    const base = {
+        earlyStart: baseStart,
+        earlyFinish: baseFinish
+    };
+    const c = task.constraint;
+    if (!c) return base;
+    switch(c.type){
+        case 'ASAP':
+        case 'ALAP':
+            return base;
+        // For constraint dates we trust the user-supplied moment as-is. Snapping
+        // gets fiddly for finish-end-of-interval boundaries (5pm is a valid
+        // finish but not a valid start). Document: constraint dates should be
+        // working-time moments; weird inputs produce weird outputs.
+        case 'MSO':
+            {
+                if (!c.date) return base;
+                const earlyStart = new Date(c.date);
+                const earlyFinish = addWorkingMinutes(earlyStart, task.duration, calendar);
+                return {
+                    earlyStart,
+                    earlyFinish
+                };
+            }
+        case 'MFO':
+            {
+                if (!c.date) return base;
+                const earlyFinish = new Date(c.date);
+                const earlyStart = subtractWorkingMinutes(earlyFinish, task.duration, calendar);
+                return {
+                    earlyStart,
+                    earlyFinish
+                };
+            }
+        case 'SNET':
+            {
+                if (!c.date) return base;
+                const earlyStart = c.date > baseStart ? new Date(c.date) : baseStart;
+                const earlyFinish = addWorkingMinutes(earlyStart, task.duration, calendar);
+                return {
+                    earlyStart,
+                    earlyFinish
+                };
+            }
+        case 'FNET':
+            {
+                if (!c.date) return base;
+                if (c.date <= baseFinish) return base;
+                const earlyFinish = new Date(c.date);
+                const earlyStart = subtractWorkingMinutes(earlyFinish, task.duration, calendar);
+                return {
+                    earlyStart,
+                    earlyFinish
+                };
+            }
+        case 'SNLT':
+        case 'FNLT':
+            // Backward-direction constraints; no forward-pass effect.
+            return base;
+    }
+}
+function applyBackwardConstraint(task, successorLatestFinish, forward, calendar) {
+    const baseLateFinish = snapToPreviousWorkingMoment(successorLatestFinish, calendar);
+    const baseLateStart = subtractWorkingMinutes(baseLateFinish, task.duration, calendar);
+    const base = {
+        lateStart: baseLateStart,
+        lateFinish: baseLateFinish
+    };
+    const c = task.constraint;
+    if (!c) return base;
+    switch(c.type){
+        case 'ASAP':
+        case 'ALAP':
+        case 'SNET':
+        case 'FNET':
+            return base;
+        case 'MSO':
+        case 'MFO':
+            // Hard pin: task is locked at the forward-pass date. Slack on the
+            // task itself is zero; impossibility propagates back to predecessors.
+            return {
+                lateStart: forward.earlyStart,
+                lateFinish: forward.earlyFinish
+            };
+        case 'SNLT':
+            {
+                if (!c.date) return base;
+                const lateStart = c.date < baseLateStart ? new Date(c.date) : baseLateStart;
+                const lateFinish = addWorkingMinutes(lateStart, task.duration, calendar);
+                return {
+                    lateStart,
+                    lateFinish
+                };
+            }
+        case 'FNLT':
+            {
+                if (!c.date) return base;
+                const lateFinish = c.date < baseLateFinish ? new Date(c.date) : baseLateFinish;
+                const lateStart = subtractWorkingMinutes(lateFinish, task.duration, calendar);
+                return {
+                    lateStart,
+                    lateFinish
+                };
+            }
+    }
+}
+// ---------------------------------------------------------------------------
+// Link semantics
+// ---------------------------------------------------------------------------
+function earliestStartFromLink(link, _source, target, sourceFwd, calendar) {
+    switch(link.type){
+        case 'FS':
+            return addWorkingTime(sourceFwd.earlyFinish, link.lag, calendar);
+        case 'SS':
+            return addWorkingTime(sourceFwd.earlyStart, link.lag, calendar);
+        case 'FF':
+            {
+                const finishConstraint = addWorkingTime(sourceFwd.earlyFinish, link.lag, calendar);
+                return subtractWorkingMinutes(finishConstraint, target.duration, calendar);
+            }
+        case 'SF':
+            {
+                const finishConstraint = addWorkingTime(sourceFwd.earlyStart, link.lag, calendar);
+                return subtractWorkingMinutes(finishConstraint, target.duration, calendar);
+            }
+    }
+}
+function latestFinishFromLink(link, source, _target, targetBwd, calendar) {
+    switch(link.type){
+        case 'FS':
+            return subtractWorkingMinutes(targetBwd.lateStart, link.lag, calendar);
+        case 'SS':
+            {
+                const sourceLateStart = subtractWorkingMinutes(targetBwd.lateStart, link.lag, calendar);
+                return addWorkingMinutes(sourceLateStart, source.duration, calendar);
+            }
+        case 'FF':
+            return subtractWorkingMinutes(targetBwd.lateFinish, link.lag, calendar);
+        case 'SF':
+            {
+                const sourceLateStart = subtractWorkingMinutes(targetBwd.lateFinish, link.lag, calendar);
+                return addWorkingMinutes(sourceLateStart, source.duration, calendar);
+            }
+    }
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function getDefaultCalendar(project) {
+    const calendar = project.calendars.find((c)=>c.id === project.defaultCalendarId);
+    if (!calendar) {
+        throw new Error(`Project default calendar "${project.defaultCalendarId}" not found`);
+    }
+    return calendar;
+}
+function incomingLinks(taskId, links) {
+    return links.filter((l)=>l.target === taskId);
+}
+function outgoingLinks(taskId, links) {
+    return links.filter((l)=>l.source === taskId);
+}
+function projectFinishAnchor(project, forwardById, calendar) {
+    if (project.end) return snapToPreviousWorkingMoment(project.end, calendar);
+    let latest;
+    for (const f of forwardById.values()){
+        if (!latest || f.earlyFinish > latest) latest = f.earlyFinish;
+    }
+    return latest ?? snapToNextWorkingMoment(project.start, calendar);
+}
+function addWorkingTime(date, minutes, calendar) {
+    if (minutes > 0) return addWorkingMinutes(date, minutes, calendar);
+    if (minutes < 0) return subtractWorkingMinutes(date, -minutes, calendar);
+    return new Date(date);
+}
+// ---------------------------------------------------------------------------
+// Summary task hierarchy
+// ---------------------------------------------------------------------------
+function groupChildrenByParent(tasks) {
+    const map = new Map();
+    for (const t of tasks){
+        if (t.parent === undefined) continue;
+        const list = map.get(t.parent) ?? [];
+        list.push(t);
+        map.set(t.parent, list);
+    }
+    return map;
+}
+function summariesDeepestFirst(tasks) {
+    const parentById = new Map();
+    for (const t of tasks)parentById.set(t.id, t.parent);
+    const depthCache = new Map();
+    function depthOf(id) {
+        const cached = depthCache.get(id);
+        if (cached !== undefined) return cached;
+        const parent = parentById.get(id);
+        const d = parent === undefined ? 0 : depthOf(parent) + 1;
+        depthCache.set(id, d);
+        return d;
+    }
+    return tasks.filter((t)=>t.type === 'summary').map((t)=>({
+            task: t,
+            depth: depthOf(t.id)
+        })).sort((a, b)=>b.depth - a.depth).map((x)=>x.task);
+}
+function aggregateFromChildren(summary, childrenByParent, forwardById) {
+    const children = childrenByParent.get(summary.id) ?? [];
+    const dates = children.map((c)=>forwardById.get(c.id)).filter((d)=>d !== undefined);
+    if (dates.length === 0) return undefined;
+    let earlyStartMs = Number.POSITIVE_INFINITY;
+    let earlyFinishMs = Number.NEGATIVE_INFINITY;
+    for (const d of dates){
+        if (d.earlyStart.getTime() < earlyStartMs) earlyStartMs = d.earlyStart.getTime();
+        if (d.earlyFinish.getTime() > earlyFinishMs) earlyFinishMs = d.earlyFinish.getTime();
+    }
+    return {
+        earlyStart: new Date(earlyStartMs),
+        earlyFinish: new Date(earlyFinishMs)
+    };
+}
+function aggregateBackwardFromChildren(summary, childrenByParent, backwardById) {
+    const children = childrenByParent.get(summary.id) ?? [];
+    const dates = children.map((c)=>backwardById.get(c.id)).filter((d)=>d !== undefined);
+    if (dates.length === 0) return undefined;
+    let lateStartMs = Number.POSITIVE_INFINITY;
+    let lateFinishMs = Number.NEGATIVE_INFINITY;
+    for (const d of dates){
+        if (d.lateStart.getTime() < lateStartMs) lateStartMs = d.lateStart.getTime();
+        if (d.lateFinish.getTime() > lateFinishMs) lateFinishMs = d.lateFinish.getTime();
+    }
+    return {
+        lateStart: new Date(lateStartMs),
+        lateFinish: new Date(lateFinishMs)
+    };
+}
+function computeFreeSlack(task, taskFwd, forwardById, links, calendar) {
+    const outgoing = links.filter((l)=>l.source === task.id);
+    if (outgoing.length === 0) return 0;
+    let minGap = Number.POSITIVE_INFINITY;
+    for (const link of outgoing){
+        const targetFwd = forwardById.get(link.target);
+        if (!targetFwd) continue;
+        let requiredEnd;
+        switch(link.type){
+            case 'FS':
+                requiredEnd = subtractWorkingMinutes(targetFwd.earlyStart, link.lag, calendar);
+                break;
+            case 'SS':
+                requiredEnd = addWorkingMinutes(subtractWorkingMinutes(targetFwd.earlyStart, link.lag, calendar), task.duration, calendar);
+                break;
+            case 'FF':
+                requiredEnd = subtractWorkingMinutes(targetFwd.earlyFinish, link.lag, calendar);
+                break;
+            case 'SF':
+                requiredEnd = addWorkingMinutes(subtractWorkingMinutes(targetFwd.earlyFinish, link.lag, calendar), task.duration, calendar);
+                break;
+        }
+        const gap = workingMinutesBetween(taskFwd.earlyFinish, requiredEnd, calendar);
+        if (gap < minGap) minGap = gap;
+    }
+    return Number.isFinite(minGap) ? minGap : 0;
+}
+
+function newHistory() {
+    return {
+        past: [],
+        future: [],
+        canUndo: false,
+        canRedo: false
+    };
+}
+function pushCommand(h, command) {
+    return {
+        past: [
+            ...h.past,
+            command
+        ],
+        future: [],
+        canUndo: true,
+        canRedo: false
+    };
+}
+function undo(h, project) {
+    if (h.past.length === 0) return null;
+    const cmd = h.past[h.past.length - 1];
+    if (!cmd) return null; // unreachable under noUncheckedIndexedAccess; preserves type narrowing
+    const inverse = cmd.inverse(project);
+    const nextProject = inverse.apply(project);
+    const nextPast = h.past.slice(0, -1);
+    return {
+        nextHistory: {
+            past: nextPast,
+            future: [
+                ...h.future,
+                cmd
+            ],
+            canUndo: nextPast.length > 0,
+            canRedo: true
+        },
+        nextProject,
+        undoneCommand: cmd
+    };
+}
+function redo(h, project) {
+    if (h.future.length === 0) return null;
+    const cmd = h.future[h.future.length - 1];
+    if (!cmd) return null; // unreachable under noUncheckedIndexedAccess; preserves type narrowing
+    const nextProject = cmd.apply(project);
+    const nextFuture = h.future.slice(0, -1);
+    return {
+        nextHistory: {
+            past: [
+                ...h.past,
+                cmd
+            ],
+            future: nextFuture,
+            canUndo: true,
+            canRedo: nextFuture.length > 0
+        },
+        nextProject,
+        redoneCommand: cmd
+    };
+}
+
+/**
+ * Wraps N EditCommands into a single history entry. Apply runs each
+ * member in order; if any throws, the whole composite throws (caller
+ * sees a single error — the no-partial-output guarantee). Inverse walks
+ * members in REVERSE order, collecting each member's inverse — which
+ * reads from the snapshot captured during the member's apply.
+ *
+ * Single-use semantics: composite.apply() MUST be called before
+ * composite.inverse(), because the stateful member commands
+ * (Update*Command, Delete*Command) only have their snapshots after
+ * apply(). Calling inverse() without apply() throws the underlying
+ * member's "apply() was not called" EditError.
+ *
+ * **Contract caveat for members.** This implementation assumes every
+ * member is either stateless (Create*Command — its inverse derives
+ * from constructor args) or uses the snapshot-at-apply pattern (the
+ * built-in Update*Command and Delete*Command). The `_project` arg
+ * passed to each member's `inverse()` here is the composite's `_project`
+ * (the post-composite-apply state), NOT the post-member-apply state
+ * for that particular member. Built-in stateful commands ignore the
+ * arg and read their own snapshot, so this works correctly.
+ *
+ * If a future EditCommand implementation needs the actual post-member-
+ * apply state inside a composite, the implementation must either:
+ *   (a) adopt snapshot-at-apply itself (recommended — matches built-ins),
+ *   (b) extend CompositeCommand to walk the apply chain and pass each
+ *       member its specific post-state to inverse().
+ *
+ * Produced by DraftProject.commit() when N>1 pending commands need to
+ * land as one history entry. Single-pending-command commits return
+ * the member directly without wrapping (per DraftProject contract).
+ */ class CompositeCommand {
+    constructor(members, label){
+        this.kind = 'composite';
+        this.members = members;
+        this.label = label;
+    }
+    apply(project) {
+        let cur = project;
+        for (const cmd of this.members){
+            cur = cmd.apply(cur);
+        }
+        return cur;
+    }
+    inverse(_project) {
+        // Members store their own pre-state via snapshot-at-apply. We just
+        // collect each member's inverse in reverse order.
+        const inverses = [];
+        const reversed = [
+            ...this.members
+        ].reverse();
+        for (const cmd of reversed){
+            inverses.push(cmd.inverse(_project));
+        }
+        return new CompositeCommand(inverses, `Undo: ${this.label}`);
+    }
+}
+
+function newDraft(base) {
+    return {
+        base,
+        pending: [],
+        effective: base,
+        isDirty: false
+    };
+}
+function enqueue(draft, command) {
+    const effective = command.apply(draft.effective);
+    return {
+        base: draft.base,
+        pending: [
+            ...draft.pending,
+            command
+        ],
+        effective,
+        isDirty: true
+    };
+}
+function commit(draft, label = 'Edit') {
+    if (draft.pending.length === 0) {
+        throw new EditError('cannot commit an empty draft', 'commit');
+    }
+    const compound = draft.pending.length === 1 ? draft.pending[0] : new CompositeCommand(draft.pending, label);
+    if (!compound) {
+        throw new EditError('unreachable: empty pending', 'commit');
+    }
+    return {
+        newBase: draft.effective,
+        compound
+    };
+}
+function cancel(draft) {
+    return newDraft(draft.base);
+}
+
+function reducer(state, action) {
+    switch(action.type){
+        case 'enqueue':
+            return {
+                ...state,
+                draft: enqueue(state.draft, action.command)
+            };
+        case 'commit':
+            {
+                if (state.draft.pending.length === 0) return state;
+                const { newBase, compound } = commit(state.draft, action.label);
+                return {
+                    draft: newDraft(newBase),
+                    history: pushCommand(state.history, compound)
+                };
+            }
+        case 'cancel':
+            return {
+                ...state,
+                draft: cancel(state.draft)
+            };
+        case 'undo':
+            {
+                // If dirty, cancel pending first (matches VS Code / Figma).
+                const cleaned = state.draft.isDirty ? cancel(state.draft) : state.draft;
+                const result = undo(state.history, cleaned.base);
+                if (!result) return {
+                    ...state,
+                    draft: cleaned
+                };
+                return {
+                    draft: newDraft(result.nextProject),
+                    history: result.nextHistory
+                };
+            }
+        case 'redo':
+            {
+                const cleaned = state.draft.isDirty ? cancel(state.draft) : state.draft;
+                const result = redo(state.history, cleaned.base);
+                if (!result) return {
+                    ...state,
+                    draft: cleaned
+                };
+                return {
+                    draft: newDraft(result.nextProject),
+                    history: result.nextHistory
+                };
+            }
+    }
+}
+/**
+ * The single hook entry point for v0.4 editing. Captures `initial` once
+ * on first mount (subsequent renders with a different `initial` are
+ * ignored — consumers reset by remounting via `key={projectId}`).
+ *
+ * Every effective state change is run through `schedule()` so the
+ * returned `project` always has fresh CPM data. Per ADR-005 (engine-first).
+ */ function useEditableProject(initial) {
+    // Capture initial once. useRef freezes the value across re-renders.
+    const initialRef = useRef(initial);
+    const [state, dispatch] = useReducer(reducer, undefined, ()=>({
+            draft: newDraft(initialRef.current),
+            history: newHistory()
+        }));
+    const scheduled = useMemo(()=>schedule(state.draft.effective), [
+        state.draft.effective
+    ]);
+    return {
+        project: scheduled,
+        isDirty: state.draft.isDirty,
+        canUndo: state.history.canUndo,
+        canRedo: state.history.canRedo,
+        enqueue: (command)=>dispatch({
+                type: 'enqueue',
+                command
+            }),
+        commit: (label = 'Edit')=>dispatch({
+                type: 'commit',
+                label
+            }),
+        cancel: ()=>dispatch({
+                type: 'cancel'
+            }),
+        undo: ()=>dispatch({
+                type: 'undo'
+            }),
+        redo: ()=>dispatch({
+                type: 'redo'
+            })
+    };
+}
+
+__insertCSS(".construction-gantt-non-working{background:rgba(241,245,249,.65)}.construction-gantt-marker-today{background:#ef4444;color:#fff;font-weight:600}.construction-gantt-marker-milestone{background:#2563eb;color:#fff;font-weight:500}");
+
+// Render-only visibility filter for <Gantt> tasks.
+//
+// Per ADR-005 (engine-first; no BYO-CPM mode), consumer domain rules around
+// hiding tasks must surface as render-time props, never as engine bypasses.
+// This is the canonical example: the engine always runs on the full task
+// set; the visibility filter applies only to the rendered output.
+//
+// Direct lift from the CM domain rule (FrappeGanttView.tsx:366-371 in
+// Bode-Builds): "Hiding a predecessor would otherwise make a dependent
+// task's early-start collapse to 0, which is wrong." We honour the rule
+// by structure — the filter sits AFTER schedule() in the pipeline, so
+// computed fields on the visible tasks reflect the full schedule.
+/**
+ * Return the subset of `tasks` whose ids appear in `visibleTaskIds`.
+ *
+ * - `undefined` → no filter; the original array reference is returned
+ *   so React's `useMemo` identity stays stable on the noop path.
+ * - empty set → returns an empty array (hide everything).
+ * - set containing ids not present in `tasks` → unknown ids ignored;
+ *   only matching tasks survive.
+ *
+ * Crucially: this is a pure projection. `task.computed` is preserved
+ * exactly — no recomputation, no clipping, no slack adjustment. The
+ * engine already ran on the full set; we trust its result.
+ */ function filterTasksByVisibility(tasks, visibleTaskIds) {
+    if (visibleTaskIds === undefined) return tasks;
+    return tasks.filter((t)=>visibleTaskIds.has(t.id));
+}
+
+const Gantt = /*#__PURE__*/ forwardRef(function Gantt({ project, height = 500, cellWidth = 48, cellHeight = 42, preScheduled = false, markers, baselineIndex, showBaselineBars, columns, visibleTaskIds }, ref) {
+    const containerRef = useRef(null);
+    const scheduled = useMemo(()=>preScheduled ? project : schedule(project), [
+        project,
+        preScheduled
+    ]);
+    // Visibility filter is render-only — applied AFTER schedule() has run so
+    // computed fields on visible tasks reflect the full project. ADR-005.
+    const renderableTasks = useMemo(()=>filterTasksByVisibility(scheduled.tasks, visibleTaskIds), [
+        scheduled.tasks,
+        visibleTaskIds
+    ]);
+    const calendar = useMemo(()=>scheduled.calendars.find((c)=>c.id === scheduled.defaultCalendarId), [
+        scheduled.calendars,
+        scheduled.defaultCalendarId
+    ]);
+    const baseline = useMemo(()=>{
+        if (baselineIndex === undefined) return undefined;
+        return scheduled.baselines.find((b)=>b.index === baselineIndex);
+    }, [
+        scheduled.baselines,
+        baselineIndex
+    ]);
+    const ghostBarsEnabled = baseline !== undefined && (showBaselineBars ?? true);
+    const svarTasks = useMemo(()=>{
+        if (!ghostBarsEnabled || !baseline) {
+            return renderableTasks.map((t)=>toSvarTask(t, baseline, calendar));
+        }
+        // Interleave each real task with its baseline-snapshot ghost row.
+        // Phantoms share the real task's `parent` so they stay grouped under
+        // the same summary in hierarchy views.
+        const out = [];
+        for (const t of renderableTasks){
+            out.push(toSvarTask(t, baseline, calendar));
+            if (t.type === 'summary') continue;
+            const phantom = makeBaselinePhantom(t, baseline);
+            if (phantom) out.push(phantom);
+        }
+        return out;
+    }, [
+        renderableTasks,
+        baseline,
+        calendar,
+        ghostBarsEnabled
+    ]);
+    const svarLinks = useMemo(()=>scheduled.links.map(toSvarLink), [
+        scheduled.links
+    ]);
+    const projectEnd = useMemo(()=>getProjectEnd(scheduled), [
+        scheduled
+    ]);
+    const svarMarkers = useMemo(()=>resolveMarkers(markers, scheduled.start, projectEnd), [
+        markers,
+        scheduled.start,
+        projectEnd
+    ]);
+    const highlightTime = useMemo(()=>buildHighlightTime(calendar), [
+        calendar
+    ]);
+    // Convert our SVAR-agnostic GanttColumn[] to SVAR's IColumnConfig[].
+    // undefined → don't pass columns to SVAR (use SVAR defaults).
+    // [] → pass false to SVAR (hide grid entirely).
+    // [...] → convert each column.
+    const svarColumns = useMemo(()=>{
+        if (columns === undefined) return undefined;
+        if (columns.length === 0) return false;
+        return columns.map(toSvarColumn);
+    }, [
+        columns
+    ]);
+    useImperativeHandle(ref, ()=>({
+            async exportPNG (options) {
+                const { exportPNG } = await import('./png-DKZeKnRh.js');
+                return exportPNG({
+                    scheduled,
+                    ganttProps: {
+                        cellWidth,
+                        cellHeight,
+                        markers,
+                        baselineIndex,
+                        showBaselineBars,
+                        columns,
+                        height,
+                        visibleTaskIds
+                    },
+                    options: options ?? {}
+                });
+            },
+            async exportPDF (options) {
+                const { exportPDF } = await import('./pdf-CBaoJRTI.js');
+                return exportPDF({
+                    scheduled,
+                    ganttProps: {
+                        cellWidth,
+                        cellHeight,
+                        markers,
+                        baselineIndex,
+                        showBaselineBars,
+                        columns,
+                        height,
+                        visibleTaskIds
+                    },
+                    options: options ?? {}
+                });
+            },
+            async exportXLSX (options) {
+                const { exportXLSX } = await import('./xlsx-5FRPFck7.js');
+                return exportXLSX({
+                    scheduled,
+                    options: options ?? {}
+                });
+            }
+        }), [
+        scheduled,
+        cellWidth,
+        cellHeight,
+        markers,
+        baselineIndex,
+        showBaselineBars,
+        columns,
+        height,
+        visibleTaskIds
+    ]);
+    return /*#__PURE__*/ jsx("div", {
+        ref: containerRef,
+        style: {
+            height
+        },
+        children: /*#__PURE__*/ jsx(Gantt$1, {
+            tasks: svarTasks,
+            links: svarLinks,
+            start: scheduled.start,
+            end: projectEnd,
+            cellWidth: cellWidth,
+            cellHeight: cellHeight,
+            markers: svarMarkers,
+            highlightTime: highlightTime,
+            taskTemplate: ConstructionBar,
+            ...svarColumns !== undefined ? {
+                columns: svarColumns
+            } : {}
+        })
+    });
+});
+const ConstructionBar = ({ data })=>{
+    // Phantom baseline row — render a slim outlined ghost bar.
+    if (data.is_baseline_ghost) {
+        return /*#__PURE__*/ jsx("div", {
+            style: {
+                height: '60%',
+                marginTop: '15%',
+                border: '1.5px dashed #94a3b8',
+                background: 'transparent',
+                borderRadius: 3,
+                fontSize: 9,
+                color: '#64748b',
+                display: 'flex',
+                alignItems: 'center',
+                padding: '0 6px',
+                fontStyle: 'italic',
+                whiteSpace: 'nowrap'
+            },
+            title: "Baseline position — where this task was when the baseline was captured",
+            children: "baseline"
+        });
+    }
+    const isCritical = data.is_critical ?? false;
+    const isLate = data.is_late ?? false;
+    const isSummary = data.type === 'summary';
+    const isMilestone = data.type === 'milestone';
+    if (isMilestone) {
+        return /*#__PURE__*/ jsxs("div", {
+            style: {
+                width: '100%',
+                height: '100%',
+                display: 'flex',
+                alignItems: 'center',
+                justifyContent: 'center',
+                color: isCritical ? '#fff' : '#1f2937',
+                fontWeight: 600,
+                fontSize: 11
+            },
+            children: [
+                "◆ ",
+                data.text
+            ]
+        });
+    }
+    const isSlipped = data.is_slipped ?? false;
+    const isAhead = data.is_ahead ?? false;
+    // Show slack indicator for non-critical, non-summary, non-milestone tasks
+    // with at least half a working day of total float. Skips the noise of "+5m"
+    // pills on the visually-critical path tasks.
+    const totalSlack = data.total_slack ?? 0;
+    const showSlackIndicator = !isSummary && !isCritical && totalSlack >= 270; // >= 30 min more than half a day
+    return /*#__PURE__*/ jsxs("div", {
+        style: {
+            display: 'flex',
+            alignItems: 'center',
+            gap: 6,
+            height: '100%',
+            padding: '0 8px',
+            fontSize: 12,
+            fontWeight: isSummary ? 600 : 500,
+            color: isCritical ? '#fff' : '#1f2937',
+            background: isSummary ? 'transparent' : isCritical ? '#dc2626' : '#cbd5e1',
+            borderRadius: 4,
+            border: isSummary ? '2px solid #1e293b' : undefined
+        },
+        children: [
+            /*#__PURE__*/ jsx("span", {
+                style: {
+                    flex: 1,
+                    overflow: 'hidden',
+                    textOverflow: 'ellipsis',
+                    whiteSpace: 'nowrap'
+                },
+                children: data.text
+            }),
+            isSlipped && /*#__PURE__*/ jsxs("span", {
+                style: {
+                    padding: '0 6px',
+                    background: '#fed7aa',
+                    color: '#7c2d12',
+                    borderRadius: 3,
+                    fontSize: 10,
+                    fontWeight: 700,
+                    lineHeight: '16px',
+                    whiteSpace: 'nowrap'
+                },
+                title: "Drifted later than the baseline",
+                children: [
+                    "+",
+                    workingMinutesToShortLabel(data.start_variance ?? 0)
+                ]
+            }),
+            isAhead && /*#__PURE__*/ jsxs("span", {
+                style: {
+                    padding: '0 6px',
+                    background: '#bbf7d0',
+                    color: '#14532d',
+                    borderRadius: 3,
+                    fontSize: 10,
+                    fontWeight: 700,
+                    lineHeight: '16px',
+                    whiteSpace: 'nowrap'
+                },
+                title: "Ahead of the baseline",
+                children: [
+                    "−",
+                    workingMinutesToShortLabel(data.start_variance ?? 0)
+                ]
+            }),
+            showSlackIndicator && /*#__PURE__*/ jsxs("span", {
+                style: {
+                    padding: '0 6px',
+                    background: '#dbeafe',
+                    color: '#1e3a8a',
+                    borderRadius: 3,
+                    fontSize: 10,
+                    fontWeight: 600,
+                    lineHeight: '16px',
+                    whiteSpace: 'nowrap'
+                },
+                title: "Total float — how much this task can slip before becoming critical",
+                children: [
+                    workingMinutesToShortLabel(totalSlack),
+                    " float"
+                ]
+            }),
+            isLate && /*#__PURE__*/ jsxs("span", {
+                style: {
+                    padding: '0 6px',
+                    background: '#fde68a',
+                    color: '#78350f',
+                    borderRadius: 3,
+                    fontSize: 10,
+                    fontWeight: 700,
+                    lineHeight: '16px',
+                    whiteSpace: 'nowrap'
+                },
+                title: "Negative slack — contract trouble",
+                children: [
+                    workingMinutesToShortLabel(data.total_slack ?? 0),
+                    " late"
+                ]
+            })
+        ]
+    });
+};
+function toSvarTask(t, baseline, calendar) {
+    const variance = baseline && calendar ? getTaskBaselineVariance(t, baseline, calendar) : undefined;
+    const startVariance = variance?.startVariance ?? 0;
+    const base = {
+        id: t.id,
+        text: t.text,
+        start: t.start,
+        end: t.end,
+        duration: t.duration,
+        progress: t.progress,
+        type: t.type,
+        parent: t.parent,
+        is_critical: t.computed?.isCritical ?? false,
+        is_late: (t.computed?.totalSlack ?? 0) < 0,
+        total_slack: t.computed?.totalSlack ?? 0,
+        start_variance: startVariance,
+        is_slipped: startVariance >= 30,
+        is_ahead: startVariance <= -30
+    };
+    // `open` only meaningful on summary tasks. Setting it on leaves trips
+    // SVAR's child-iteration path (null forEach).
+    if (t.type === 'summary') base.open = t.open ?? true;
+    return base;
+}
+function makeBaselinePhantom(t, baseline) {
+    const snap = baseline.tasks.get(t.id);
+    if (!snap) return null;
+    return {
+        id: `${t.id}-baseline-${baseline.index}`,
+        text: '(baseline)',
+        start: snap.start,
+        end: snap.end,
+        duration: snap.duration,
+        progress: 0,
+        type: 'task',
+        parent: t.parent,
+        is_baseline_ghost: true
+    };
+}
+function toSvarLink(l) {
+    return {
+        id: l.id,
+        source: l.source,
+        target: l.target,
+        type: dependencyTypeToSvar(l.type),
+        lag: l.lag
+    };
+}
+function dependencyTypeToSvar(t) {
+    switch(t){
+        case 'FS':
+            return 'e2s';
+        case 'SS':
+            return 's2s';
+        case 'FF':
+            return 'e2e';
+        case 'SF':
+            return 's2e';
+    }
+}
+function getProjectEnd(p) {
+    if (p.end) return p.end;
+    let latestMs = Number.NEGATIVE_INFINITY;
+    for (const t of p.tasks){
+        if (t.end.getTime() > latestMs) latestMs = t.end.getTime();
+    }
+    // Pad by one cell so the last bar isn't clipped to the right edge.
+    const cushion = 24 * 60 * 60 * 1000; // 1 day
+    return Number.isFinite(latestMs) ? new Date(latestMs + cushion) : new Date(p.start);
+}
+function resolveMarkers(userMarkers, projectStart, projectEnd) {
+    if (userMarkers) return userMarkers.map(toSvarMarker);
+    // Default: today line, only if today falls within the project window.
+    const today = new Date();
+    if (today >= projectStart && today <= projectEnd) {
+        return [
+            {
+                start: today,
+                text: 'Today',
+                css: 'construction-gantt-marker-today'
+            }
+        ];
+    }
+    return [];
+}
+function toSvarMarker(m) {
+    const css = m.css ?? (m.variant === 'milestone' ? 'construction-gantt-marker-milestone' : m.variant === 'today' ? 'construction-gantt-marker-today' : undefined);
+    return {
+        start: m.start,
+        text: m.text,
+        css
+    };
+}
+/**
+ * Convert a public GanttColumn to SVAR's IColumnConfig.
+ *
+ * render takes priority over field. When only field is set we emit a default
+ * cell that formats the value as a string (Date → ISO date, undefined → "").
+ * We cast row to our Task type directly — the relevant fields (id, text,
+ * start, end, duration, progress, type, parent, computed, constraint)
+ * all overlap. SVAR's internal $x/$y/$w computed fields are never passed
+ * through to the consumer's render prop.
+ */ function toSvarColumn(c) {
+    let cell;
+    if (c.render) {
+        const Render = c.render;
+        cell = (props)=>/*#__PURE__*/ jsx(Render, {
+                task: props.row
+            });
+    } else if (c.field) {
+        const field = c.field;
+        cell = (props)=>{
+            const task = props.row;
+            const value = task[field];
+            if (value === undefined || value === null) return /*#__PURE__*/ jsx("span", {});
+            if (value instanceof Date) return /*#__PURE__*/ jsx("span", {
+                children: value.toISOString().slice(0, 10)
+            });
+            return /*#__PURE__*/ jsx("span", {
+                children: String(value)
+            });
+        };
+    }
+    const config = {
+        id: c.id,
+        header: c.header,
+        ...c.width !== undefined ? {
+            width: c.width
+        } : {},
+        ...c.align !== undefined ? {
+            align: c.align
+        } : {},
+        ...cell !== undefined ? {
+            cell
+        } : {}
+    };
+    return config;
+}
+function buildHighlightTime(calendar) {
+    if (!calendar) return undefined;
+    return (date, unit)=>{
+        if (unit !== 'day') return '';
+        if (!isWorkingDay(date, calendar)) return 'construction-gantt-non-working';
+        return '';
+    };
+}
+function workingMinutesToShortLabel(minutes) {
+    const abs = Math.abs(minutes);
+    if (abs >= 540) {
+        // Approximate working-days from 9h-per-day. Display is "best-effort"
+        // since real durations depend on each task's calendar — good enough
+        // for an in-bar pill.
+        const days = Math.round(abs / 540);
+        return `${days}d`;
+    }
+    if (abs >= 60) {
+        const hours = Math.round(abs / 60);
+        return `${hours}h`;
+    }
+    return `${Math.round(abs)}m`;
+}
+
+// MSPDI XML → internal Project. Hand-mapped, supported-subset only.
+// Unrecognised MSPDI elements surface in `droppedFields` rather than
+// being silently discarded.
+// Field names we know about and either map or intentionally ignore on parse.
+// Everything outside this set lands in `droppedFields`.
+//
+// The list is intentionally broad: real MS Project exports emit ~50 fields
+// per Task, most of which are MS-Project-computed state (CPM results, EV,
+// rates, costs, leveling). We don't preserve these on round-trip — our
+// engine recomputes the equivalent fields. Listing them here keeps
+// `droppedFields` focused on genuinely-unknown elements rather than
+// recompute-able noise.
+const KNOWN_TASK_FIELDS = new Set([
+    // Mapped — read into the internal Task shape
+    'UID',
+    'ID',
+    'Name',
+    'Start',
+    'Finish',
+    'Duration',
+    'ConstraintType',
+    'Milestone',
+    'Summary',
+    'OutlineLevel',
+    'PredecessorLink',
+    'Baseline',
+    // Allowed but ignored (default-bearing structure or recompute-able state)
+    'Type',
+    'IsNull',
+    'CreateDate',
+    'WBS',
+    'OutlineNumber',
+    'Priority',
+    'PercentComplete',
+    'PercentWorkComplete',
+    'PhysicalPercentComplete',
+    'EarnedValueMethod',
+    'DurationFormat',
+    'Work',
+    'ResumeValid',
+    'EffortDriven',
+    'Recurring',
+    'OverAllocated',
+    'Estimated',
+    'Critical',
+    'IsSubproject',
+    'IsSubprojectReadOnly',
+    'ExternalTask',
+    // CPM results — recomputed by our engine
+    'EarlyStart',
+    'EarlyFinish',
+    'LateStart',
+    'LateFinish',
+    'StartVariance',
+    'FinishVariance',
+    'WorkVariance',
+    'FreeSlack',
+    'TotalSlack',
+    // Cost + work tracking — outside our v0.2 scope
+    'FixedCost',
+    'FixedCostAccrual',
+    'Cost',
+    'OvertimeCost',
+    'OvertimeWork',
+    'ActualDuration',
+    'ActualCost',
+    'ActualOvertimeCost',
+    'ActualWork',
+    'ActualOvertimeWork',
+    'RegularWork',
+    'RemainingDuration',
+    'RemainingCost',
+    'RemainingWork',
+    'RemainingOvertimeCost',
+    'RemainingOvertimeWork',
+    'ACWP',
+    'CV',
+    'BCWS',
+    'BCWP',
+    // Calendar override per task + leveling — not in our v0.2 scope
+    'CalendarUID',
+    'LevelAssignments',
+    'LevelingCanSplit',
+    'LevelingDelay',
+    'LevelingDelayFormat',
+    'IgnoreResourceCalendar',
+    'HideBar',
+    'Rollup',
+    // Server/publishing — meaningless outside MS Project Server context
+    'IsPublished',
+    'CommitmentType'
+]);
+const KNOWN_PROJECT_FIELDS = new Set([
+    'Name',
+    'Title',
+    'Author',
+    'StartDate',
+    'Tasks',
+    // ignored without dropping for v0.2 first cut (will be supported in
+    // future commits — listed here so we don't noise up droppedFields)
+    'Calendars',
+    'Resources',
+    'Assignments',
+    'WBSMasks',
+    'OutlineCodes',
+    'ExtendedAttributes',
+    // pure metadata that consumers should preserve via meta-roundtrip but
+    // doesn't enter our Project shape
+    'Manager',
+    'Company',
+    'Subject',
+    'Category',
+    'Keywords',
+    'Comments',
+    'CreationDate',
+    'LastSaved',
+    'FinishDate',
+    'CurrencyCode',
+    'ScheduleFromStart',
+    'FYStartDate',
+    'CriticalSlackLimit',
+    'CurrencyDigits',
+    'CurrencySymbol',
+    'CurrencySymbolPosition',
+    'CalendarUID',
+    'DefaultStartTime',
+    'DefaultFinishTime',
+    'MinutesPerDay',
+    'MinutesPerWeek',
+    'DaysPerMonth',
+    'DefaultTaskType',
+    'DefaultFixedCostAccrual',
+    'DefaultStandardRate',
+    'DefaultOvertimeRate',
+    'DurationFormat',
+    'WorkFormat',
+    'EditableActualCosts',
+    'HonorConstraints',
+    'EarnedValueMethod',
+    'InsertedProjectsLikeSummary',
+    'MultipleCriticalPaths',
+    'NewTasksEffortDriven',
+    'NewTasksEstimated',
+    'SplitsInProgressTasks',
+    'SpreadActualCost',
+    'SpreadPercentComplete',
+    'TaskUpdatesResource',
+    'FiscalYearStart',
+    'WeekStartDay',
+    'MoveCompletedEndsBack',
+    'MoveRemainingStartsBack',
+    'MoveRemainingStartsForward',
+    'MoveCompletedEndsForward',
+    'BaselineForEarnedValue',
+    'AutoAddNewResourcesAndTasks',
+    'StatusDate',
+    'CurrentDate',
+    'MicrosoftProjectServerURL',
+    'Autolink',
+    'NewTaskStartDate',
+    'DefaultTaskEVMethod',
+    'ProjectExternallyEdited',
+    'ExtendedCreationDate',
+    'ActualsInSync',
+    'AdminProject',
+    'RemoveFileProperties',
+    'SaveVersion',
+    'UID'
+]);
+const KNOWN_PREDECESSOR_FIELDS = new Set([
+    'PredecessorUID',
+    'Type',
+    'LinkLag',
+    'CrossProject',
+    'CrossProjectName',
+    // LagFormat is a magic number (7=minutes, 5=hours, 39=days) describing
+    // how the consumer should *display* LinkLag — we always normalize to
+    // minutes internally, so it's allowed-but-ignored.
+    'LagFormat'
+]);
+function parseMspdi(xml) {
+    const parser = new XMLParser({
+        ignoreAttributes: true,
+        isArray: (_name, jpath)=>jpath === 'Project.Tasks.Task' || jpath.endsWith('.PredecessorLink') || jpath === 'Project.Calendars.Calendar' || jpath === 'Project.Resources.Resource' || jpath === 'Project.Assignments.Assignment' || jpath.endsWith('.WeekDays.WeekDay') || jpath.endsWith('.WorkingTimes.WorkingTime') || jpath === 'Project.Tasks.Task.Baseline',
+        parseTagValue: false,
+        trimValues: true
+    });
+    const doc = parser.parse(xml);
+    const root = doc.Project;
+    if (!root) {
+        throw new Error('parseMspdi: <Project> root element missing');
+    }
+    const droppedFields = [];
+    // Scan the project-level fields we don't know about.
+    for (const [key, value] of Object.entries(root)){
+        if (KNOWN_PROJECT_FIELDS.has(key)) continue;
+        droppedFields.push({
+            path: `Project.${key}`,
+            value: stringifyForDiag(value),
+            reason: 'unsupported-element'
+        });
+    }
+    const tasks = [];
+    const links = [];
+    // Per-task baseline snapshots, keyed by baseline Number (BaselineIndex).
+    // Flattened into project.baselines below.
+    const baselineAccum = new Map();
+    const rawTasks = root.Tasks?.Task ?? [];
+    if (!Array.isArray(rawTasks)) {
+        throw new Error('parseMspdi: <Tasks> contained a non-array Task collection (malformed)');
+    }
+    for(let i = 0; i < rawTasks.length; i++){
+        const raw = rawTasks[i];
+        const taskPath = `Project.Tasks.Task[${i}]`;
+        // Map the supported fields.
+        const uid = String(raw.UID ?? raw.ID ?? '');
+        if (!uid) throw new Error(`parseMspdi: ${taskPath} missing UID and ID`);
+        const name = String(raw.Name ?? '');
+        const start = parseMspdiDate(String(raw.Start ?? ''));
+        const end = parseMspdiDate(String(raw.Finish ?? ''));
+        const duration = parseMspdiDuration(String(raw.Duration ?? 'PT0H0M0S'));
+        const isMilestone = String(raw.Milestone ?? '0') === '1';
+        const isSummary = String(raw.Summary ?? '0') === '1';
+        const taskType = isSummary ? 'summary' : isMilestone ? 'milestone' : 'task';
+        tasks.push({
+            id: uid,
+            text: name,
+            type: taskType,
+            scheduleMode: 'auto',
+            duration,
+            start,
+            end,
+            progress: 0
+        });
+        // Walk predecessor links nested inside the task.
+        const preds = Array.isArray(raw.PredecessorLink) ? raw.PredecessorLink : raw.PredecessorLink !== undefined ? [
+            raw.PredecessorLink
+        ] : [];
+        for(let p = 0; p < preds.length; p++){
+            const link = preds[p];
+            const srcUid = String(link.PredecessorUID ?? '');
+            if (!srcUid) continue;
+            const mspdiType = Number(link.Type ?? '1');
+            const linkType = mspdiTypeToDependencyType(mspdiType);
+            const lagTenthsOfMinute = Number(link.LinkLag ?? '0');
+            const lagMinutes = Math.round(lagTenthsOfMinute / 10);
+            links.push({
+                id: `${srcUid}-${uid}-${p}`,
+                source: srcUid,
+                target: uid,
+                type: linkType,
+                lag: lagMinutes
+            });
+            // Capture any unknown fields on the predecessor link.
+            for (const k of Object.keys(link)){
+                if (KNOWN_PREDECESSOR_FIELDS.has(k)) continue;
+                droppedFields.push({
+                    path: `${taskPath}.PredecessorLink[${p}].${k}`,
+                    value: stringifyForDiag(link[k]),
+                    reason: 'unsupported-element'
+                });
+            }
+        }
+        // Walk per-task <Baseline> children and accumulate into baselineAccum.
+        // MSPDI Baseline lives task-level (each task has up to 11 Baseline
+        // children with Number=0..10); our internal Baseline is project-level
+        // with a Map<TaskId, snapshot>. Pivot during parse.
+        const taskBaselines = Array.isArray(raw.Baseline) ? raw.Baseline : raw.Baseline !== undefined ? [
+            raw.Baseline
+        ] : [];
+        for(let b = 0; b < taskBaselines.length; b++){
+            const baselineRaw = taskBaselines[b];
+            const numberStr = String(baselineRaw.Number ?? '');
+            const number = Number(numberStr);
+            if (!Number.isFinite(number) || number < 0 || number > 10) {
+                droppedFields.push({
+                    path: `${taskPath}.Baseline[${b}].Number`,
+                    value: numberStr,
+                    reason: 'unsupported-element'
+                });
+                continue;
+            }
+            const index = number;
+            const snap = {
+                start: parseMspdiDate(String(baselineRaw.Start ?? '')),
+                end: parseMspdiDate(String(baselineRaw.Finish ?? '')),
+                duration: parseMspdiDuration(String(baselineRaw.Duration ?? 'PT0H0M0S'))
+            };
+            let acc = baselineAccum.get(index);
+            if (!acc) {
+                acc = new Map();
+                baselineAccum.set(index, acc);
+            }
+            acc.set(uid, snap);
+        }
+        // Scan the task-level fields we don't know about.
+        for (const [key, value] of Object.entries(raw)){
+            if (KNOWN_TASK_FIELDS.has(key)) continue;
+            droppedFields.push({
+                path: `${taskPath}.${key}`,
+                value: stringifyForDiag(value),
+                reason: 'unsupported-element'
+            });
+        }
+    }
+    const projectStart = root.StartDate ? parseMspdiDate(String(root.StartDate)) : tasks[0]?.start ?? new Date();
+    // Calendars. MSPDI optionally nests <Calendars><Calendar>+. Each Calendar's
+    // <WeekDays> contains DayType 1-7 entries (the recurring pattern) and
+    // DayType=0 entries with TimePeriod (exceptions). See toMspdiCalendar in
+    // serialize.ts for the inverse mapping.
+    const calendars = [];
+    const rawCalendars = root.Calendars?.Calendar ?? [];
+    if (Array.isArray(rawCalendars)) {
+        for(let i = 0; i < rawCalendars.length; i++){
+            const raw = rawCalendars[i];
+            calendars.push(parseMspdiCalendar(raw, `Project.Calendars.Calendar[${i}]`, droppedFields));
+        }
+    }
+    // Resources. v0.2 first cut maps only UID + Name + CalendarUID; rates,
+    // types, units, cost, and other MS Project resource fields are
+    // intentionally ignored without dropping (we don't yet model them).
+    const resources = [];
+    const rawResources = root.Resources?.Resource ?? [];
+    if (Array.isArray(rawResources)) {
+        for(let i = 0; i < rawResources.length; i++){
+            const raw = rawResources[i];
+            resources.push(parseMspdiResource(raw, `Project.Resources.Resource[${i}]`, droppedFields));
+        }
+    }
+    // Assignments. v0.2 first cut maps only UID + TaskUID + ResourceUID + Units
+    // (the resource-to-task allocation triple). Per-day timephased data, cost
+    // tracking, and EV fields don't enter our model — they appear in
+    // droppedFields if present.
+    const assignments = [];
+    const rawAssignments = root.Assignments?.Assignment ?? [];
+    if (Array.isArray(rawAssignments)) {
+        for(let i = 0; i < rawAssignments.length; i++){
+            const raw = rawAssignments[i];
+            assignments.push(parseMspdiAssignment(raw, `Project.Assignments.Assignment[${i}]`, droppedFields));
+        }
+    }
+    // Pick a sensible defaultCalendarId. Prefer the first calendar with
+    // `IsBaseCalendar` 1; fall back to the first calendar; fall back to 'std'.
+    let defaultCalendarId = 'std';
+    const firstCalendar = calendars[0];
+    if (firstCalendar) {
+        const firstBase = calendars.find((c)=>c.baseCalendarId === undefined);
+        defaultCalendarId = String((firstBase ?? firstCalendar).id);
+    }
+    // Flatten the per-task baseline accumulator into our project-level
+    // Baseline[] shape. Sort by index for stable order.
+    const baselines = [];
+    for (const [index, taskMap] of baselineAccum){
+        baselines.push({
+            index,
+            // MSPDI doesn't carry baseline name or capturedAt on individual snapshots;
+            // synthesize defaults. Consumers who want named baselines can populate
+            // these after parse.
+            capturedAt: new Date(0),
+            tasks: taskMap
+        });
+    }
+    baselines.sort((a, b)=>a.index - b.index);
+    const project = {
+        start: projectStart,
+        defaultCalendarId,
+        tasks,
+        links,
+        resources,
+        calendars,
+        baselines,
+        assignments
+    };
+    return {
+        project,
+        droppedFields
+    };
+}
+const KNOWN_CALENDAR_FIELDS = new Set([
+    'UID',
+    'Name',
+    'IsBaseCalendar',
+    'BaseCalendarUID',
+    'WeekDays'
+]);
+const KNOWN_WEEKDAY_FIELDS = new Set([
+    'DayType',
+    'DayWorking',
+    'WorkingTimes',
+    'TimePeriod'
+]);
+// v0.2 first cut: only UID + Name + CalendarUID enter our Resource shape.
+// Other fields exist in real MS Project exports — listed here as
+// allowed-but-ignored so they don't noise up droppedFields.
+const KNOWN_RESOURCE_FIELDS = new Set([
+    // Mapped
+    'UID',
+    'ID',
+    'Name',
+    'CalendarUID',
+    // Allowed but ignored (no internal model yet)
+    'IsNull',
+    'Initials',
+    'Group',
+    'Code',
+    'EmailAddress',
+    'WindowsUserAccount',
+    'Type',
+    'IsGeneric',
+    'IsInactive',
+    'IsEnterprise',
+    'BookingType',
+    'MaterialLabel',
+    'AccrueAt',
+    'MaxUnits',
+    'PeakUnits',
+    'OverAllocated',
+    'AvailableFrom',
+    'AvailableTo',
+    'StandardRate',
+    'StandardRateFormat',
+    'OvertimeRate',
+    'OvertimeRateFormat',
+    'CostPerUse',
+    'Cost',
+    'CostVariance',
+    'OvertimeCost',
+    'ActualCost',
+    'ActualOvertimeCost',
+    'RemainingCost',
+    'RemainingOvertimeCost',
+    'CostCenter',
+    'BudgetCost',
+    'BaselineCost',
+    'Work',
+    'RegularWork',
+    'OvertimeWork',
+    'ActualWork',
+    'RemainingWork',
+    'ActualOvertimeWork',
+    'RemainingOvertimeWork',
+    'PercentWorkComplete',
+    'WorkVariance',
+    'StartVariance',
+    'FinishVariance',
+    'BudgetWork',
+    'BaselineWork',
+    'ACWP',
+    'CV',
+    'BCWS',
+    'BCWP',
+    'Start',
+    'Finish',
+    'CanLevel',
+    'NotesText',
+    'NotesRTF',
+    'CreationDate',
+    'Hyperlink',
+    'HyperlinkAddress',
+    'HyperlinkSubAddress',
+    'PhoneticAlias',
+    'ExtendedAttribute',
+    'Baseline',
+    'OutlineCode',
+    'TimephasedData'
+]);
+// v0.2 first cut: only UID + TaskUID + ResourceUID + Units enter our
+// Assignment shape. Per-day timephased data, cost tracking, EV fields,
+// and confirmed/leveled times are all allowed-but-ignored.
+const KNOWN_ASSIGNMENT_FIELDS = new Set([
+    // Mapped
+    'UID',
+    'TaskUID',
+    'ResourceUID',
+    'Units',
+    // Allowed but ignored (no internal model yet)
+    'PercentWorkComplete',
+    'ActualCost',
+    'ActualWork',
+    'Cost',
+    'CostVariance',
+    'Work',
+    'WorkVariance',
+    'StartVariance',
+    'FinishVariance',
+    'OvertimeCost',
+    'OvertimeWork',
+    'ActualOvertimeCost',
+    'ActualOvertimeWork',
+    'RegularWork',
+    'RemainingCost',
+    'RemainingWork',
+    'RemainingOvertimeCost',
+    'RemainingOvertimeWork',
+    'ConfirmedFinish',
+    'ConfirmedStart',
+    'Start',
+    'Finish',
+    'Stop',
+    'Resume',
+    'ResumeValid',
+    'LevelingDelay',
+    'LevelingDelayFormat',
+    'Delay',
+    'NotesText',
+    'NotesRTF',
+    'Hyperlink',
+    'HyperlinkAddress',
+    'HyperlinkSubAddress',
+    'CostRateTable',
+    'BookingType',
+    'ActualStart',
+    'ActualFinish',
+    'WorkContour',
+    'BudgetCost',
+    'BudgetWork',
+    'BaselineCost',
+    'BaselineWork',
+    'BaselineStart',
+    'BaselineFinish',
+    'BaselineBudgetCost',
+    'BaselineBudgetWork',
+    'ACWP',
+    'CV',
+    'BCWS',
+    'BCWP',
+    'Baseline',
+    'ExtendedAttribute',
+    'TimephasedData',
+    'CreationDate'
+]);
+function parseMspdiCalendar(raw, path, droppedFields) {
+    const id = String(raw.UID ?? raw.Name ?? 'std');
+    const name = String(raw.Name ?? id);
+    const workWeek = [
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        []
+    ];
+    const exceptions = [];
+    const weekDays = raw.WeekDays?.WeekDay ?? [];
+    if (Array.isArray(weekDays)) {
+        for(let i = 0; i < weekDays.length; i++){
+            const wd = weekDays[i];
+            const wdPath = `${path}.WeekDays.WeekDay[${i}]`;
+            const dayType = Number(wd.DayType ?? '0');
+            const dayWorking = String(wd.DayWorking ?? '0') === '1';
+            if (dayType >= 1 && dayType <= 7) {
+                // Recurring weekday — DayType 1=Sun ... 7=Sat → DayOfWeek 0=Sun ... 6=Sat
+                const dayOfWeek = dayType - 1;
+                workWeek[dayOfWeek] = dayWorking ? parseWorkingTimes(wd) : [];
+            } else if (dayType === 0) {
+                // Exception entry
+                const timePeriod = wd.TimePeriod;
+                if (!timePeriod) continue;
+                const fromDate = parseMspdiDate(String(timePeriod.FromDate ?? ''));
+                // Treat as single-day exception, anchored on FromDate's local-day boundary.
+                const anchored = new Date(fromDate.getFullYear(), fromDate.getMonth(), fromDate.getDate());
+                const ex = {
+                    date: anchored,
+                    isWorking: dayWorking
+                };
+                if (dayWorking) {
+                    const intervals = parseWorkingTimes(wd);
+                    if (intervals.length) ex.intervals = intervals;
+                }
+                exceptions.push(ex);
+            }
+            // Scan unknown WeekDay fields
+            for (const k of Object.keys(wd)){
+                if (KNOWN_WEEKDAY_FIELDS.has(k)) continue;
+                droppedFields.push({
+                    path: `${wdPath}.${k}`,
+                    value: stringifyForDiag(wd[k]),
+                    reason: 'unsupported-element'
+                });
+            }
+        }
+    }
+    // Scan unknown Calendar fields
+    for (const k of Object.keys(raw)){
+        if (KNOWN_CALENDAR_FIELDS.has(k)) continue;
+        droppedFields.push({
+            path: `${path}.${k}`,
+            value: stringifyForDiag(raw[k]),
+            reason: 'unsupported-element'
+        });
+    }
+    const calendar = {
+        id,
+        name,
+        workWeek,
+        exceptions
+    };
+    // BaseCalendarUID — MS Project uses -1 for "no base". Treat -1 or absent
+    // as top-level; otherwise carry through.
+    const baseUid = raw.BaseCalendarUID !== undefined ? String(raw.BaseCalendarUID) : undefined;
+    if (baseUid !== undefined && baseUid !== '-1') {
+        calendar.baseCalendarId = baseUid;
+    }
+    return calendar;
+}
+function parseWorkingTimes(wd) {
+    const wt = wd.WorkingTimes;
+    if (!wt) return [];
+    const arr = wt.WorkingTime;
+    if (!Array.isArray(arr)) return [];
+    const intervals = [];
+    for (const w of arr){
+        const wRec = w;
+        const fromTime = String(wRec.FromTime ?? '');
+        const toTime = String(wRec.ToTime ?? '');
+        intervals.push({
+            startMinutes: parseMspdiTime(fromTime),
+            endMinutes: parseMspdiTime(toTime)
+        });
+    }
+    return intervals;
+}
+function parseMspdiTime(s) {
+    // `HH:MM:SS` → minutes-from-midnight. Seconds truncated.
+    const match = s.match(/^(\d{1,2}):(\d{2}):(\d{2})$/);
+    if (!match) return 0;
+    return Number(match[1]) * 60 + Number(match[2]);
+}
+const MSPDI_TYPE_TO_DEPENDENCY = {
+    0: 'FF',
+    1: 'FS',
+    2: 'SF',
+    3: 'SS'
+};
+function mspdiTypeToDependencyType(t) {
+    return MSPDI_TYPE_TO_DEPENDENCY[t] ?? 'FS';
+}
+function parseMspdiDate(s) {
+    // MSPDI emits ISO 8601 like `2026-01-05T08:00:00` (no timezone in
+    // practice; MS Project writes local time). We treat it as local.
+    return new Date(s);
+}
+function parseMspdiDuration(s) {
+    // MSPDI duration format: `PT{H}H{M}M{S}S` where each component is
+    // optional (e.g. `PT24H0M0S`, `PT0H30M0S`). Returns total minutes
+    // (seconds truncated).
+    const match = s.match(/^PT(\d+)H(\d+)M(\d+)S$/);
+    if (match) {
+        return Number(match[1]) * 60 + Number(match[2]);
+    }
+    // Looser fallback — support `PT{N}M` shorthand.
+    const looseMin = s.match(/^PT(\d+)M$/);
+    if (looseMin) return Number(looseMin[1]);
+    const looseHr = s.match(/^PT(\d+)H$/);
+    if (looseHr) return Number(looseHr[1]) * 60;
+    return 0;
+}
+function stringifyForDiag(v) {
+    if (v === null || v === undefined) return '';
+    if (typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean') return String(v);
+    try {
+        return JSON.stringify(v).slice(0, 200);
+    } catch  {
+        return '<unstringifiable>';
+    }
+}
+// ---------------------------------------------------------------------------
+// Resources
+// ---------------------------------------------------------------------------
+function parseMspdiResource(raw, path, droppedFields) {
+    const id = String(raw.UID ?? raw.ID ?? '');
+    const name = String(raw.Name ?? '');
+    const resource = {
+        id,
+        name
+    };
+    // CalendarUID — MS Project uses -1 for "no override". Treat -1, absent,
+    // or empty as "use project default"; otherwise carry through.
+    const calUid = raw.CalendarUID !== undefined ? String(raw.CalendarUID) : undefined;
+    if (calUid !== undefined && calUid !== '-1' && calUid !== '') {
+        resource.calendarId = calUid;
+    }
+    // Scan unknown Resource fields
+    for (const k of Object.keys(raw)){
+        if (KNOWN_RESOURCE_FIELDS.has(k)) continue;
+        droppedFields.push({
+            path: `${path}.${k}`,
+            value: stringifyForDiag(raw[k]),
+            reason: 'unsupported-element'
+        });
+    }
+    return resource;
+}
+// ---------------------------------------------------------------------------
+// Assignments
+// ---------------------------------------------------------------------------
+function parseMspdiAssignment(raw, path, droppedFields) {
+    const id = String(raw.UID ?? '');
+    const taskId = String(raw.TaskUID ?? '');
+    const resourceId = String(raw.ResourceUID ?? '');
+    const assignment = {
+        id,
+        taskId,
+        resourceId
+    };
+    // Units default 1.0. MSPDI stores as a decimal string. Treat absent/empty
+    // or unparseable as 1.0; only emit if it differs from the default.
+    if (raw.Units !== undefined) {
+        const units = Number(raw.Units);
+        if (Number.isFinite(units) && units !== 1) {
+            assignment.units = units;
+        }
+    }
+    // Scan unknown Assignment fields. TimephasedData specifically is large +
+    // commonly present in real MS Project exports — listing it as
+    // allowed-but-ignored is the honest position until we add a per-day
+    // allocation model (v0.4+).
+    for (const k of Object.keys(raw)){
+        if (KNOWN_ASSIGNMENT_FIELDS.has(k)) continue;
+        droppedFields.push({
+            path: `${path}.${k}`,
+            value: stringifyForDiag(raw[k]),
+            reason: 'unsupported-element'
+        });
+    }
+    return assignment;
+}
+
+// Internal Project → MSPDI XML. Hand-mapped, supported-subset only.
+// Inverse of `parseMspdi` for the fields enumerated in this module's
+// KNOWN_TASK_FIELDS + KNOWN_PROJECT_FIELDS sets.
+function serializeMspdi(project, options = {}) {
+    const meta = options.meta ?? {};
+    const name = meta.name ?? 'Untitled';
+    const title = meta.title ?? name;
+    // Group links by target so we can nest PredecessorLink elements inside Task.
+    const linksByTarget = new Map();
+    for (const link of project.links){
+        const key = String(link.target);
+        const arr = linksByTarget.get(key) ?? [];
+        arr.push(link);
+        linksByTarget.set(key, arr);
+    }
+    // Group baselines by taskId. Each task may have one snapshot per baseline
+    // (0-10), emitted as <Baseline> children nested inside the task.
+    const baselinesByTask = buildBaselinesByTask(project.baselines);
+    const tasksOut = project.tasks.map((t, idx)=>{
+        const taskOut = {
+            UID: String(t.id),
+            ID: String(idx + 1),
+            Name: t.text,
+            Start: formatMspdiDate(t.start),
+            Finish: formatMspdiDate(t.end),
+            Duration: formatMspdiDuration(t.duration),
+            ConstraintType: 0,
+            Milestone: t.type === 'milestone' ? 1 : 0,
+            Summary: t.type === 'summary' ? 1 : 0,
+            OutlineLevel: 1
+        };
+        const incoming = linksByTarget.get(String(t.id));
+        if (incoming?.length) {
+            taskOut.PredecessorLink = incoming.map(toMspdiLink);
+        }
+        const taskBaselines = baselinesByTask.get(String(t.id));
+        if (taskBaselines?.length) {
+            taskOut.Baseline = taskBaselines;
+        }
+        return taskOut;
+    });
+    const calendarsOut = project.calendars.map(toMspdiCalendar);
+    const resourcesOut = project.resources.map(toMspdiResource);
+    const assignmentsOut = project.assignments.map(toMspdiAssignment);
+    const projectRoot = {
+        Name: name,
+        Title: title,
+        ...meta.author !== undefined ? {
+            Author: meta.author
+        } : {},
+        StartDate: formatMspdiDate(project.start),
+        ...calendarsOut.length > 0 ? {
+            Calendars: {
+                Calendar: calendarsOut
+            }
+        } : {},
+        ...resourcesOut.length > 0 ? {
+            Resources: {
+                Resource: resourcesOut
+            }
+        } : {},
+        Tasks: {
+            Task: tasksOut
+        },
+        ...assignmentsOut.length > 0 ? {
+            Assignments: {
+                Assignment: assignmentsOut
+            }
+        } : {}
+    };
+    const builder = new XMLBuilder({
+        ignoreAttributes: true,
+        format: true,
+        indentBy: '  ',
+        suppressEmptyNode: true,
+        suppressBooleanAttributes: true,
+        processEntities: true
+    });
+    const inner = builder.build({
+        Project: projectRoot
+    });
+    // fast-xml-parser doesn't emit a namespace on the root, so we inject
+    // the standard MSPDI namespace declaration. Trim leading whitespace
+    // first so the regex anchor is reliable.
+    const trimmed = inner.replace(/^\s+/, '');
+    const withNamespace = trimmed.replace(/^<Project>/, '<Project xmlns="http://schemas.microsoft.com/project">');
+    return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n${withNamespace}`;
+}
+function toMspdiLink(link) {
+    return {
+        PredecessorUID: String(link.source),
+        Type: dependencyTypeToMspdi(link.type),
+        LinkLag: (link.lag ?? 0) * 10
+    };
+}
+function dependencyTypeToMspdi(t) {
+    switch(t){
+        case 'FF':
+            return 0;
+        case 'FS':
+            return 1;
+        case 'SF':
+            return 2;
+        case 'SS':
+            return 3;
+    }
+}
+function formatMspdiDate(d) {
+    // MSPDI emits local time without timezone (e.g. `2026-01-05T08:00:00`).
+    const pad = (n)=>String(n).padStart(2, '0');
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}` + `T${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+}
+function formatMspdiDuration(totalMinutes) {
+    const hours = Math.floor(totalMinutes / 60);
+    const minutes = totalMinutes % 60;
+    return `PT${hours}H${minutes}M0S`;
+}
+// ---------------------------------------------------------------------------
+// Calendars
+// ---------------------------------------------------------------------------
+function toMspdiCalendar(cal) {
+    const weekDays = [];
+    // 7 recurring entries — MSPDI DayType 1=Sun … 7=Sat; our DayOfWeek 0=Sun … 6=Sat
+    for(let dayOfWeek = 0; dayOfWeek < 7; dayOfWeek++){
+        const intervals = cal.workWeek[dayOfWeek] ?? [];
+        weekDays.push(toRecurringWeekDay(dayOfWeek + 1, intervals));
+    }
+    // Exception entries — DayType=0 with TimePeriod
+    for (const ex of cal.exceptions){
+        weekDays.push(toExceptionWeekDay(ex));
+    }
+    return {
+        UID: String(cal.id),
+        Name: cal.name,
+        IsBaseCalendar: cal.baseCalendarId === undefined ? 1 : 0,
+        WeekDays: {
+            WeekDay: weekDays
+        }
+    };
+}
+function toRecurringWeekDay(mspdiDayType, intervals) {
+    const working = intervals.length > 0;
+    const out = {
+        DayType: mspdiDayType,
+        DayWorking: working ? 1 : 0
+    };
+    if (working) {
+        out.WorkingTimes = {
+            WorkingTime: intervals.map(toMspdiWorkingTime)
+        };
+    }
+    return out;
+}
+function toExceptionWeekDay(ex) {
+    const dayStart = startOfDay(ex.date);
+    const dayEnd = endOfDay(ex.date);
+    const out = {
+        DayType: 0,
+        DayWorking: ex.isWorking ? 1 : 0,
+        TimePeriod: {
+            FromDate: formatMspdiDate(dayStart),
+            ToDate: formatMspdiDate(dayEnd)
+        }
+    };
+    if (ex.isWorking && ex.intervals?.length) {
+        out.WorkingTimes = {
+            WorkingTime: ex.intervals.map(toMspdiWorkingTime)
+        };
+    }
+    return out;
+}
+function toMspdiWorkingTime(w) {
+    return {
+        FromTime: formatMspdiTime(w.startMinutes),
+        ToTime: formatMspdiTime(w.endMinutes)
+    };
+}
+function formatMspdiTime(minutesFromMidnight) {
+    const h = Math.floor(minutesFromMidnight / 60);
+    const m = minutesFromMidnight % 60;
+    const pad = (n)=>String(n).padStart(2, '0');
+    return `${pad(h)}:${pad(m)}:00`;
+}
+function startOfDay(d) {
+    return new Date(d.getFullYear(), d.getMonth(), d.getDate(), 0, 0, 0);
+}
+function endOfDay(d) {
+    return new Date(d.getFullYear(), d.getMonth(), d.getDate(), 23, 59, 0);
+}
+// ---------------------------------------------------------------------------
+// Resources
+// ---------------------------------------------------------------------------
+function toMspdiResource(r, idx) {
+    return {
+        UID: String(r.id),
+        ID: String(idx + 1),
+        Name: r.name,
+        Type: 1,
+        CalendarUID: r.calendarId !== undefined ? String(r.calendarId) : '-1'
+    };
+}
+// ---------------------------------------------------------------------------
+// Assignments
+// ---------------------------------------------------------------------------
+function toMspdiAssignment(a) {
+    return {
+        UID: String(a.id),
+        TaskUID: String(a.taskId),
+        ResourceUID: String(a.resourceId),
+        Units: (a.units ?? 1).toString()
+    };
+}
+// ---------------------------------------------------------------------------
+// Baselines
+// ---------------------------------------------------------------------------
+/**
+ * Pivot project-level baselines into per-task entries for MSPDI emission.
+ * Each task ends up with a sorted list of <Baseline> children (one per
+ * baseline that has a snapshot for that task).
+ */ function buildBaselinesByTask(baselines) {
+    const out = new Map();
+    // Sort by baseline index so emission order is stable.
+    const sorted = [
+        ...baselines
+    ].sort((a, b)=>a.index - b.index);
+    for (const baseline of sorted){
+        for (const [taskId, snap] of baseline.tasks){
+            const key = String(taskId);
+            const entry = {
+                Number: baseline.index,
+                Start: formatMspdiDate(snap.start),
+                Finish: formatMspdiDate(snap.end),
+                Duration: formatMspdiDuration(snap.duration)
+            };
+            const existing = out.get(key);
+            if (existing) {
+                existing.push(entry);
+            } else {
+                out.set(key, [
+                    entry
+                ]);
+            }
+        }
+    }
+    return out;
+}
+
+function isWeekend(date) {
+    const day = date.getDay();
+    return day === 0 || day === 6;
+}
+const baseTasks = [
+    {
+        id: 1,
+        text: 'Site preparation',
+        start: new Date(2026, 0, 5),
+        end: new Date(2026, 0, 9),
+        duration: 5,
+        type: 'task',
+        progress: 100
+    },
+    {
+        id: 2,
+        text: 'Foundation pour',
+        start: new Date(2026, 0, 10),
+        end: new Date(2026, 0, 14),
+        duration: 5,
+        type: 'task',
+        progress: 60
+    },
+    {
+        id: 3,
+        text: 'Framing',
+        start: new Date(2026, 0, 15),
+        end: new Date(2026, 0, 22),
+        duration: 8,
+        type: 'task',
+        progress: 20
+    },
+    {
+        id: 4,
+        text: 'Council inspection',
+        start: new Date(2026, 0, 23),
+        end: new Date(2026, 0, 23),
+        duration: 0,
+        type: 'milestone',
+        progress: 0
+    }
+];
+const spikeTasks = baseTasks.map((task)=>({
+        ...task,
+        is_weekend_start: task.start ? isWeekend(task.start) : false
+    }));
+const SpikeTaskBar = ({ data })=>{
+    return /*#__PURE__*/ jsxs("div", {
+        style: {
+            display: 'flex',
+            alignItems: 'center',
+            gap: 6,
+            height: '100%',
+            padding: '0 6px',
+            fontSize: 12,
+            color: '#1f2937'
+        },
+        children: [
+            /*#__PURE__*/ jsx("span", {
+                children: data.text
+            }),
+            data.is_weekend_start && /*#__PURE__*/ jsx("span", {
+                style: {
+                    padding: '0 6px',
+                    background: '#fde68a',
+                    color: '#78350f',
+                    borderRadius: 4,
+                    fontSize: 10,
+                    fontWeight: 600,
+                    lineHeight: '16px'
+                },
+                children: "starts weekend"
+            })
+        ]
+    });
+};
+function SpikeGantt() {
+    return /*#__PURE__*/ jsx("div", {
+        style: {
+            height: 420
+        },
+        children: /*#__PURE__*/ jsx(Gantt$1, {
+            tasks: spikeTasks,
+            taskTemplate: SpikeTaskBar,
+            start: new Date(2026, 0, 1),
+            end: new Date(2026, 1, 1),
+            cellWidth: 36,
+            cellHeight: 42
+        })
+    });
+}
+
+export { EditError, Gantt, SpikeGantt, addWorkingMinutes, captureBaseline, createTask, deleteLink, deleteTask, getCriticalPath, getDayWorkingMinutes, getProjectStats, getTaskBaselineVariance, getTaskBaselineVarianceAll, isWorkingDay, linkTasks, nzDefaultCalendar, nzPublicHolidays, parseMspdi, renameTask, schedule, serializeMspdi, setTaskDuration, setTaskProgress, setTaskStart, snapToNextWorkingMoment, snapToPreviousWorkingMoment, subtractWorkingMinutes, topologicalSort, updateLink, updateTask, useEditableProject, workingMinutesBetween };