@kensio/quando 0.2.0 → 1.0.0

package/README.md

@@ -17,9 +17,6 @@ implements it. Quando reads the global rather than importing a polyfill, so it
 has no runtime dependencies; anywhere without `Temporal` natively can load
 `temporal-polyfill` first and everything here works untouched.
 
-> The rule language, builder, parser and queries below are on `main` and go out
-> in the next release. `0.1.0` on npm carries only the interval core.
-
 ## A rule
 
 ```ts
@@ -70,7 +67,7 @@ For opening hours and rotas there is a plainer front door, which builds the same
 thing:
 
 ```ts
-import { rota, schedule, weekdays, weekends } from "@kensio/quando";
+import { rota, schedule, tally, weekdays, weekends } from "@kensio/quando";
 
 const openingHours = schedule()
   .open(weekdays(), "09:00-17:00")
@@ -84,10 +81,17 @@ const onCall = rota().assign(weekdays(), "alice").assign(weekends(), "bob");
 
 onCall.whoIsOn(friday);
 // → "alice"
+
+const staff = tally().plus(weekdays(), 3).plus("2026-03-11", 2);
+
+staff.at(Temporal.ZonedDateTime.from("2026-03-11T11:00[Europe/London]"));
+// → 5
 ```
 
-Each line outranks the ones above it, so exceptions read in the order you would
-say them. See [schedules and rotas](docs/schedules/).
+For a schedule and a rota each line outranks the ones above it, so exceptions
+read in the order you would say them. A tally is the one that adds instead,
+because two teams of three on a Monday are six people. See
+[schedules and rotas](docs/schedules/) and [merging](docs/merging/).
 
 ## Why intervals
 
@@ -113,6 +117,8 @@ this repository:
 - [Serialisation](docs/serialisation/) — the JSON form and its boundary
 - [Schedules and rotas](docs/schedules/) — opening hours and who is on, plainly
 - [Cascades](docs/cascades/) — layers carrying values, resolved by precedence
+- [Merging](docs/merging/) — overlap that adds rather than displaces
+- [Comparing](docs/comparing/) — canonical form, equality and cache keys
 - [API](docs/api/) — everything the package exports
 
 ## What it is not
@@ -122,8 +128,12 @@ scheduler: Quando calculates _when_ and never fires anything, so its answer is
 your scheduler's input. Not storage, and not a holiday data provider; calendar
 data belongs in satellite packages so that the core carries none.
 
-Cascades carry values by precedence; merging values that should add rather than
-displace is designed and not yet built, along with estimates and a command line.
+Not a constraint solver either. Caps per window, minimum spacing and
+rolling-window totals ("ninety days in any hundred and eighty") constrain a
+pattern of occurrences rather than the moments in one, which is a different
+problem. See [what a rule cannot say](docs/concepts/#what-a-rule-cannot-say).
+
+Estimates, rule set diffing and a command line are designed and not yet built.
 
 ## Licence
 

package/dist/assigned.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Asking the four questions of a cascade rather than of a rule.
+ *
+ * `activeAt`, `elapsed`, `next` and `advanceBy` are about *when*, and a rule
+ * is what they read. A cascade says *what holds when*, which is a different
+ * question. Narrowing one to a single value turns it back into the first.
+ * The times a rota assigns to Alice are a stretch of when, and every question
+ * worth asking about a rule is worth asking about them.
+ *
+ * So {@link assigned} is what the queries take in place of a rule, and
+ * {@link valueAt} is the one question a rule has no version of.
+ */
+import type { Cascade, Valued } from "./cascade.js";
+import type { Context } from "./context.js";
+import type { IntervalStream } from "./interval-stream.js";
+import type { Rule } from "./rule.js";
+/**
+ * A cascade narrowed to the times it assigns one value.
+ *
+ * Not a rule, and deliberately not made to look like one. A rule is a document
+ * that stores and travels, and this is a question asked at the point of
+ * asking. Building one costs nothing and evaluates nothing.
+ */
+export interface Assigned<V> {
+    readonly cascade: Cascade<V>;
+    readonly is: V;
+}
+/** Either of the two things a query can read as the times it covers. */
+export type Covers<V> = Rule | Assigned<V>;
+/**
+ * The times a cascade assigns a value.
+ *
+ * ```ts
+ * elapsed(assigned(onCall, "alice"), week);
+ * advanceBy(from, threeHours, { during: assigned(onCall, "alice") });
+ * ```
+ *
+ * Sameness is `Object.is`, the same test {@link coalesce} uses, so a value
+ * matches by identity rather than by shape.
+ */
+export declare function assigned<V>(cascade: Cascade<V>, is: V): Assigned<V>;
+/**
+ * The times something covers, whichever of the two it is.
+ *
+ * This is the one place the queries have to know that a cascade exists, and
+ * what comes back either way is an ordinary interval stream, so everything
+ * above it stays written once.
+ */
+export declare function covered<V>(covers: Covers<V>, context: Context): IntervalStream;
+/**
+ * What a cascade assigns at an instant, or `undefined` where nothing does.
+ *
+ * The question a rule has no version of. `activeAt` asks whether a rule covers
+ * a moment, and the answer for a cascade is not whether but what.
+ *
+ * Always terminates, whatever the layers say, because it asks about the
+ * smallest window there is.
+ */
+export declare function valueAt<V>(cascade: Cascade<V>, at: Temporal.ZonedDateTime, context?: Omit<Context, "from" | "to">): V | undefined;
+/**
+ * The next stretch a cascade assigns anything at all, with its value.
+ *
+ * `next` narrowed to one value answers "when is Alice next on". This answers
+ * "what happens next", whatever that turns out to be, which is the question a
+ * timeline asks.
+ */
+export declare function nextValue<V>(cascade: Cascade<V>, context: Context): Valued<V> | undefined;
+//# sourceMappingURL=assigned.d.ts.map

package/dist/assigned.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assigned.d.ts","sourceRoot":"","sources":["../src/assigned.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAG3D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAGtC;;;;;;GAMG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IAC7B,QAAQ,CAAC,EAAE,EAAE,CAAC,CAAC;CAChB;AAED,wEAAwE;AACxE,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,IAAI,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;AAE3C;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAEnE;AAOD;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,EACjB,OAAO,EAAE,OAAO,GACf,cAAc,CAKhB;AAWD;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,EAAE,EAAE,QAAQ,CAAC,aAAa,EAC1B,OAAO,CAAC,EAAE,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC,GACrC,CAAC,GAAG,SAAS,CAQf;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,OAAO,EAAE,OAAO,GACf,MAAM,CAAC,CAAC,CAAC,GAAG,SAAS,CAGvB"}

package/dist/assigned.js

@@ -0,0 +1,84 @@
+/**
+ * Asking the four questions of a cascade rather than of a rule.
+ *
+ * `activeAt`, `elapsed`, `next` and `advanceBy` are about *when*, and a rule
+ * is what they read. A cascade says *what holds when*, which is a different
+ * question. Narrowing one to a single value turns it back into the first.
+ * The times a rota assigns to Alice are a stretch of when, and every question
+ * worth asking about a rule is worth asking about them.
+ *
+ * So {@link assigned} is what the queries take in place of a rule, and
+ * {@link valueAt} is the one question a rule has no version of.
+ */
+import { intervals } from "./interpret.js";
+import { resolve } from "./resolve.js";
+import { take } from "./stream.js";
+/**
+ * The times a cascade assigns a value.
+ *
+ * ```ts
+ * elapsed(assigned(onCall, "alice"), week);
+ * advanceBy(from, threeHours, { during: assigned(onCall, "alice") });
+ * ```
+ *
+ * Sameness is `Object.is`, the same test {@link coalesce} uses, so a value
+ * matches by identity rather than by shape.
+ */
+export function assigned(cascade, is) {
+    return { cascade, is };
+}
+/** Whether a query is reading a rule or a narrowed cascade. */
+function isRule(covers) {
+    return "type" in covers;
+}
+/**
+ * The times something covers, whichever of the two it is.
+ *
+ * This is the one place the queries have to know that a cascade exists, and
+ * what comes back either way is an ordinary interval stream, so everything
+ * above it stays written once.
+ */
+export function covered(covers, context) {
+    if (isRule(covers)) {
+        return intervals(covers, context);
+    }
+    return matching(covers, context);
+}
+/** The stretches of a resolved cascade carrying the value asked for. */
+function* matching(covers, context) {
+    for (const span of resolve(covers.cascade, context)) {
+        if (Object.is(span.value, covers.is)) {
+            yield { start: span.start, end: span.end };
+        }
+    }
+}
+/**
+ * What a cascade assigns at an instant, or `undefined` where nothing does.
+ *
+ * The question a rule has no version of. `activeAt` asks whether a rule covers
+ * a moment, and the answer for a cascade is not whether but what.
+ *
+ * Always terminates, whatever the layers say, because it asks about the
+ * smallest window there is.
+ */
+export function valueAt(cascade, at, context) {
+    const moment = {
+        ...context,
+        from: at,
+        to: at.add({ nanoseconds: 1 }),
+    };
+    const [now] = take(resolve(cascade, moment), 1);
+    return now?.value;
+}
+/**
+ * The next stretch a cascade assigns anything at all, with its value.
+ *
+ * `next` narrowed to one value answers "when is Alice next on". This answers
+ * "what happens next", whatever that turns out to be, which is the question a
+ * timeline asks.
+ */
+export function nextValue(cascade, context) {
+    const [first] = take(resolve(cascade, context), 1);
+    return first;
+}
+//# sourceMappingURL=assigned.js.map

package/dist/assigned.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assigned.js","sourceRoot":"","sources":["../src/assigned.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAKH,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAiBnC;;;;;;;;;;GAUG;AACH,MAAM,UAAU,QAAQ,CAAI,OAAmB,EAAE,EAAK;IACpD,OAAO,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC;AACzB,CAAC;AAED,+DAA+D;AAC/D,SAAS,MAAM,CAAI,MAAiB;IAClC,OAAO,MAAM,IAAI,MAAM,CAAC;AAC1B,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,OAAO,CACrB,MAAiB,EACjB,OAAgB;IAEhB,IAAI,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC;QACnB,OAAO,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACpC,CAAC;IACD,OAAO,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AACnC,CAAC;AAED,wEAAwE;AACxE,QAAQ,CAAC,CAAC,QAAQ,CAAI,MAAmB,EAAE,OAAgB;IACzD,KAAK,MAAM,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,CAAC;QACpD,IAAI,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC;YACrC,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,CAAC,GAAG,EAAE,CAAC;QAC7C,CAAC;IACH,CAAC;AACH,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,OAAO,CACrB,OAAmB,EACnB,EAA0B,EAC1B,OAAsC;IAEtC,MAAM,MAAM,GAAY;QACtB,GAAG,OAAO;QACV,IAAI,EAAE,EAAE;QACR,EAAE,EAAE,EAAE,CAAC,GAAG,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,CAAC;KAC/B,CAAC;IACF,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC;IAChD,OAAO,GAAG,EAAE,KAAK,CAAC;AACpB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,SAAS,CACvB,OAAmB,EACnB,OAAgB;IAEhB,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC;IACnD,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/canonical-rule.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The one form of a rule that says what a rule says.
+ *
+ * `.except(…)` is `all(this, not(any(…)))` spelled out, so a rule built with
+ * it carries an `all` inside an `all`. Nothing is wrong with that, and it does
+ * mean two rules a reader would call identical are two different documents.
+ * Comparing them, hashing them or diffing them all want the same thing first,
+ * which is a form that depends on what a rule says rather than on how it was
+ * written.
+ *
+ * The normal form here is syntactic. It flattens, drops identities, collapses
+ * double negation, sorts and deduplicates, and stops. Two rules that *cover
+ * the same time* by different routes stay different, because deciding that in
+ * general means evaluating them over all of time. `always` and the seven days
+ * of the week are the pair to keep in mind.
+ *
+ * Nothing here throws. A rule holding a date that will not parse comes back
+ * with that date untouched, because a function used for cache keys is worth
+ * more total than strict, and `parseRule` is the place that refuses.
+ */
+import { type Rule } from "./rule.js";
+export declare function canonicalRule(rule: Rule): Rule;
+//# sourceMappingURL=canonical-rule.d.ts.map

package/dist/canonical-rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonical-rule.d.ts","sourceRoot":"","sources":["../src/canonical-rule.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,KAAK,IAAI,EAA0B,MAAM,WAAW,CAAC;AAyF9D,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAqD9C"}

package/dist/canonical-rule.js

@@ -0,0 +1,139 @@
+/**
+ * The one form of a rule that says what a rule says.
+ *
+ * `.except(…)` is `all(this, not(any(…)))` spelled out, so a rule built with
+ * it carries an `all` inside an `all`. Nothing is wrong with that, and it does
+ * mean two rules a reader would call identical are two different documents.
+ * Comparing them, hashing them or diffing them all want the same thing first,
+ * which is a form that depends on what a rule says rather than on how it was
+ * written.
+ *
+ * The normal form here is syntactic. It flattens, drops identities, collapses
+ * double negation, sorts and deduplicates, and stops. Two rules that *cover
+ * the same time* by different routes stay different, because deciding that in
+ * general means evaluating them over all of time. `always` and the seven days
+ * of the week are the pair to keep in mind.
+ *
+ * Nothing here throws. A rule holding a date that will not parse comes back
+ * with that date untouched, because a function used for cache keys is worth
+ * more total than strict, and `parseRule` is the place that refuses.
+ */
+import { WEEKDAYS } from "./rule.js";
+/** Where a weekday sorts. Calendar order rather than alphabetical. */
+const DAY_ORDER = new Map(WEEKDAYS.map((day, index) => [day, index]));
+/** A rule's stable string form, which is what sorting and equality compare. */
+function key(rule) {
+    return JSON.stringify(rule);
+}
+/** Present or absent, never present-and-undefined. */
+function zonePart(zone) {
+    return zone === undefined ? {} : { zone };
+}
+const asTime = (from) => Temporal.PlainTime.from(from);
+const asDate = (from) => Temporal.PlainDate.from(from);
+/**
+ * A `Temporal` value written the one way, where it can be read at all.
+ *
+ * `"09:00"` and `"09:00:00"` are the same time of day written twice, and two
+ * rules holding one each should compare equal. A string neither form can read
+ * is handed back as it came, so this stays total.
+ */
+function written(value, read) {
+    try {
+        return read(value).toString();
+    }
+    catch {
+        return value;
+    }
+}
+function canonicalDays(days) {
+    return [...new Set(days)].toSorted((a, b) => (DAY_ORDER.get(a) ?? 0) - (DAY_ORDER.get(b) ?? 0));
+}
+function canonicalDates(dates) {
+    const one = dates.map((date) => written(date, asDate));
+    return [...new Set(one)].toSorted();
+}
+/**
+ * The operands of an `all` or an `any`, flattened, reduced and ordered.
+ *
+ * Both are the same shape with the two constants swapped. For `all`, `always`
+ * adds nothing and `never` settles it. For `any` it is the other way round.
+ */
+function combined(type, rules) {
+    const absorbed = type === "all" ? "always" : "never";
+    const settles = type === "all" ? "never" : "always";
+    const flat = [];
+    for (const rule of rules) {
+        const inner = canonicalRule(rule);
+        if (inner.type === settles) {
+            return { type: settles };
+        }
+        if (inner.type === absorbed) {
+            continue;
+        }
+        // Already canonical, so its own operands are reduced and its type is not
+        // the one being flattened into unless it genuinely nests.
+        if (inner.type === type) {
+            flat.push(...inner.rules);
+            continue;
+        }
+        flat.push(inner);
+    }
+    const kept = [...new Map(flat.map((rule) => [key(rule), rule])).values()];
+    const unique = kept.toSorted((a, b) => key(a).localeCompare(key(b)));
+    const only = unique[0];
+    if (only === undefined) {
+        return { type: absorbed };
+    }
+    return unique.length === 1 ? only : { type, rules: unique };
+}
+export function canonicalRule(rule) {
+    switch (rule.type) {
+        case "always":
+        case "never": {
+            return { type: rule.type };
+        }
+        case "daysOfWeek": {
+            return {
+                type: "daysOfWeek",
+                days: canonicalDays(rule.days),
+                ...zonePart(rule.zone),
+            };
+        }
+        case "dates": {
+            return {
+                type: "dates",
+                dates: canonicalDates(rule.dates),
+                ...zonePart(rule.zone),
+            };
+        }
+        case "timeOfDay": {
+            return {
+                type: "timeOfDay",
+                from: written(rule.from, asTime),
+                to: written(rule.to, asTime),
+                ...zonePart(rule.zone),
+            };
+        }
+        case "not": {
+            const inner = canonicalRule(rule.rule);
+            // Two complements cancel, and the complement of a constant is the other
+            // one. Both keep a `not` out of the form where it says nothing.
+            if (inner.type === "not") {
+                return inner.rule;
+            }
+            if (inner.type === "always") {
+                return { type: "never" };
+            }
+            if (inner.type === "never") {
+                return { type: "always" };
+            }
+            return { type: "not", rule: inner };
+        }
+        case "all":
+        case "any": {
+            return combined(rule.type, rule.rules);
+        }
+    }
+}
+//# sourceMappingURL=canonical-rule.js.map

package/dist/canonical-rule.js.map

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

package/dist/canonical.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Comparing rules and cascades, and the one form that makes it possible.
+ *
+ * [canonical-rule.ts](./canonical-rule.ts) holds the normal form itself and
+ * the reasoning behind where it stops. This is the surface over it: the same
+ * treatment for a cascade, a stable key, and equality.
+ */
+import { type Cascade } from "./cascade.js";
+import type { Rule } from "./rule.js";
+/**
+ * The one form of a rule or a cascade that says what this one says.
+ *
+ * ```ts
+ * canonical(weekdays().except(dates("2026-12-25")));
+ * ```
+ *
+ * Flattens nested `all` and `any`, drops `always` from an `all` and `never`
+ * from an `any`, settles the ones that dominate, cancels double negation,
+ * deduplicates, and orders what is left. Leaves are ordered too, so
+ * `daysOfWeek("friday", "monday")` and `daysOfWeek("monday", "friday")` are
+ * the same document afterwards.
+ *
+ * A cascade keeps its layer order, because that order is its meaning.
+ */
+export declare function canonical(rule: Rule): Rule;
+export declare function canonical<V>(cascade: Cascade<V>): Cascade<V>;
+/**
+ * A stable string for a rule or a cascade, the same for any two that say the
+ * same thing.
+ *
+ * What a cache key is. A cascade's values go through `JSON.stringify` with
+ * everything else, so this is worth as much as those values are storable.
+ */
+export declare function fingerprint<V>(value: Rule | Cascade<V>): string;
+/**
+ * Whether two rules, or two cascades, say the same thing.
+ *
+ * Syntactic, and deliberately so. Two rules that cover the same time by
+ * different routes are not equal, because deciding that in general means
+ * evaluating them over all of time. `always` and all seven days of the week
+ * are the pair to remember.
+ */
+export declare function equals<V>(left: Rule | Cascade<V>, right: Rule | Cascade<V>): boolean;
+//# sourceMappingURL=canonical.d.ts.map

package/dist/canonical.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonical.d.ts","sourceRoot":"","sources":["../src/canonical.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EAAE,KAAK,OAAO,EAAyB,MAAM,cAAc,CAAC;AACnE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAwBtC;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAAC;AAC5C,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAK9D;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,MAAM,CAE/D;AAED;;;;;;;GAOG;AACH,wBAAgB,MAAM,CAAC,CAAC,EACtB,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC,EACvB,KAAK,EAAE,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC,GACvB,OAAO,CAET"}

package/dist/canonical.js

@@ -0,0 +1,53 @@
+/**
+ * Comparing rules and cascades, and the one form that makes it possible.
+ *
+ * [canonical-rule.ts](./canonical-rule.ts) holds the normal form itself and
+ * the reasoning behind where it stops. This is the surface over it: the same
+ * treatment for a cascade, a stable key, and equality.
+ */
+import { canonicalRule } from "./canonical-rule.js";
+import { isCascade } from "./cascade.js";
+function canonicalLayer(layer) {
+    return "value" in layer
+        ? { scope: canonicalRule(layer.scope), value: layer.value }
+        : {
+            scope: canonicalRule(layer.scope),
+            replace: canonicalCascade(layer.replace),
+        };
+}
+/**
+ * Layers keep their order, because order is what a cascade means. What changes
+ * is each scope, and a `merge` of `"override"` written out, which is the
+ * default said twice.
+ */
+function canonicalCascade(cascade) {
+    const layers = cascade.layers.map((layer) => canonicalLayer(layer));
+    return cascade.merge === undefined || cascade.merge === "override"
+        ? { type: "cascade", layers }
+        : { type: "cascade", merge: cascade.merge, layers };
+}
+export function canonical(value) {
+    return isCascade(value) ? canonicalCascade(value) : canonicalRule(value);
+}
+/**
+ * A stable string for a rule or a cascade, the same for any two that say the
+ * same thing.
+ *
+ * What a cache key is. A cascade's values go through `JSON.stringify` with
+ * everything else, so this is worth as much as those values are storable.
+ */
+export function fingerprint(value) {
+    return JSON.stringify(canonical(value));
+}
+/**
+ * Whether two rules, or two cascades, say the same thing.
+ *
+ * Syntactic, and deliberately so. Two rules that cover the same time by
+ * different routes are not equal, because deciding that in general means
+ * evaluating them over all of time. `always` and all seven days of the week
+ * are the pair to remember.
+ */
+export function equals(left, right) {
+    return fingerprint(left) === fingerprint(right);
+}
+//# sourceMappingURL=canonical.js.map

package/dist/canonical.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonical.js","sourceRoot":"","sources":["../src/canonical.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAgB,SAAS,EAAc,MAAM,cAAc,CAAC;AAGnE,SAAS,cAAc,CAAI,KAAe;IACxC,OAAO,OAAO,IAAI,KAAK;QACrB,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE;QAC3D,CAAC,CAAC;YACE,KAAK,EAAE,aAAa,CAAC,KAAK,CAAC,KAAK,CAAC;YACjC,OAAO,EAAE,gBAAgB,CAAC,KAAK,CAAC,OAAO,CAAC;SACzC,CAAC;AACR,CAAC;AAED;;;;GAIG;AACH,SAAS,gBAAgB,CAAI,OAAmB;IAC9C,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,CAAC;IAEpE,OAAO,OAAO,CAAC,KAAK,KAAK,SAAS,IAAI,OAAO,CAAC,KAAK,KAAK,UAAU;QAChE,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE;QAC7B,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC;AACxD,CAAC;AAmBD,MAAM,UAAU,SAAS,CAAI,KAAwB;IACnD,OAAO,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;AAC3E,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,WAAW,CAAI,KAAwB;IACrD,OAAO,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,KAAa,CAAC,CAAC,CAAC;AAClD,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,MAAM,CACpB,IAAuB,EACvB,KAAwB;IAExB,OAAO,WAAW,CAAC,IAAI,CAAC,KAAK,WAAW,CAAC,KAAK,CAAC,CAAC;AAClD,CAAC"}

package/dist/cascade.d.ts

@@ -11,6 +11,7 @@
  * only appear where they are actually needed, which is assignment.
  */
 import type { Interval } from "./interval.js";
+import type { MergeStrategy } from "./merge.js";
 import type { Rule } from "./rule.js";
 /**
  * An interval with a value assigned to it.
@@ -58,12 +59,32 @@ export interface ReplacingLayer<V> {
  */
 export interface Cascade<V> {
     readonly type: "cascade";
+    /**
+     * What happens where two layers claim the same moment. Absent means
+     * `override`, which is the precedence a cascade has always had.
+     *
+     * The strategy is a name in the document. A merge function passed to
+     * `resolve` could not be stored, and a cascade that no longer says how it
+     * combines is one two readers can disagree about.
+     */
+    readonly merge?: MergeStrategy;
     readonly layers: readonly Layer<V>[];
 }
 /** Whether a value is a cascade rather than a rule. */
 export declare function isCascade<V>(value: Rule | Cascade<V>): value is Cascade<V>;
 /** An ordered list of layers, lowest priority first. */
 export declare function cascade<V>(...layers: readonly Layer<V>[]): Cascade<V>;
+/**
+ * An ordered list of layers whose overlaps combine rather than displace.
+ *
+ * ```ts
+ * const staff = merged("sum", layer(weekdays(), 3), layer(dates("2026-03-11"), 2));
+ * ```
+ *
+ * The Wednesday has five. Under {@link cascade} it would have two, because the
+ * later layer would displace the earlier one.
+ */
+export declare function merged<V>(strategy: MergeStrategy, ...layers: readonly Layer<V>[]): Cascade<V>;
 /** One value, across the whole of a scope. */
 export declare function layer<V>(scope: Rule, value: V): ConstantLayer<V>;
 /**

package/dist/cascade.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cascade.d.ts","sourceRoot":"","sources":["../src/cascade.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEtC;;;;;GAKG;AACH,MAAM,WAAW,MAAM,CAAC,CAAC,CAAE,SAAQ,QAAQ;IACzC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;CACnB;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC;AAE5D,iEAAiE;AACjE,MAAM,WAAW,aAAa,CAAC,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;CACnB;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,cAAc,CAAC,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC;IACrB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;CAC9B;AAED;;;;;GAKG;AACH,MAAM,WAAW,OAAO,CAAC,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,SAAS,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;CACtC;AAED,uDAAuD;AACvD,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,KAAK,IAAI,OAAO,CAAC,CAAC,CAAC,CAE1E;AAED,wDAAwD;AACxD,wBAAgB,OAAO,CAAC,CAAC,EAAE,GAAG,MAAM,EAAE,SAAS,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,CAErE;AAED,8CAA8C;AAC9C,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAEhE;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,CAErD;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,KAAK,EAAE,IAAI,EACX,WAAW,EAAE,OAAO,CAAC,CAAC,CAAC,GACtB,cAAc,CAAC,CAAC,CAAC,CAAC;AACrB,wBAAgB,OAAO,CACrB,KAAK,EAAE,IAAI,EACX,WAAW,EAAE,IAAI,GAChB,cAAc,CAAC,OAAO,CAAC,CAAC"}
+{"version":3,"file":"cascade.d.ts","sourceRoot":"","sources":["../src/cascade.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEtC;;;;;GAKG;AACH,MAAM,WAAW,MAAM,CAAC,CAAC,CAAE,SAAQ,QAAQ;IACzC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;CACnB;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC;AAE5D,iEAAiE;AACjE,MAAM,WAAW,aAAa,CAAC,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;CACnB;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,cAAc,CAAC,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC;IACrB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;CAC9B;AAED;;;;;GAKG;AACH,MAAM,WAAW,OAAO,CAAC,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB;;;;;;;OAOG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,aAAa,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,SAAS,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;CACtC;AAED,uDAAuD;AACvD,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,KAAK,IAAI,OAAO,CAAC,CAAC,CAAC,CAE1E;AAED,wDAAwD;AACxD,wBAAgB,OAAO,CAAC,CAAC,EAAE,GAAG,MAAM,EAAE,SAAS,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,CAErE;AAED;;;;;;;;;GASG;AACH,wBAAgB,MAAM,CAAC,CAAC,EACtB,QAAQ,EAAE,aAAa,EACvB,GAAG,MAAM,EAAE,SAAS,KAAK,CAAC,CAAC,CAAC,EAAE,GAC7B,OAAO,CAAC,CAAC,CAAC,CAEZ;AAED,8CAA8C;AAC9C,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAEhE;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,CAErD;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,KAAK,EAAE,IAAI,EACX,WAAW,EAAE,OAAO,CAAC,CAAC,CAAC,GACtB,cAAc,CAAC,CAAC,CAAC,CAAC;AACrB,wBAAgB,OAAO,CACrB,KAAK,EAAE,IAAI,EACX,WAAW,EAAE,IAAI,GAChB,cAAc,CAAC,OAAO,CAAC,CAAC"}

package/dist/cascade.js

@@ -18,6 +18,19 @@ export function isCascade(value) {
 export function cascade(...layers) {
     return { type: "cascade", layers };
 }
+/**
+ * An ordered list of layers whose overlaps combine rather than displace.
+ *
+ * ```ts
+ * const staff = merged("sum", layer(weekdays(), 3), layer(dates("2026-03-11"), 2));
+ * ```
+ *
+ * The Wednesday has five. Under {@link cascade} it would have two, because the
+ * later layer would displace the earlier one.
+ */
+export function merged(strategy, ...layers) {
+    return { type: "cascade", merge: strategy, layers };
+}
 /** One value, across the whole of a scope. */
 export function layer(scope, value) {
     return { scope, value };

package/dist/cascade.js.map

@@ -1 +1 @@
-{"version":3,"file":"cascade.js","sourceRoot":"","sources":["../src/cascade.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AA0DH,uDAAuD;AACvD,MAAM,UAAU,SAAS,CAAI,KAAwB;IACnD,OAAO,KAAK,CAAC,IAAI,KAAK,SAAS,CAAC;AAClC,CAAC;AAED,wDAAwD;AACxD,MAAM,UAAU,OAAO,CAAI,GAAG,MAA2B;IACvD,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC;AACrC,CAAC;AAED,8CAA8C;AAC9C,MAAM,UAAU,KAAK,CAAI,KAAW,EAAE,KAAQ;IAC5C,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;AAC1B,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,QAAQ,CAAC,IAAU;IACjC,OAAO,OAAO,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;AACpC,CAAC;AAkBD,MAAM,UAAU,OAAO,CACrB,KAAW,EACX,WAAoC;IAEpC,OAAO;QACL,KAAK;QACL,OAAO,EAAE,SAAS,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC;KACtE,CAAC;AACJ,CAAC"}
+{"version":3,"file":"cascade.js","sourceRoot":"","sources":["../src/cascade.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAoEH,uDAAuD;AACvD,MAAM,UAAU,SAAS,CAAI,KAAwB;IACnD,OAAO,KAAK,CAAC,IAAI,KAAK,SAAS,CAAC;AAClC,CAAC;AAED,wDAAwD;AACxD,MAAM,UAAU,OAAO,CAAI,GAAG,MAA2B;IACvD,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC;AACrC,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,MAAM,CACpB,QAAuB,EACvB,GAAG,MAA2B;IAE9B,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;AACtD,CAAC;AAED,8CAA8C;AAC9C,MAAM,UAAU,KAAK,CAAI,KAAW,EAAE,KAAQ;IAC5C,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;AAC1B,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,QAAQ,CAAC,IAAU;IACjC,OAAO,OAAO,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;AACpC,CAAC;AAkBD,MAAM,UAAU,OAAO,CACrB,KAAW,EACX,WAAoC;IAEpC,OAAO;QACL,KAAK;QACL,OAAO,EAAE,SAAS,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC;KACtE,CAAC;AACJ,CAAC"}

package/dist/index.d.ts

@@ -29,15 +29,26 @@ export { intervals } from "./interpret.js";
 export type { Built } from "./build.js";
 export { all, always, any, dates, daysOfWeek, inZone, never, not, timeOfDay, weekdays, weekends, } from "./build.js";
 export { parseRule } from "./parse.js";
+export type { ValueParser } from "./parse-cascade.js";
+export { parseCascade } from "./parse-cascade.js";
+export { asBoolean, asString, fail } from "./parse-shape.js";
 export type { Cascade, ConstantLayer, Layer, ReplacingLayer, Valued, } from "./cascade.js";
-export { cascade, isCascade, layer, replace, whenever } from "./cascade.js";
+export { cascade, isCascade, layer, merged, replace, whenever, } from "./cascade.js";
+export type { Merge, MergeStrategy } from "./merge.js";
+export { MERGE_STRATEGIES } from "./merge.js";
 export type { ValuedStream } from "./valued-stream.js";
+export { overlay } from "./valued-stream.js";
 export { resolve } from "./resolve.js";
+export { canonical, equals, fingerprint } from "./canonical.js";
 export type { PlainRule } from "./plain-forms.js";
 export type { Schedule } from "./schedule.js";
 export { schedule } from "./schedule.js";
 export type { Rota } from "./rota.js";
 export { rota } from "./rota.js";
+export type { Tally } from "./tally.js";
+export { tally } from "./tally.js";
+export type { Assigned, Covers } from "./assigned.js";
+export { assigned, nextValue, valueAt } from "./assigned.js";
 export type { Search } from "./query.js";
 export { activeAt, advanceBy, elapsed, next } from "./query.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,YAAY,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EACL,WAAW,EACX,aAAa,EACb,QAAQ,EACR,QAAQ,EACR,OAAO,EACP,mBAAmB,EACnB,eAAe,GAChB,MAAM,eAAe,CAAC;AAEvB,YAAY,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAE1E,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAEnC,YAAY,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAE5C,YAAY,EACV,OAAO,EACP,OAAO,EACP,UAAU,EACV,SAAS,EACT,cAAc,EACd,SAAS,EACT,OAAO,EACP,IAAI,EACJ,aAAa,EACb,OAAO,GACR,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAErC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C,YAAY,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,EACL,GAAG,EACH,MAAM,EACN,GAAG,EACH,KAAK,EACL,UAAU,EACV,MAAM,EACN,KAAK,EACL,GAAG,EACH,SAAS,EACT,QAAQ,EACR,QAAQ,GACT,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEvC,YAAY,EACV,OAAO,EACP,aAAa,EACb,KAAK,EACL,cAAc,EACd,MAAM,GACP,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAE5E,YAAY,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC,YAAY,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElD,YAAY,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC,YAAY,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,YAAY,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,YAAY,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EACL,WAAW,EACX,aAAa,EACb,QAAQ,EACR,QAAQ,EACR,OAAO,EACP,mBAAmB,EACnB,eAAe,GAChB,MAAM,eAAe,CAAC;AAEvB,YAAY,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAE1E,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAEnC,YAAY,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAE5C,YAAY,EACV,OAAO,EACP,OAAO,EACP,UAAU,EACV,SAAS,EACT,cAAc,EACd,SAAS,EACT,OAAO,EACP,IAAI,EACJ,aAAa,EACb,OAAO,GACR,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAErC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C,YAAY,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,EACL,GAAG,EACH,MAAM,EACN,GAAG,EACH,KAAK,EACL,UAAU,EACV,MAAM,EACN,KAAK,EACL,GAAG,EACH,SAAS,EACT,QAAQ,EACR,QAAQ,GACT,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEvC,YAAY,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAE7D,YAAY,EACV,OAAO,EACP,aAAa,EACb,KAAK,EACL,cAAc,EACd,MAAM,GACP,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,OAAO,EACP,SAAS,EACT,KAAK,EACL,MAAM,EACN,OAAO,EACP,QAAQ,GACT,MAAM,cAAc,CAAC;AAEtB,YAAY,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAE9C,YAAY,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAE7C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAEhE,YAAY,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElD,YAAY,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC,YAAY,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,YAAY,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,YAAY,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAE7D,YAAY,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -24,9 +24,16 @@ export { WEEKDAYS } from "./rule.js";
 export { intervals } from "./interpret.js";
 export { all, always, any, dates, daysOfWeek, inZone, never, not, timeOfDay, weekdays, weekends, } from "./build.js";
 export { parseRule } from "./parse.js";
-export { cascade, isCascade, layer, replace, whenever } from "./cascade.js";
+export { parseCascade } from "./parse-cascade.js";
+export { asBoolean, asString, fail } from "./parse-shape.js";
+export { cascade, isCascade, layer, merged, replace, whenever, } from "./cascade.js";
+export { MERGE_STRATEGIES } from "./merge.js";
+export { overlay } from "./valued-stream.js";
 export { resolve } from "./resolve.js";
+export { canonical, equals, fingerprint } from "./canonical.js";
 export { schedule } from "./schedule.js";
 export { rota } from "./rota.js";
+export { tally } from "./tally.js";
+export { assigned, nextValue, valueAt } from "./assigned.js";
 export { activeAt, advanceBy, elapsed, next } from "./query.js";
 //# sourceMappingURL=index.js.map