@northguild/gmt 1.19.0 → 1.20.0

package/dist/internal/dutyEngine.js

@@ -1,15 +1,14 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "./temporal.js";
 import { parseDutyLog } from "./dutyLog.js";
 import { calendarScale, datePlusDays, localDateOf, operatorDayScale, periodAfter, periodsEndingAt, resolveWallClock, WallClockRejected, } from "./dutyPeriods.js";
 import { MAX_PERIOD_COUNT, parseDutyRules, usesOperatorDays, } from "./dutyRules.js";
+import { countEvents, countInRange, latestPairFrom, createRunStore, endingAtOrBefore, entryHolding, firstEndingAfter, firstEntryIn, firstStartingAtOrAfter, firstWhere, interruptionResetAt, lastAtLeastUntil, lastEntryBefore, latestAtLeast, logStartBefore, runEndingAt, runIndex, runsMatching, runsUntil, timeInBefore, viewRun, } from "./dutyRunIndex.js";
+import { MIN_EPOCH_NANOSECONDS } from "./epochNanoseconds.js";
 import { isObject } from "./isObject.js";
 import { parseScheduleDisambiguation } from "./operatingSchedule.js";
 import { formatHourDuration } from "./hourDurationString.js";
-import { coalesceIntervalNanoseconds } from "./intervalNanoseconds.js";
 import { zoneFrame } from "./zoneFrame.js";
 import { parseDayStartTime } from "./dutyPeriods.js";
-/** TC39 `nsMinInstant`: a window never reaches back past the first instant. */
-const MIN_INSTANT_NANOSECONDS = -8640000000000000000000n;
 /** A window a call cannot place in Temporal's range. Caught by the public function. */
 export class Unrepresentable extends RangeError {
 }
@@ -67,7 +66,7 @@ export function prepareDutyCall(log, rules, options) {
             scales: new Map(),
             wallClocks: new Map(),
             windowInstances: new Map(),
-            runs: new Map(),
+            store: createRunStore(entries),
         },
         rules: resolved,
     };
@@ -90,18 +89,6 @@ function scaleFor(context, unit) {
     context.scales.set(unit, scale);
     return scale;
 }
-/** The log as it stands at `at`: later entries dropped, one straddling `at` cut there. */
-function clip(entries, at) {
-    const clipped = [];
-    for (const entry of entries) {
-        if (entry.start >= at) {
-            break;
-        }
-        clipped.push(entry.end > at ? { ...entry, end: at } : entry);
-    }
-    return clipped;
-}
-const matches = (test, status) => typeof test === "function" ? test(status) : test.has(status);
 /**
  * Read a status list a helper takes: an array of strings, `[]` allowed. Each element is read once.
  *
@@ -128,19 +115,7 @@ export function readStatusList(value) {
  * them (CORE-6): touching entries join, and a gap or another status ends a run.
  */
 export function runsOf(log, test) {
-    return coalesceIntervalNanoseconds(log
-        .filter((entry) => matches(test, entry.status))
-        .map(({ start, end }) => ({ start, end, startText: "", endText: "" }))).map(({ start, end }) => ({ start, end }));
-}
-/** The runs of the whole log in a set of statuses, found once per call and kept. */
-function logRuns(context, statuses) {
-    const known = context.runs.get(statuses);
-    if (known !== undefined) {
-        return known;
-    }
-    const found = runsOf(context.entries, statuses);
-    context.runs.set(statuses, found);
-    return found;
+    return runsMatching(log, (status) => test.has(status));
 }
 /**
  * The parts of ordered, separate runs inside `[from, to)`, empty parts dropped: `clipRuns`, with
@@ -185,7 +160,7 @@ export function clipRuns(runs, from, to) {
 export function timeIn(log, statuses, from, to) {
     let total = 0n;
     for (const entry of log) {
-        if (matches(statuses, entry.status)) {
+        if (statuses.has(entry.status)) {
             const start = max(entry.start, from);
             const end = min(entry.end, to);
             total += end > start ? end - start : 0n;
@@ -193,16 +168,6 @@ export function timeIn(log, statuses, from, to) {
     }
     return total;
 }
-/** The latest run at least `minimum` long. */
-function lastAtLeast(runs, minimum) {
-    for (let index = runs.length - 1; index >= 0; index--) {
-        const run = runs[index];
-        if (length(run) >= minimum) {
-            return run;
-        }
-    }
-    return undefined;
-}
 /**
  * The paired rests among runs of rest: two runs in a row, each shorter than `fullRest` and at
  * least `pair.each`, the longer at least `pair.one` and both together at least `pair.combined`.
@@ -249,7 +214,7 @@ function windowOf(context, period, at, anchor) {
     if (period.kind === "elapsed") {
         return {
             span: {
-                start: max(at - period.length, MIN_INSTANT_NANOSECONDS),
+                start: max(at - period.length, MIN_EPOCH_NANOSECONDS),
                 end: at,
             },
             basis: "elapsed",
@@ -525,7 +490,7 @@ function evaluateFreePeriod(context, rule, at, anchor) {
     const window = windowOf(context, rule.within, at, anchor);
     // Every count below ends at or before `at`, so the runs of the whole log, cut to the count's
     // span, are the runs of the log as it stands at `at`.
-    const rests = logRuns(context, rule.restStatuses);
+    const rests = runIndex(context.store, rule.restStatuses).runs;
     const countIn = (from, to, extendTo) => {
         const inside = runsBetween(rests, from, to);
         const runs = extendTo === undefined ? inside : withRestUntil(inside, at, extendTo);
@@ -605,11 +570,66 @@ function evaluateFreePeriod(context, rule, at, anchor) {
         grouping: groupingOf(window),
     };
 }
-function evaluateRestRequirement(context, rule, log, at, anchor) {
+/**
+ * The stretches without rest in the log as it stood at `at`: each runs from the end of one rest to
+ * the start of the next, the last to `at` (or nowhere, when a rest reaches `at`). The log's first
+ * entry starts one too, as a rest ending there would: time before the log is unknown, but the work
+ * logged before the first rest is a stretch without rest like any other.
+ */
+function restGaps(rests, logStart, at) {
+    const taken = rests.count;
+    const resting = rests.last !== undefined && rests.last.end === at;
+    const prepended = logStart !== undefined &&
+        (taken === 0 || viewRun(rests, 0).start !== logStart);
+    const startAt = (gap) => prepended
+        ? gap === 0
+            ? logStart
+            : viewRun(rests, gap - 1).end
+        : viewRun(rests, gap).end;
+    const endAt = (gap) => {
+        const next = prepended ? gap : gap + 1;
+        return next < taken
+            ? viewRun(rests, next).start
+            : resting
+                ? startAt(gap)
+                : at;
+    };
+    return {
+        count: prepended ? taken + 1 : taken,
+        resting,
+        startAt,
+        endAt,
+    };
+}
+/**
+ * The longest stretch without rest touching `[from, to)`, found from the first that ends after
+ * `from`.
+ */
+function widestGap(gaps, from, to) {
+    let widest = 0n;
+    for (let gap = firstWhere(gaps.count, (position) => gaps.endAt(position) > from); gap < gaps.count && gaps.startAt(gap) < to; gap++) {
+        widest = max(widest, gaps.endAt(gap) - gaps.startAt(gap));
+    }
+    return widest;
+}
+/** The widest stretch without rest in `[from, upper)` at `at`, and when the next rest falls due. */
+function widestRestGap(context, index, at, from, upper, maxGap) {
+    const gaps = restGaps(runsUntil(index, at), logStartBefore(context.store, at), at);
+    return {
+        widest: widestGap(gaps, from, upper),
+        dueBy: gaps.count > 0 && !gaps.resting
+            ? gaps.startAt(gaps.count - 1) + maxGap
+            : null,
+    };
+}
+function evaluateRestRequirement(context, rule, at, anchor) {
     const window = windowOf(context, rule.per, at, anchor);
     const { span } = window;
-    const rests = runsOf(log, rule.restStatuses);
-    const inside = clipRuns(rests, span.start, min(span.end, at));
+    const index = runIndex(context.store, rule.restStatuses);
+    const upper = min(span.end, at);
+    // The count ends at or before `at`, so the runs of the whole log, cut to it, are the runs of
+    // the log as it stands at `at`.
+    const inside = span.start < upper ? runsBetween(index.runs, span.start, upper) : [];
     const actual = restChecks(rule, inside.map(length));
     const met = actual.met ||
         (span.end > at &&
@@ -624,30 +644,7 @@ function evaluateRestRequirement(context, rule, log, at, anchor) {
         grouping: groupingOf(window),
     };
     if (rule.maxGap !== null) {
-        const last = rests[rests.length - 1];
-        const resting = last !== undefined && last.end === at;
-        // A stretch without rest runs from the end of one rest to the start of the next. The log's
-        // first entry starts one too, as a rest ending there would: time before the log is unknown,
-        // but the work logged before the first rest is a stretch without rest like any other.
-        const logStart = log[0]?.start;
-        const gapStarts = logStart === undefined || rests[0]?.start === logStart
-            ? rests.map((run) => run.end)
-            : [logStart, ...rests.map((run) => run.end)];
-        const gapEnds = gapStarts.length > rests.length
-            ? rests.map((run) => run.start)
-            : rests.slice(1).map((run) => run.start);
-        let widest = 0n;
-        for (let index = 0; index < gapStarts.length; index++) {
-            const gapStart = gapStarts[index];
-            const gapEnd = gapEnds[index] ?? (resting ? gapStart : at);
-            if (gapEnd > span.start && gapStart < min(span.end, at)) {
-                widest = max(widest, gapEnd - gapStart);
-            }
-        }
-        const lastGapStart = gapStarts[gapStarts.length - 1];
-        const dueBy = lastGapStart !== undefined && !resting
-            ? lastGapStart + rule.maxGap
-            : null;
+        const { widest, dueBy } = widestRestGap(context, index, at, span.start, upper, rule.maxGap);
         if (widest > rule.maxGap) {
             return {
                 satisfied: false,
@@ -669,57 +666,57 @@ function evaluateRestRequirement(context, rule, log, at, anchor) {
         dueBy: null,
     });
 }
-function evaluateRestBeforeDuty(rule, log, at) {
-    const isRest = (status) => rule.restStatuses.has(status);
-    const rests = runsOf(log, isRest);
-    const last = log[log.length - 1];
-    const onDuty = last !== undefined && last.end === at && !isRest(last.status);
-    // On duty, the duty started where the run outside rest reaching `at` began; resting, a duty
-    // starting now is the one to be ready for.
-    const dutyStart = onDuty
-        ? runsOf(log, (status) => !isRest(status)).at(-1).start
-        : at;
-    const logStart = log[0]?.start ?? at;
-    if (rule.orFactor !== null) {
-        // The rest judged is the one right before the duty, measured whole, against the duty it
-        // ends: from the end of the last rest of at least `minimum` before it, breaks included, to
-        // where it starts. A duty between an earlier rest and this one is never skipped, and more
-        // rest before the duty only lengthens the rest or shortens the duty before it.
-        const rest = rests.find((run) => run.end === dutyStart);
-        const restStart = rest?.start ?? dutyStart;
-        const fullRest = rests
-            .filter((run) => run.end <= restStart && length(run) >= rule.minimum)
-            .at(-1);
-        const dutyFrom = fullRest?.end ?? min(logStart, restStart);
-        const previousDuty = restStart - dutyFrom;
-        const { numerator, denominator } = rule.orFactor.k;
-        // k × the duty, rounded up to the nanosecond, exactly.
-        const scaled = (previousDuty * numerator + denominator - 1n) / denominator;
-        const limit = max(rule.minimum, max(scaled, rule.orFactor.floor));
-        const used = rest === undefined ? 0n : length(rest);
-        return {
-            ...floored(used, limit, !onDuty || used >= limit, {
-                window: { start: dutyFrom, end: dutyStart },
-                periodBasis: "elapsed",
-                dueBy: null,
-                resetAt: null,
-                grouping: "start",
-            }),
-            // A rest that starts with the log, or a duty with none logged before it, may have more
-            // rest before the log: the record does not judge it.
-            beforeLog: restStart <= logStart,
-            key: restStart,
-        };
-    }
-    const windowStart = max(dutyStart - rule.within, MIN_INSTANT_NANOSECONDS);
-    // The rest before the duty: the longest run of rest inside the window, the latest on a tie.
+/** The rest right before a duty, measured whole, against the duty before it (`orFactor`). */
+function restBeforeDutyScaled(rule, orFactor, { rests, dutyStart, onDuty, logStart }) {
+    // The rest judged is the one right before the duty, measured whole, against the duty it
+    // ends: from the end of the last rest of at least `minimum` before it, breaks included, to
+    // where it starts. A duty between an earlier rest and this one is never skipped, and more
+    // rest before the duty only lengthens the rest or shortens the duty before it.
+    const rest = runEndingAt(rests, dutyStart);
+    const restStart = rest?.start ?? dutyStart;
+    const fullRest = latestAtLeast(rests, endingAtOrBefore(rests, restStart), rule.minimum);
+    const dutyFrom = fullRest?.end ?? min(logStart, restStart);
+    const previousDuty = restStart - dutyFrom;
+    const { numerator, denominator } = orFactor.k;
+    // k × the duty, rounded up to the nanosecond, exactly.
+    const scaled = (previousDuty * numerator + denominator - 1n) / denominator;
+    const limit = max(rule.minimum, max(scaled, orFactor.floor));
+    const used = rest === undefined ? 0n : length(rest);
+    return {
+        ...floored(used, limit, !onDuty || used >= limit, {
+            window: { start: dutyFrom, end: dutyStart },
+            periodBasis: "elapsed",
+            dueBy: null,
+            resetAt: null,
+            grouping: "start",
+        }),
+        // A rest that starts with the log, or a duty with none logged before it, may have more
+        // rest before the log: the record does not judge it.
+        beforeLog: restStart <= logStart,
+        key: restStart,
+    };
+}
+/** The longest run of rest inside `[windowStart, dutyStart)`, the latest on a tie. */
+function longestRestInside(rests, windowStart, dutyStart) {
+    // Only the runs reaching into the window are read, and dutyStart is at most `at`, so the cut
+    // last run reads as it does whole.
     let rest;
-    for (const run of rests) {
+    for (let position = firstEndingAfter(rests, windowStart); position < rests.count; position++) {
+        const run = viewRun(rests, position);
+        if (run.start >= dutyStart) {
+            break;
+        }
         const inside = min(run.end, dutyStart) - max(run.start, windowStart);
         if (inside > 0n && (rest === undefined || inside >= rest.inside)) {
             rest = { run, inside };
         }
     }
+    return rest;
+}
+/** The rest before a duty: the longest inside the window, against the minimum. */
+function restBeforeDutyWithin(rule, { rests, dutyStart, onDuty }) {
+    const windowStart = max(dutyStart - rule.within, MIN_EPOCH_NANOSECONDS);
+    const rest = longestRestInside(rests, windowStart, dutyStart);
     const used = rest?.inside ?? 0n;
     return {
         ...floored(used, rule.minimum, !onDuty || used >= rule.minimum, {
@@ -733,18 +730,44 @@ function evaluateRestBeforeDuty(rule, log, at) {
         key: rest?.run.start ?? windowStart,
     };
 }
+function evaluateRestBeforeDuty(context, rule, at) {
+    const { store } = context;
+    const rests = runsUntil(runIndex(store, rule.restStatuses), at);
+    const last = lastEntryBefore(store, at);
+    const onDuty = last !== undefined &&
+        last.end === at &&
+        !rule.restStatuses.has(last.status);
+    // On duty, the duty started where the run outside rest reaching `at` began; resting, a duty
+    // starting now is the one to be ready for.
+    const dutyStart = onDuty
+        ? runsUntil(runIndex(store, { not: rule.restStatuses }), at)
+            .last.start
+        : at;
+    const started = {
+        rests,
+        dutyStart,
+        onDuty,
+        logStart: logStartBefore(store, at) ?? at,
+    };
+    return rule.orFactor === null
+        ? restBeforeDutyWithin(rule, started)
+        : restBeforeDutyScaled(rule, rule.orFactor, started);
+}
 function evaluateRule(context, rule, at, anchor) {
     // A free period reads only runs of rest, kept for the whole call, not the log cut at `at`.
     if (rule.kind === "freePeriod") {
         return evaluateFreePeriod(context, rule, at, anchor);
     }
-    const log = clip(context.entries, at);
-    const first = log[0]?.start ?? at;
+    // The log as it stands at `at` is the whole log read up to `at`: no copy is made.
+    const { store } = context;
+    const first = logStartBefore(store, at) ?? at;
+    const viewOf = (test) => runsUntil(runIndex(store, test), at);
+    const timeOf = (test, from, to) => timeInBefore(runIndex(store, test), from, to, at);
     switch (rule.kind) {
         case "cumulativeCap": {
-            const reset = lastAtLeast(runsOf(log, rule.since.statuses), rule.since.consecutive);
+            const reset = lastAtLeastUntil(viewOf(rule.since.statuses), rule.since.consecutive);
             const from = reset?.end ?? first;
-            return capped(duration(timeIn(log, rule.statuses, from, at)), duration(rule.cap), {
+            return capped(duration(timeOf(rule.statuses, from, at)), duration(rule.cap), {
                 window: { start: from, end: at },
                 periodBasis: null,
                 dueBy: null,
@@ -753,11 +776,10 @@ function evaluateRule(context, rule, at, anchor) {
             });
         }
         case "elapsedWindow": {
-            const rests = runsOf(log, rule.since.statuses);
-            const reset = lastAtLeast(rests, rule.since.consecutive);
+            const rests = viewOf(rule.since.statuses);
+            const reset = lastAtLeastUntil(rests, rule.since.consecutive);
             const after = reset?.end ?? null;
-            const opener = log.find((entry) => (after === null || entry.start >= after) &&
-                rule.startStatuses.has(entry.status));
+            const opener = firstEntryIn(store, rule.startStatuses, after, at);
             if (opener === undefined) {
                 return {
                     satisfied: true,
@@ -775,8 +797,7 @@ function evaluateRule(context, rule, at, anchor) {
             let opensAt = opener.start;
             let second;
             if (rule.exclude !== null) {
-                const pairs = restPairs(rests.filter((run) => run.start >= opener.start), rule.since.consecutive, rule.exclude);
-                const latest = pairs[pairs.length - 1];
+                const latest = latestPairFrom(rests, firstStartingAtOrAfter(rests, opener.start), rule.since.consecutive, rule.exclude);
                 if (latest !== undefined) {
                     opensAt = latest.first.end;
                     second = latest.second;
@@ -806,7 +827,7 @@ function evaluateRule(context, rule, at, anchor) {
                     limit += rule.extension.by;
                 }
             }
-            const late = timeIn(log, rule.restrictedStatuses, closesAt, at);
+            const late = timeOf(rule.restrictedStatuses, closesAt, at);
             return {
                 satisfied: late === 0n,
                 used: duration(at - opensAt - excluded),
@@ -821,28 +842,13 @@ function evaluateRule(context, rule, at, anchor) {
             };
         }
         case "requiredInterruption": {
-            const outside = rule.outsideStatuses;
-            const breaks = runsOf(log, (status) => !rule.countedStatuses.has(status) &&
-                (outside === null || outside.has(status)));
-            let resetAt = null;
-            let part = 0;
-            for (const pause of breaks) {
-                const taken = length(pause);
-                const split = rule.orderedSplit;
-                if (taken >= rule.minimum) {
-                    resetAt = pause.end;
-                    part = 0;
-                }
-                else if (split !== null && taken >= split[part]) {
-                    part++;
-                    if (part === split.length) {
-                        resetAt = pause.end;
-                        part = 0;
-                    }
-                }
-            }
+            const breaks = viewOf({
+                not: rule.countedStatuses,
+                within: rule.outsideStatuses,
+            });
+            const resetAt = interruptionResetAt(breaks, rule.minimum, rule.orderedSplit);
             const from = resetAt ?? first;
-            return capped(duration(timeIn(log, rule.countedStatuses, from, at)), duration(rule.after), {
+            return capped(duration(timeOf(rule.countedStatuses, from, at)), duration(rule.after), {
                 window: { start: from, end: at },
                 periodBasis: null,
                 dueBy: null,
@@ -854,19 +860,20 @@ function evaluateRule(context, rule, at, anchor) {
             const window = windowOf(context, rule.window, at, anchor);
             const reset = rule.reset === null
                 ? undefined
-                : lastAtLeast(runsOf(log, rule.reset.statuses), rule.reset.consecutive);
+                : lastAtLeastUntil(viewOf(rule.reset.statuses), rule.reset.consecutive);
             const from = reset !== undefined && reset.end > window.span.start
                 ? reset.end
                 : window.span.start;
             const to = min(window.span.end, at);
-            let used = timeIn(log, rule.statuses, from, to);
+            let used = timeOf(rule.statuses, from, to);
             let limit = rule.cap;
             if (rule.precondition !== null) {
                 const { restStatuses, minimum, beforeHours } = rule.precondition;
-                const rest = clipRuns(runsOf(log, restStatuses), from, to).find((run) => length(run) >= minimum);
-                const before = rest === undefined
-                    ? used
-                    : timeIn(log, rule.statuses, from, rest.start);
+                // `to` is at most `at`, so the runs of the whole log, cut to it, are the log's.
+                const rest = (from < to
+                    ? runsBetween(runIndex(store, restStatuses).runs, from, to)
+                    : []).find((run) => length(run) >= minimum);
+                const before = rest === undefined ? used : timeOf(rule.statuses, from, rest.start);
                 if (rest === undefined || before > beforeHours) {
                     limit = beforeHours;
                     used = before;
@@ -882,7 +889,7 @@ function evaluateRule(context, rule, at, anchor) {
         }
         case "fixedPeriodCap": {
             const window = windowOf(context, repeated(rule.period, rule.adjacent), at, anchor);
-            const total = timeIn(log, rule.statuses, window.span.start, min(window.span.end, at));
+            const total = timeOf(rule.statuses, window.span.start, min(window.span.end, at));
             const rest = {
                 window: window.span,
                 periodBasis: basisOf(window),
@@ -905,20 +912,20 @@ function evaluateRule(context, rule, at, anchor) {
             };
         }
         case "restRequirement":
-            return evaluateRestRequirement(context, rule, log, at, anchor);
+            return evaluateRestRequirement(context, rule, at, anchor);
         case "restBeforeDuty":
-            return evaluateRestBeforeDuty(rule, log, at);
+            return evaluateRestBeforeDuty(context, rule, at);
         case "quota": {
-            const continuing = context.entries.some((entry) => rule.statuses.has(entry.status) &&
-                entry.start <= at &&
-                entry.end > at);
-            const events = runsOf(log, rule.statuses).filter((run) => !(continuing && run.end === at) &&
-                length(run) >= rule.minimum &&
-                length(run) < rule.maximum);
+            const continuing = entryHolding(store, at);
+            const running = continuing !== undefined && rule.statuses.has(continuing.status);
+            const runs = viewOf(rule.statuses);
+            const sizes = { minimum: rule.minimum, maximum: rule.maximum };
+            // A run going on at `at` is not an event yet.
+            const skipEndingAt = running ? at : null;
             if ("every" in rule.reset) {
                 const window = windowOf(context, rule.reset.every, at, anchor);
                 const to = min(window.span.end, at);
-                const found = events.filter((run) => run.start >= window.span.start && run.start < to).length;
+                const found = countEvents(runs, sizes, { from: window.span.start, to }, skipEndingAt);
                 return capped(tally(found), tally(rule.count), {
                     window: window.span,
                     periodBasis: basisOf(window),
@@ -927,9 +934,9 @@ function evaluateRule(context, rule, at, anchor) {
                     grouping: groupingOf(window),
                 });
             }
-            const reset = lastAtLeast(runsOf(log, rule.reset.statuses), rule.reset.consecutive);
+            const reset = lastAtLeastUntil(viewOf(rule.reset.statuses), rule.reset.consecutive);
             const from = reset?.end ?? first;
-            return capped(tally(events.filter((run) => run.start >= from).length), tally(rule.count), {
+            return capped(tally(countEvents(runs, sizes, { from, to: null }, skipEndingAt)), tally(rule.count), {
                 window: { start: from, end: at },
                 periodBasis: null,
                 dueBy: null,
@@ -938,11 +945,11 @@ function evaluateRule(context, rule, at, anchor) {
             });
         }
         case "dueBy": {
-            const events = runsOf(log, rule.statuses);
-            const event = lastAtLeast(events, rule.minimum);
+            const events = viewOf(rule.statuses);
+            const event = lastAtLeastUntil(events, rule.minimum);
             const reset = rule.reset === null
                 ? undefined
-                : lastAtLeast(runsOf(log, rule.reset.statuses), rule.reset.consecutive);
+                : lastAtLeastUntil(viewOf(rule.reset.statuses), rule.reset.consecutive);
             const clock = event === undefined
                 ? (reset?.end ?? null)
                 : reset === undefined
@@ -950,7 +957,7 @@ function evaluateRule(context, rule, at, anchor) {
                     : max(event.end, reset.end);
             const from = clock ?? first;
             const due = boundaryAfter(context, rule.period, rule.periods, from);
-            const latest = events[events.length - 1];
+            const latest = events.last;
             const pending = latest !== undefined && latest.end === at && latest.start <= due;
             return {
                 satisfied: at <= due || pending,
@@ -974,12 +981,12 @@ function evaluateRule(context, rule, at, anchor) {
             const unfinished = span.end > at;
             const counts = new Map();
             for (const named of rule.classes) {
-                const runs = runsOf(log, named.statuses);
+                const runs = viewOf(named.statuses);
                 const qualifies = (run) => run.start >= span.start &&
                     run.start < to &&
                     length(run) >= named.minimum;
-                const found = runs.filter(qualifies).length;
-                const last = runs[runs.length - 1];
+                const found = countEvents(runs, { minimum: named.minimum, maximum: null }, { from: span.start, to }, null);
+                const last = runs.last;
                 let best = found;
                 if (unfinished) {
                     // A run counts in the window it starts in, measured whole, so the most the window can
@@ -1030,7 +1037,7 @@ function evaluateRule(context, rule, at, anchor) {
         }
         case "occurrenceCap": {
             const scale = scaleFor(context, rule.per.unit);
-            const runs = runsOf(log, rule.statuses);
+            const runs = viewOf(rule.statuses);
             const blocks = [];
             let blockAnchor = anchor;
             for (let index = 0; index < rule.lookback; index++) {
@@ -1043,9 +1050,11 @@ function evaluateRule(context, rule, at, anchor) {
             }
             const occupied = blocks.filter((block) => {
                 const to = min(block.end, at);
-                return runs.some((run) => rule.byInitiationDate
-                    ? run.start >= block.start && run.start < to
-                    : run.start < to && run.end > block.start);
+                // The first run that can count: starting in the block, or ending after it starts.
+                const position = rule.byInitiationDate
+                    ? firstStartingAtOrAfter(runs, block.start)
+                    : firstEndingAfter(runs, block.start);
+                return position < runs.count && viewRun(runs, position).start < to;
             }).length;
             const earliest = blocks[blocks.length - 1];
             const latest = blocks[0];
@@ -1059,18 +1068,18 @@ function evaluateRule(context, rule, at, anchor) {
         }
         case "usageLookback": {
             const window = windowOf(context, rule.notWithin, at, anchor);
-            const reset = lastAtLeast(runsOf(log, rule.reset.statuses), rule.reset.consecutive);
+            const reset = lastAtLeastUntil(viewOf(rule.reset.statuses), rule.reset.consecutive);
             const from = reset !== undefined && reset.end > window.span.start
                 ? reset.end
                 : window.span.start;
             // A use is an instant, and each window holds it once. An elapsed window runs up to and
             // including the use being made at `at`, so one exactly its length earlier is outside it; a
             // window of local periods holds only its own, so one on its end is the next's.
-            const found = rule.uses.filter((use) => use >= from &&
-                use <= at &&
-                (rule.notWithin.kind === "elapsed"
-                    ? use > at - rule.notWithin.length
-                    : use < window.span.end)).length;
+            const found = countInRange(rule.uses, rule.notWithin.kind === "elapsed"
+                ? max(from, at - rule.notWithin.length + 1n)
+                : from, rule.notWithin.kind === "elapsed"
+                ? at + 1n
+                : min(at + 1n, window.span.end));
             return capped(tally(found), tally(1), {
                 window: { start: from, end: window.span.end },
                 periodBasis: basisOf(window),
@@ -1262,11 +1271,9 @@ function runFloors(rule) {
                 },
             ];
         case "requiredInterruption": {
-            const outside = rule.outsideStatuses;
             return [
                 {
-                    test: (status) => !rule.countedStatuses.has(status) &&
-                        (outside === null || outside.has(status)),
+                    test: { not: rule.countedStatuses, within: rule.outsideStatuses },
                     floors: [rule.minimum, ...(rule.orderedSplit ?? [])],
                     sliding: false,
                 },
@@ -1408,7 +1415,7 @@ function candidateInstants(context, rule, range) {
         }
     }
     for (const { test, floors, sliding } of runFloors(rule)) {
-        for (const run of runsOf(context.entries, test)) {
+        for (const run of runIndex(context.store, test).runs) {
             for (const floor of floors) {
                 around(run.start + floor);
                 if (sliding) {
@@ -1425,7 +1432,7 @@ function candidateInstants(context, rule, range) {
         // full rest between. A run shorter than `each` is skipped, never a partner.
         const fullRest = rule.since.consecutive;
         let partner;
-        for (const run of runsOf(context.entries, rule.since.statuses)) {
+        for (const run of runIndex(context.store, rule.since.statuses).runs) {
             if (partner !== undefined) {
                 around(run.start + rule.exclude.combined - length(partner));
             }
@@ -1439,7 +1446,7 @@ function candidateInstants(context, rule, range) {
         }
     }
     if (rule.kind === "restRequirement") {
-        const rests = runsOf(context.entries, rule.restStatuses);
+        const rests = runIndex(context.store, rule.restStatuses).runs;
         const ranks = rule.composition !== null || rule.composite !== null;
         if (rule.maxGap !== null) {
             // A stretch without rest starts at each rest's end and at the log's first entry.
@@ -1458,11 +1465,13 @@ function candidateInstants(context, rule, range) {
             for (let index = 0; index < near.length; index++) {
                 const earlier = near[index];
                 // A rest shrinking out of the window crosses one growing at its end, or one held whole.
-                for (let other = 0; other < near.length; other++) {
+                // The rests are ordered and separate, so those within two window lengths of `earlier`
+                // are one stretch of them: from the first that ends within reach to the first that
+                // starts out of it.
+                for (let other = firstWhere(near.length, (position) => near[position].end > earlier.start - 2n * shift); other < near.length; other++) {
                     const later = near[other];
-                    if (later.start - earlier.end >= 2n * shift ||
-                        earlier.start - later.end >= 2n * shift) {
-                        continue;
+                    if (later.start - earlier.end >= 2n * shift) {
+                        break;
                     }
                     const crossing = (earlier.end + shift + later.start) / 2n;
                     around(crossing);
@@ -1479,7 +1488,7 @@ function candidateInstants(context, rule, range) {
         // a run further than that before the range, or after it, adds none inside it.
         const farthest = (BigInt(rule.atLeast) + 1n) * minimum +
             shifts.reduce((longest, shift) => max(longest, shift), 0n);
-        const rests = runsOf(context.entries, rule.restStatuses).filter((run) => run.end + farthest >= range.start && run.start <= until + 1n);
+        const rests = runIndex(context.store, rule.restStatuses).runs.filter((run) => run.end + farthest >= range.start && run.start <= until + 1n);
         // A window fails only while it holds fewer than `atLeast` free periods, so a run's count
         // changing above `atLeast` changes no answer: each run's first `atLeast + 1` multiples are
         // the ones that matter. Of those, only the ones that land in the range are taken.
@@ -1520,13 +1529,13 @@ function candidateInstants(context, rule, range) {
         // and the log's start, set one.
         const clocks = [
             context.entries[0]?.start,
-            ...runsOf(context.entries, rule.statuses)
-                .filter((run) => length(run) >= rule.minimum)
+            ...runIndex(context.store, rule.statuses)
+                .runs.filter((run) => length(run) >= rule.minimum)
                 .map((run) => run.end),
             ...(rule.reset === null
                 ? []
-                : runsOf(context.entries, rule.reset.statuses)
-                    .filter((run) => length(run) >=
+                : runIndex(context.store, rule.reset.statuses)
+                    .runs.filter((run) => length(run) >=
                     rule.reset.consecutive)
                     .map((run) => run.end)),
         ];