@kensio/quando 0.1.0 → 1.0.0

package/dist/rota.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Who is on, in the words people use for that.
+ *
+ * The same machinery as a [schedule](./schedule.ts) with the value left open:
+ * a rota assigns a person, a tariff assigns a rate, a roster assigns how many
+ * are working. A `Rota<V>` is a `Cascade<V>`, so the core reads it unchanged.
+ *
+ * The value type accumulates as layers are added, so a rota of two names
+ * answers `"alice" | "bob" | undefined` rather than `string` — which is what
+ * makes an exhaustive switch over who is on call actually exhaustive. Ask for
+ * `rota<string>()` when the names are not known up front.
+ */
+import { type Cascade } from "./cascade.js";
+import { type PlainRule } from "./plain-forms.js";
+import type { ValuedStream } from "./valued-stream.js";
+/** Who or what holds when, and the questions worth asking about that. */
+export interface Rota<V> extends Cascade<V> {
+    /** These times belong to this one, unless something later says otherwise. */
+    readonly assign: <const W>(scope: PlainRule, value: W) => Rota<V | W>;
+    /**
+     * A swap: this day goes to this one instead.
+     *
+     * The same thing as an `assign` naming a single day — it exists because
+     * "Carol is swapping the eleventh" is what happened, and a rota reads better
+     * when the exceptions say they are exceptions.
+     */
+    readonly swap: <const W>(day: PlainRule, value: W) => Rota<V | W>;
+    /** Who is on at that moment, or `undefined` if nobody is. */
+    readonly whoIsOn: (at: Temporal.ZonedDateTime) => V | undefined;
+    /**
+     * Each stretch between two moments, and who has it.
+     *
+     * Leave `to` out for an endless run of them, which is lazy and safe to stop
+     * pulling from whenever you have enough.
+     */
+    readonly shifts: (from: Temporal.ZonedDateTime, to?: Temporal.ZonedDateTime) => ValuedStream<V>;
+}
+/**
+ * An empty rota: nobody is on until something says they are.
+ *
+ * ```ts
+ * const onCall = rota()
+ *   .assign(weekdays(), "alice")
+ *   .assign(weekends(), "bob")
+ *   .swap("2026-03-11", "carol");
+ * ```
+ */
+export declare function rota<V = never>(): Rota<V>;
+//# sourceMappingURL=rota.d.ts.map

package/dist/rota.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rota.d.ts","sourceRoot":"","sources":["../src/rota.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,EAAE,KAAK,OAAO,EAAqB,MAAM,cAAc,CAAC;AAC/D,OAAO,EAAU,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,yEAAyE;AACzE,MAAM,WAAW,IAAI,CAAC,CAAC,CAAE,SAAQ,OAAO,CAAC,CAAC,CAAC;IACzC,6EAA6E;IAC7E,QAAQ,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAEtE;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAElE,6DAA6D;IAC7D,QAAQ,CAAC,OAAO,EAAE,CAAC,EAAE,EAAE,QAAQ,CAAC,aAAa,KAAK,CAAC,GAAG,SAAS,CAAC;IAEhE;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,EAAE,CACf,IAAI,EAAE,QAAQ,CAAC,aAAa,EAC5B,EAAE,CAAC,EAAE,QAAQ,CAAC,aAAa,KACxB,YAAY,CAAC,CAAC,CAAC,CAAC;CACtB;AAsBD;;;;;;;;;GASG;AACH,wBAAgB,IAAI,CAAC,CAAC,GAAG,KAAK,KAAK,IAAI,CAAC,CAAC,CAAC,CAEzC"}

package/dist/rota.js

@@ -0,0 +1,41 @@
+/**
+ * Who is on, in the words people use for that.
+ *
+ * The same machinery as a [schedule](./schedule.ts) with the value left open:
+ * a rota assigns a person, a tariff assigns a rate, a roster assigns how many
+ * are working. A `Rota<V>` is a `Cascade<V>`, so the core reads it unchanged.
+ *
+ * The value type accumulates as layers are added, so a rota of two names
+ * answers `"alice" | "bob" | undefined` rather than `string` — which is what
+ * makes an exhaustive switch over who is on call actually exhaustive. Ask for
+ * `rota<string>()` when the names are not known up front.
+ */
+import { valueAt } from "./assigned.js";
+import { layer } from "./cascade.js";
+import { asDays } from "./plain-forms.js";
+import { resolve } from "./resolve.js";
+function build(layers) {
+    const self = {
+        type: "cascade",
+        layers,
+        assign: (scope, value) => build([...layers, layer(asDays(scope), value)]),
+        swap: (day, value) => build([...layers, layer(asDays(day), value)]),
+        whoIsOn: (at) => valueAt(self, at),
+        shifts: (from, to) => resolve(self, to === undefined ? { from } : { from, to }),
+    };
+    return self;
+}
+/**
+ * An empty rota: nobody is on until something says they are.
+ *
+ * ```ts
+ * const onCall = rota()
+ *   .assign(weekdays(), "alice")
+ *   .assign(weekends(), "bob")
+ *   .swap("2026-03-11", "carol");
+ * ```
+ */
+export function rota() {
+    return build([]);
+}
+//# sourceMappingURL=rota.js.map

package/dist/rota.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rota.js","sourceRoot":"","sources":["../src/rota.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACxC,OAAO,EAA4B,KAAK,EAAE,MAAM,cAAc,CAAC;AAC/D,OAAO,EAAE,MAAM,EAAkB,MAAM,kBAAkB,CAAC;AAC1D,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAgCvC,SAAS,KAAK,CAAI,MAA2B;IAC3C,MAAM,IAAI,GAAY;QACpB,IAAI,EAAE,SAAS;QACf,MAAM;QAEN,MAAM,EAAE,CAAI,KAAgB,EAAE,KAAQ,EAAE,EAAE,CACxC,KAAK,CAAQ,CAAC,GAAG,MAAM,EAAE,KAAK,CAAQ,MAAM,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;QAE/D,IAAI,EAAE,CAAI,GAAc,EAAE,KAAQ,EAAE,EAAE,CACpC,KAAK,CAAQ,CAAC,GAAG,MAAM,EAAE,KAAK,CAAQ,MAAM,CAAC,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;QAE7D,OAAO,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC;QAElC,MAAM,EAAE,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,CACnB,OAAO,CAAC,IAAI,EAAE,EAAE,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC;KAC5D,CAAC;IAEF,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,IAAI;IAClB,OAAO,KAAK,CAAI,EAAE,CAAC,CAAC;AACtB,CAAC"}

package/dist/rule.d.ts

@@ -0,0 +1,73 @@
+/**
+ * The rule language, as data.
+ *
+ * A rule is a plain JSON value with a `type` tag — not an object with methods.
+ * That is what makes storing one, sending one over a wire, and validating one
+ * cost nothing: the document *is* the rule. It also means a new operation over
+ * rules is a new function rather than a new method on every rule type, which
+ * matters because there are many operations coming — evaluating, describing,
+ * validating, rendering, diffing — and comparatively few rule types.
+ */
+export declare const WEEKDAYS: readonly ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"];
+export type Weekday = (typeof WEEKDAYS)[number];
+/**
+ * A rule says *when*, and nothing else. It is boolean: the times it covers and
+ * the times it does not.
+ *
+ * Values — who is on call, what the tariff is — attach to layers rather than to
+ * rules, which is what keeps `not` meaningful and the set algebra simple.
+ */
+export type Rule = AlwaysRule | NeverRule | DaysOfWeekRule | TimeOfDayRule | DatesRule | AllRule | AnyRule | NotRule;
+/** All time. The identity for intersection. */
+export interface AlwaysRule {
+    readonly type: "always";
+}
+/** No time at all. The identity for union. */
+export interface NeverRule {
+    readonly type: "never";
+}
+/** Whole days, by their day of the week. */
+export interface DaysOfWeekRule {
+    readonly type: "daysOfWeek";
+    readonly days: readonly Weekday[];
+    /** Overrides the context's zone, for a rule about a particular place. */
+    readonly zone?: string;
+}
+/**
+ * A window within each day, as wall-clock times: `"09:00"` to `"17:00"`.
+ *
+ * Wall clock is what people write and what schedules mean. Across a daylight
+ * saving transition the elapsed length of the window changes and the clock
+ * times do not, which is the right way round.
+ *
+ * A `to` earlier than `from` wraps past midnight, so `"22:00"` to `"06:00"` is
+ * a night shift rather than nothing.
+ */
+export interface TimeOfDayRule {
+    readonly type: "timeOfDay";
+    readonly from: string;
+    readonly to: string;
+    readonly zone?: string;
+}
+/** Whole days, by date: `"2026-03-14"`. */
+export interface DatesRule {
+    readonly type: "dates";
+    readonly dates: readonly string[];
+    readonly zone?: string;
+}
+/** Every rule must hold: intersection. */
+export interface AllRule {
+    readonly type: "all";
+    readonly rules: readonly Rule[];
+}
+/** At least one rule must hold: union. */
+export interface AnyRule {
+    readonly type: "any";
+    readonly rules: readonly Rule[];
+}
+/** The times a rule does not hold: complement. */
+export interface NotRule {
+    readonly type: "not";
+    readonly rule: Rule;
+}
+//# sourceMappingURL=rule.d.ts.map

package/dist/rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../src/rule.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,eAAO,MAAM,QAAQ,YACnB,QAAQ,EACR,SAAS,EACT,WAAW,EACX,UAAU,EACV,QAAQ,EACR,UAAU,EACV,QAAQ,CACA,CAAC;AAEX,MAAM,MAAM,OAAO,GAAG,CAAC,OAAO,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC;AAEhD;;;;;;GAMG;AACH,MAAM,MAAM,IAAI,GACZ,UAAU,GACV,SAAS,GACT,cAAc,GACd,aAAa,GACb,SAAS,GACT,OAAO,GACP,OAAO,GACP,OAAO,CAAC;AAEZ,+CAA+C;AAC/C,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;CACzB;AAED,8CAA8C;AAC9C,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;CACxB;AAED,4CAA4C;AAC5C,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,SAAS,OAAO,EAAE,CAAC;IAClC,yEAAyE;IACzE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,2CAA2C;AAC3C,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,0CAA0C;AAC1C,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,CAAC;CACjC;AAED,0CAA0C;AAC1C,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,CAAC;CACjC;AAED,kDAAkD;AAClD,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;CACrB"}

package/dist/rule.js

@@ -0,0 +1,20 @@
+/**
+ * The rule language, as data.
+ *
+ * A rule is a plain JSON value with a `type` tag — not an object with methods.
+ * That is what makes storing one, sending one over a wire, and validating one
+ * cost nothing: the document *is* the rule. It also means a new operation over
+ * rules is a new function rather than a new method on every rule type, which
+ * matters because there are many operations coming — evaluating, describing,
+ * validating, rendering, diffing — and comparatively few rule types.
+ */
+export const WEEKDAYS = [
+    "monday",
+    "tuesday",
+    "wednesday",
+    "thursday",
+    "friday",
+    "saturday",
+    "sunday",
+];
+//# sourceMappingURL=rule.js.map

package/dist/rule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule.js","sourceRoot":"","sources":["../src/rule.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,QAAQ;IACR,SAAS;IACT,WAAW;IACX,UAAU;IACV,QAAQ;IACR,UAAU;IACV,QAAQ;CACA,CAAC"}

package/dist/schedule.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Opening hours, in the words people use for them.
+ *
+ * Everything here is a cascade underneath, and a `Schedule` *is* one — the
+ * same trick the rule builders use, so it serialises to the same document and
+ * `resolve` reads it unchanged. What this adds is vocabulary: nobody running a
+ * warehouse says "add a layer to the cascade", they say we are open weekdays,
+ * closed on bank holidays, and on the eleventh we close at three.
+ *
+ * Those three read in the order they are said, and each one outranks what came
+ * before it — which is the same precedence a cascade has, arrived at by
+ * writing the sentence in the obvious order rather than by knowing the rule.
+ */
+import { type Cascade } from "./cascade.js";
+import { type Interval } from "./interval.js";
+import { type PlainRule } from "./plain-forms.js";
+/**
+ * When something is open, and the questions worth asking about that.
+ *
+ * A `Schedule` is a `Cascade<boolean>`, so anything that takes a cascade takes
+ * one of these. The methods below are the common half said plainly; the
+ * cascade underneath is the whole of it.
+ */
+export interface Schedule extends Cascade<boolean> {
+    /**
+     * Open during these times. With hours, inside them on those days; without,
+     * for the whole of them.
+     */
+    readonly open: (scope: PlainRule, hours?: PlainRule) => Schedule;
+    /** Closed for the whole of these times, whatever was said before. */
+    readonly closed: (scope: PlainRule) => Schedule;
+    /**
+     * The hours on this day, in place of whatever was said before.
+     *
+     * Instead of, not as well as: the usual hours do not show through the part
+     * this leaves out, which is what "we close early on the eleventh" means and
+     * what makes it different from being shut between three and five.
+     */
+    readonly hoursOn: (day: PlainRule, hours: PlainRule) => Schedule;
+    /** Whether it is open at that moment. */
+    readonly isOpen: (at: Temporal.ZonedDateTime) => boolean;
+    /**
+     * The next stretch it is open, at or after a moment, or `undefined` if there
+     * is none within `within` of it.
+     *
+     * `within` bounds how far to look and not what is found: a stretch that
+     * starts inside the horizon is returned whole, ending when it really closes
+     * rather than where the search stopped. That differs from `next` on a rule,
+     * which clips its answer to the window it was given.
+     *
+     * A schedule that is never open has no answer to give and no way to discover
+     * that, so pass `within` when that is a possibility.
+     */
+    readonly opensNext: (at: Temporal.ZonedDateTime, within?: Temporal.Duration) => Interval | undefined;
+    /** How long it is open between two moments. */
+    readonly openBetween: (from: Temporal.ZonedDateTime, to: Temporal.ZonedDateTime) => Temporal.Duration;
+}
+/**
+ * An empty schedule: open for nothing until something says otherwise.
+ *
+ * ```ts
+ * const openingHours = schedule()
+ *   .open(weekdays(), "09:00-17:00")
+ *   .closed("2026-12-25")
+ *   .hoursOn("2026-03-11", "09:00-15:00");
+ * ```
+ */
+export declare function schedule(): Schedule;
+//# sourceMappingURL=schedule.d.ts.map

package/dist/schedule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schedule.d.ts","sourceRoot":"","sources":["../src/schedule.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,OAAO,EAAE,KAAK,OAAO,EAA8B,MAAM,cAAc,CAAC;AAExE,OAAO,EAAY,KAAK,QAAQ,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,EAAmB,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAOnE;;;;;;GAMG;AACH,MAAM,WAAW,QAAS,SAAQ,OAAO,CAAC,OAAO,CAAC;IAChD;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,CAAC,EAAE,SAAS,KAAK,QAAQ,CAAC;IAEjE,qEAAqE;IACrE,QAAQ,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,QAAQ,CAAC;IAEhD;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,KAAK,QAAQ,CAAC;IAEjE,yCAAyC;IACzC,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,QAAQ,CAAC,aAAa,KAAK,OAAO,CAAC;IAEzD;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,SAAS,EAAE,CAClB,EAAE,EAAE,QAAQ,CAAC,aAAa,EAC1B,MAAM,CAAC,EAAE,QAAQ,CAAC,QAAQ,KACvB,QAAQ,GAAG,SAAS,CAAC;IAE1B,+CAA+C;IAC/C,QAAQ,CAAC,WAAW,EAAE,CACpB,IAAI,EAAE,QAAQ,CAAC,aAAa,EAC5B,EAAE,EAAE,QAAQ,CAAC,aAAa,KACvB,QAAQ,CAAC,QAAQ,CAAC;CACxB;AAyDD;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,IAAI,QAAQ,CAEnC"}

package/dist/schedule.js

@@ -0,0 +1,80 @@
+/**
+ * Opening hours, in the words people use for them.
+ *
+ * Everything here is a cascade underneath, and a `Schedule` *is* one — the
+ * same trick the rule builders use, so it serialises to the same document and
+ * `resolve` reads it unchanged. What this adds is vocabulary: nobody running a
+ * warehouse says "add a layer to the cascade", they say we are open weekdays,
+ * closed on bank holidays, and on the eleventh we close at three.
+ *
+ * Those three read in the order they are said, and each one outranks what came
+ * before it — which is the same precedence a cascade has, arrived at by
+ * writing the sentence in the obvious order rather than by knowing the rule.
+ */
+import { valueAt } from "./assigned.js";
+import { all } from "./build.js";
+import { layer, replace } from "./cascade.js";
+import { duration } from "./interval.js";
+import { asDays, asHours } from "./plain-forms.js";
+import { resolve } from "./resolve.js";
+import { take } from "./stream.js";
+/** Zero, as a duration to accumulate onto. */
+const NOTHING = Temporal.Duration.from({ seconds: 0 });
+function open(scope, hours) {
+    const when = asDays(scope);
+    return layer(hours === undefined ? when : all(when, asHours(hours)), true);
+}
+function build(layers) {
+    const self = {
+        type: "cascade",
+        layers,
+        open: (scope, hours) => build([...layers, open(scope, hours)]),
+        closed: (scope) => build([...layers, layer(asDays(scope), false)]),
+        hoursOn: (day, hours) => build([...layers, replace(asDays(day), asHours(hours))]),
+        isOpen: (at) => valueAt(self, at) ?? false,
+        opensNext: (at, within) => {
+            const search = within === undefined ? { from: at } : { from: at, to: at.add(within) };
+            for (const period of resolve(self, search)) {
+                if (!period.value) {
+                    continue;
+                }
+                if (within === undefined || period.start === undefined) {
+                    return period;
+                }
+                // The horizon bounds how far to look, not what is found. Everything
+                // resolved against a context is clipped to it, so a stretch that runs
+                // past the horizon comes back ending at the horizon — which reads as a
+                // closing time and is not one. Read it again from its own start, with
+                // nothing to clip it, so the end is when it really closes.
+                const [whole] = take(resolve(self, { from: period.start }), 1);
+                return whole ?? period;
+            }
+            return;
+        },
+        openBetween: (from, to) => {
+            let total = NOTHING;
+            for (const period of resolve(self, { from, to })) {
+                const length = period.value ? duration(period) : undefined;
+                if (length !== undefined) {
+                    total = total.add(length);
+                }
+            }
+            return total.round({ largestUnit: "hour" });
+        },
+    };
+    return self;
+}
+/**
+ * An empty schedule: open for nothing until something says otherwise.
+ *
+ * ```ts
+ * const openingHours = schedule()
+ *   .open(weekdays(), "09:00-17:00")
+ *   .closed("2026-12-25")
+ *   .hoursOn("2026-03-11", "09:00-15:00");
+ * ```
+ */
+export function schedule() {
+    return build([]);
+}
+//# sourceMappingURL=schedule.js.map

package/dist/schedule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schedule.js","sourceRoot":"","sources":["../src/schedule.ts"],"names":[],"mappings":"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"}

package/dist/tally.d.ts

@@ -0,0 +1,76 @@
+/**
+ * How many, in the words people use for counting.
+ *
+ * The same relationship to [merging](./merge.ts) that a
+ * [schedule](./schedule.ts) has to a cascade. `merged("sum", layer(…),
+ * layer(…))` says what it does, and it asks the reader to know three things
+ * first: that layers overlap, that an overlap is what combines, and what a
+ * bare `"sum"` in the first argument governs. Nobody staffing a warehouse
+ * says any of that. They say three on weekdays, two more on the eleventh.
+ *
+ * A `Tally` *is* a `Cascade<number>` with `merge: "sum"`, so everything that
+ * takes a cascade takes one of these, and it serialises to the document a
+ * hand-written one would.
+ */
+import { type Cascade } from "./cascade.js";
+import { type PlainRule } from "./plain-forms.js";
+import type { ValuedStream } from "./valued-stream.js";
+/** How many there are over time, and the questions worth asking about that. */
+export interface Tally extends Cascade<number> {
+    /**
+     * That much more, on top of whatever else covers the same time.
+     *
+     * The verb a tally is mostly written in. Two teams each putting three
+     * people on a Monday have six people on that Monday.
+     */
+    readonly plus: (scope: PlainRule, amount: number) => Tally;
+    /**
+     * That many for these times, in place of whatever was said before.
+     *
+     * Instead of, not as well as. A skeleton crew on Christmas Eve is a figure
+     * that replaces the usual one, and writing it as a `plus` would need the
+     * author to know what they were adding to.
+     *
+     * "Exactly" is about the figure rather than the last word on it. This
+     * outranks every line above it, and a `plus` written afterwards still adds,
+     * the same way `hoursOn` works on a [schedule](./schedule.ts).
+     */
+    readonly exactly: (scope: PlainRule, amount: number) => Tally;
+    /**
+     * How many at that moment.
+     *
+     * Zero where no layer claims the moment. A cascade leaves an unclaimed
+     * moment out of its stream, and nobody rostered is nobody there, so this
+     * reads it as the figure it is. The same call
+     * [`isOpen`](./schedule.ts) makes for a schedule.
+     */
+    readonly at: (at: Temporal.ZonedDateTime) => number;
+    /**
+     * The lowest figure anywhere between two moments.
+     *
+     * The question capacity is really asking. A stretch that no layer claims
+     * counts as zero, so a window with a gap in it answers zero however well
+     * covered the rest of it is.
+     */
+    readonly least: (from: Temporal.ZonedDateTime, to: Temporal.ZonedDateTime) => number;
+    /**
+     * Each stretch between two moments, and how many are on for it.
+     *
+     * Leave `to` out for an endless run of them, which is lazy and safe to stop
+     * pulling from whenever you have enough.
+     */
+    readonly counts: (from: Temporal.ZonedDateTime, to?: Temporal.ZonedDateTime) => ValuedStream<number>;
+}
+/**
+ * An empty tally: nobody, until something says otherwise.
+ *
+ * ```ts
+ * const staff = tally()
+ *   .plus(weekdays(), 3)
+ *   .plus(weekends(), 1)
+ *   .plus("2026-03-11", 2)
+ *   .exactly("2026-12-24", 1);
+ * ```
+ */
+export declare function tally(): Tally;
+//# sourceMappingURL=tally.d.ts.map

package/dist/tally.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tally.d.ts","sourceRoot":"","sources":["../src/tally.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH,OAAO,EACL,KAAK,OAAO,EAKb,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAU,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAKvD,+EAA+E;AAC/E,MAAM,WAAW,KAAM,SAAQ,OAAO,CAAC,MAAM,CAAC;IAC5C;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,KAAK,KAAK,CAAC;IAE3D;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,KAAK,KAAK,CAAC;IAE9D;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE,QAAQ,CAAC,aAAa,KAAK,MAAM,CAAC;IAEpD;;;;;;OAMG;IACH,QAAQ,CAAC,KAAK,EAAE,CACd,IAAI,EAAE,QAAQ,CAAC,aAAa,EAC5B,EAAE,EAAE,QAAQ,CAAC,aAAa,KACvB,MAAM,CAAC;IAEZ;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,EAAE,CACf,IAAI,EAAE,QAAQ,CAAC,aAAa,EAC5B,EAAE,CAAC,EAAE,QAAQ,CAAC,aAAa,KACxB,YAAY,CAAC,MAAM,CAAC,CAAC;CAC3B;AAwDD;;;;;;;;;;GAUG;AACH,wBAAgB,KAAK,IAAI,KAAK,CAE7B"}

package/dist/tally.js

@@ -0,0 +1,80 @@
+/**
+ * How many, in the words people use for counting.
+ *
+ * The same relationship to [merging](./merge.ts) that a
+ * [schedule](./schedule.ts) has to a cascade. `merged("sum", layer(…),
+ * layer(…))` says what it does, and it asks the reader to know three things
+ * first: that layers overlap, that an overlap is what combines, and what a
+ * bare `"sum"` in the first argument governs. Nobody staffing a warehouse
+ * says any of that. They say three on weekdays, two more on the eleventh.
+ *
+ * A `Tally` *is* a `Cascade<number>` with `merge: "sum"`, so everything that
+ * takes a cascade takes one of these, and it serialises to the document a
+ * hand-written one would.
+ */
+import { valueAt } from "./assigned.js";
+import { always } from "./build.js";
+import { cascade, layer, replace, } from "./cascade.js";
+import { duration } from "./interval.js";
+import { asDays } from "./plain-forms.js";
+import { resolve } from "./resolve.js";
+/** Zero, as a duration to accumulate onto. */
+const NOTHING = Temporal.Duration.from({ seconds: 0 });
+/**
+ * A figure that claims its scope outright.
+ *
+ * The inner cascade covers the whole of the region this layer wins, which is
+ * what `always` means once it is resolved against that region rather than
+ * against the context.
+ */
+function fixed(scope, amount) {
+    const figure = cascade(layer(always(), amount));
+    return replace(asDays(scope), figure);
+}
+function build(layers) {
+    const self = {
+        type: "cascade",
+        merge: "sum",
+        layers,
+        plus: (scope, amount) => build([...layers, layer(asDays(scope), amount)]),
+        exactly: (scope, amount) => build([...layers, fixed(scope, amount)]),
+        at: (at) => valueAt(self, at) ?? 0,
+        least: (from, to) => {
+            let lowest;
+            let covered = NOTHING;
+            for (const span of resolve(self, { from, to })) {
+                lowest =
+                    lowest === undefined ? span.value : Math.min(lowest, span.value);
+                const length = duration(span);
+                if (length !== undefined) {
+                    covered = covered.add(length);
+                }
+            }
+            // Anything the layers left uncovered is nobody there, which is lower
+            // than any figure they assigned. Comparing what was covered against the
+            // window finds that without a second sweep for the gaps.
+            const window = from.until(to, { largestUnit: "hour" });
+            if (Temporal.Duration.compare(covered, window) < 0) {
+                return 0;
+            }
+            return lowest ?? 0;
+        },
+        counts: (from, to) => resolve(self, to === undefined ? { from } : { from, to }),
+    };
+    return self;
+}
+/**
+ * An empty tally: nobody, until something says otherwise.
+ *
+ * ```ts
+ * const staff = tally()
+ *   .plus(weekdays(), 3)
+ *   .plus(weekends(), 1)
+ *   .plus("2026-03-11", 2)
+ *   .exactly("2026-12-24", 1);
+ * ```
+ */
+export function tally() {
+    return build([]);
+}
+//# sourceMappingURL=tally.js.map

package/dist/tally.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tally.js","sourceRoot":"","sources":["../src/tally.ts"],"names":[],"mappings":"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"}

package/dist/time-rules.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The rule that selects a wall-clock window within each day.
+ *
+ * Wall clock rather than elapsed time is the whole point: across a daylight
+ * saving transition the clock times stay put and the real length of the window
+ * changes, which is what a schedule means by "nine to five".
+ */
+import { type Context } from "./context.js";
+import type { IntervalStream } from "./interval-stream.js";
+/**
+ * A wall-clock window within each day, endless unless the context bounds it.
+ *
+ * Starts a day earlier than the context does, because a window that wraps past
+ * midnight may have opened yesterday and still be running. Clipping to the
+ * window drops whatever that turns up too early.
+ */
+export declare function timeOfDayIntervals(context: Context, from: string, to: string, zone?: string): IntervalStream;
+//# sourceMappingURL=time-rules.d.ts.map

package/dist/time-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-rules.d.ts","sourceRoot":"","sources":["../src/time-rules.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,KAAK,OAAO,EAAU,MAAM,cAAc,CAAC;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D;;;;;;GAMG;AACH,wBAAiB,kBAAkB,CACjC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,IAAI,CAAC,EAAE,MAAM,GACZ,cAAc,CAgDhB"}

package/dist/time-rules.js

@@ -0,0 +1,55 @@
+/**
+ * The rule that selects a wall-clock window within each day.
+ *
+ * Wall clock rather than elapsed time is the whole point: across a daylight
+ * saving transition the clock times stay put and the real length of the window
+ * changes, which is what a schedule means by "nine to five".
+ */
+import { zoneOf } from "./context.js";
+/**
+ * A wall-clock window within each day, endless unless the context bounds it.
+ *
+ * Starts a day earlier than the context does, because a window that wraps past
+ * midnight may have opened yesterday and still be running. Clipping to the
+ * window drops whatever that turns up too early.
+ */
+export function* timeOfDayIntervals(context, from, to, zone) {
+    const inZone = zoneOf(context, zone);
+    const opens = Temporal.PlainTime.from(from);
+    const closes = Temporal.PlainTime.from(to);
+    if (Temporal.PlainTime.compare(opens, closes) === 0) {
+        throw new RangeError(`A time-of-day window from ${from} to ${to} has the same start and end. ` +
+            `Use { type: "always" } for a whole day.`);
+    }
+    // Earlier `to` than `from` means the window runs past midnight into the day
+    // after — a night shift, not an empty window.
+    const wraps = Temporal.PlainTime.compare(closes, opens) < 0;
+    const stop = context.to;
+    let date = context.from
+        .withTimeZone(inZone)
+        .toPlainDate()
+        .subtract({ days: 1 });
+    for (;;) {
+        const start = date.toZonedDateTime({ timeZone: inZone, plainTime: opens });
+        if (stop !== undefined &&
+            Temporal.ZonedDateTime.compare(start, stop) >= 0) {
+            return;
+        }
+        const closing = wraps ? date.add({ days: 1 }) : date;
+        const end = closing.toZonedDateTime({
+            timeZone: inZone,
+            plainTime: closes,
+        });
+        // A window can collapse to nothing on the morning clocks go forward. Both
+        // ends of 01:00-02:00 in London on 2026-03-29 resolve to the same instant,
+        // because the hour between them does not exist and Temporal's default
+        // disambiguation moves a nonexistent time forward to the far side of the
+        // gap. Yielding that would put a zero-length interval into a stream whose
+        // contract says there are none.
+        if (Temporal.ZonedDateTime.compare(start, end) < 0) {
+            yield { start, end };
+        }
+        date = date.add({ days: 1 });
+    }
+}
+//# sourceMappingURL=time-rules.js.map

package/dist/time-rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-rules.js","sourceRoot":"","sources":["../src/time-rules.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAgB,MAAM,EAAE,MAAM,cAAc,CAAC;AAGpD;;;;;;GAMG;AACH,MAAM,SAAS,CAAC,CAAC,kBAAkB,CACjC,OAAgB,EAChB,IAAY,EACZ,EAAU,EACV,IAAa;IAEb,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IACrC,MAAM,KAAK,GAAG,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC5C,MAAM,MAAM,GAAG,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAE3C,IAAI,QAAQ,CAAC,SAAS,CAAC,OAAO,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;QACpD,MAAM,IAAI,UAAU,CAClB,6BAA6B,IAAI,OAAO,EAAE,+BAA+B;YACvE,yCAAyC,CAC5C,CAAC;IACJ,CAAC;IAED,4EAA4E;IAC5E,8CAA8C;IAC9C,MAAM,KAAK,GAAG,QAAQ,CAAC,SAAS,CAAC,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IAC5D,MAAM,IAAI,GAAG,OAAO,CAAC,EAAE,CAAC;IACxB,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI;SACpB,YAAY,CAAC,MAAM,CAAC;SACpB,WAAW,EAAE;SACb,QAAQ,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC;IAEzB,SAAS,CAAC;QACR,MAAM,KAAK,GAAG,IAAI,CAAC,eAAe,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC;QAC3E,IACE,IAAI,KAAK,SAAS;YAClB,QAAQ,CAAC,aAAa,CAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,EAChD,CAAC;YACD,OAAO;QACT,CAAC;QAED,MAAM,OAAO,GAAG,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QACrD,MAAM,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC;YAClC,QAAQ,EAAE,MAAM;YAChB,SAAS,EAAE,MAAM;SAClB,CAAC,CAAC;QAEH,0EAA0E;QAC1E,2EAA2E;QAC3E,sEAAsE;QACtE,yEAAyE;QACzE,0EAA0E;QAC1E,gCAAgC;QAChC,IAAI,QAAQ,CAAC,aAAa,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YACnD,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC;QACvB,CAAC;QAED,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC;IAC/B,CAAC;AACH,CAAC"}