@kensio/quando 0.1.0-beta.0 → 0.2.0

package/README.md

@@ -2,8 +2,129 @@
 
 Declarative temporal rules for schedules, deadlines, constraints, and exceptions.
 
-## Status
+Quando answers one question: **given these rules about time, when does something
+happen?** `Temporal` tells you what a moment _is_; Quando tells you when
+something _occurs_ — "weekdays nine to five, except bank holidays", and then
+what that implies about now, about a window, and about three working hours from
+here.
 
-Early. The API is still being designed and nothing is published yet, so there is
-nothing here to install or call. `src/index.ts` is a placeholder that exists to
-keep the build and test pipeline honest until it has real code to run over.
+```bash
+npm install @kensio/quando
+```
+
+Requires a runtime with `Temporal`: **Node 26 or later**, or a browser that
+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
+import { timeOfDay, weekdays } from "@kensio/quando";
+
+const openingHours = weekdays().and(timeOfDay("09:00", "17:00"));
+```
+
+There is no build step to that: it is already the rule, a plain JSON-shaped
+object with methods hanging off it. `JSON.stringify` gives you a document you
+can store, and `parseRule` gives you the rule back.
+
+## Four questions
+
+```ts
+import { activeAt, advanceBy, elapsed, next } from "@kensio/quando";
+
+const friday = Temporal.ZonedDateTime.from("2026-03-13T16:55[Europe/London]");
+
+// Is it open?
+activeAt(openingHours, friday);
+// → true
+
+// When does it next open?
+next(openingHours, { from: friday.add({ hours: 2 }) })?.start?.toString();
+// → 2026-03-16T09:00:00+00:00[Europe/London]
+
+// How much opening is there this week?
+elapsed(openingHours, {
+  from: Temporal.ZonedDateTime.from("2026-03-09T00:00[Europe/London]"),
+  to: Temporal.ZonedDateTime.from("2026-03-16T00:00[Europe/London]"),
+}).toString();
+// → PT40H
+
+// Three hours of packing that only count while it is open — when is it done?
+advanceBy(friday, Temporal.Duration.from({ hours: 3 }), {
+  during: openingHours,
+})?.toString();
+// → 2026-03-16T11:55:00+00:00[Europe/London]
+```
+
+That last one is why the library exists, and it is the one that is genuinely
+awkward to do by hand.
+
+## Or say it the way you would say it
+
+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";
+
+const openingHours = schedule()
+  .open(weekdays(), "09:00-17:00")
+  .closed("2026-12-25")
+  .hoursOn("2026-03-11", "09:00-15:00"); // close early, just that day
+
+openingHours.isOpen(friday);
+// → true
+
+const onCall = rota().assign(weekdays(), "alice").assign(weekends(), "bob");
+
+onCall.whoIsOn(friday);
+// → "alice"
+```
+
+Each line outranks the ones above it, so exceptions read in the order you would
+say them. See [schedules and rotas](docs/schedules/).
+
+## Why intervals
+
+A rule does not answer about an instant — it produces the intervals over which
+it holds. Anything that samples has to choose a step size, trading correctness
+against speed, and every derived question becomes the same loop. Producing
+intervals turns those loops into arithmetic: working time in a window is a sum,
+three working days from now is a walk, and a rule that can never be satisfied
+yields nothing instead of never finishing.
+
+[Concepts](docs/concepts/) has the long version.
+
+## Documentation
+
+[quandojs.dev](https://quandojs.dev), which is built from [`docs/`](docs/) in
+this repository:
+
+- [Getting started](docs/getting-started/) — requirements, install, first query
+- [Concepts](docs/concepts/) — the model, and why it is that shape
+- [Rules](docs/rules/) — every rule type, and what each produces
+- [Queries](docs/queries/) — the four questions, and termination
+- [Time zones](docs/time-zones/) — wall clock against elapsed time
+- [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
+- [API](docs/api/) — everything the package exports
+
+## What it is not
+
+Not a date library — `Temporal` is that, and Quando is built on it. Not a
+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.
+
+## Licence
+
+[Apache-2.0](LICENSE).

package/dist/build.d.ts

@@ -0,0 +1,54 @@
+/**
+ * A readable way to write a rule, which is also the rule.
+ *
+ * `weekdays().and(timeOfDay("09:00", "17:00"))` reads better than the nested
+ * object literal it stands for — and it *is* that object literal, with methods
+ * hanging off it. `JSON.stringify` omits function-valued properties, so a built
+ * rule serialises to exactly the document a hand-written one would, with no
+ * `.build()` step and nothing to unwrap.
+ *
+ * That is the whole trick: there is no builder type to convert out of, because
+ * a built rule already satisfies `Rule`.
+ */
+import type { AllRule, AlwaysRule, AnyRule, DatesRule, DaysOfWeekRule, NeverRule, NotRule, Rule, TimeOfDayRule, Weekday } from "./rule.js";
+/** A rule, plus the methods for combining it with others. */
+export type Built<R extends Rule> = R & {
+    /** Both this and the others must hold. */
+    readonly and: (...others: readonly Rule[]) => Built<AllRule>;
+    /** This or any of the others. */
+    readonly or: (...others: readonly Rule[]) => Built<AnyRule>;
+    /**
+     * This, minus the times the others cover.
+     *
+     * The common shape by far — opening hours except holidays, a schedule except
+     * a shutdown — and worth its own method because writing it out is
+     * `all(this, not(any(others)))`, which reads like nothing at all.
+     */
+    readonly except: (...others: readonly Rule[]) => Built<AllRule>;
+};
+/** All of time. */
+export declare function always(): Built<AlwaysRule>;
+/** No time at all. */
+export declare function never(): Built<NeverRule>;
+/** Whole days, by day of the week. */
+export declare function daysOfWeek(...days: readonly Weekday[]): Built<DaysOfWeekRule>;
+/** Monday to Friday. */
+export declare function weekdays(): Built<DaysOfWeekRule>;
+/** Saturday and Sunday. */
+export declare function weekends(): Built<DaysOfWeekRule>;
+/**
+ * A wall-clock window within each day. A `to` earlier than `from` wraps past
+ * midnight, so `timeOfDay("22:00", "06:00")` is a night shift.
+ */
+export declare function timeOfDay(from: string, to: string, zone?: string): Built<TimeOfDayRule>;
+/** Whole days, by date. */
+export declare function dates(...days: readonly string[]): Built<DatesRule>;
+/** Every one of these must hold. With none, all of time. */
+export declare function all(...rules: readonly Rule[]): Built<AllRule>;
+/** Any one of these. With none, no time at all. */
+export declare function any(...rules: readonly Rule[]): Built<AnyRule>;
+/** The times a rule does not cover. */
+export declare function not(rule: Rule): Built<NotRule>;
+/** Whole days, by the zone a day is measured in. */
+export declare function inZone<R extends DaysOfWeekRule | DatesRule | TimeOfDayRule>(rule: R, zone: string): Built<R>;
+//# sourceMappingURL=build.d.ts.map

package/dist/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../src/build.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EACV,OAAO,EACP,UAAU,EACV,OAAO,EACP,SAAS,EACT,cAAc,EACd,SAAS,EACT,OAAO,EACP,IAAI,EACJ,aAAa,EACb,OAAO,EACR,MAAM,WAAW,CAAC;AAEnB,6DAA6D;AAC7D,MAAM,MAAM,KAAK,CAAC,CAAC,SAAS,IAAI,IAAI,CAAC,GAAG;IACtC,0CAA0C;IAC1C,QAAQ,CAAC,GAAG,EAAE,CAAC,GAAG,MAAM,EAAE,SAAS,IAAI,EAAE,KAAK,KAAK,CAAC,OAAO,CAAC,CAAC;IAC7D,iCAAiC;IACjC,QAAQ,CAAC,EAAE,EAAE,CAAC,GAAG,MAAM,EAAE,SAAS,IAAI,EAAE,KAAK,KAAK,CAAC,OAAO,CAAC,CAAC;IAC5D;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,EAAE,CAAC,GAAG,MAAM,EAAE,SAAS,IAAI,EAAE,KAAK,KAAK,CAAC,OAAO,CAAC,CAAC;CACjE,CAAC;AAmBF,mBAAmB;AACnB,wBAAgB,MAAM,IAAI,KAAK,CAAC,UAAU,CAAC,CAE1C;AAED,sBAAsB;AACtB,wBAAgB,KAAK,IAAI,KAAK,CAAC,SAAS,CAAC,CAExC;AAED,sCAAsC;AACtC,wBAAgB,UAAU,CAAC,GAAG,IAAI,EAAE,SAAS,OAAO,EAAE,GAAG,KAAK,CAAC,cAAc,CAAC,CAE7E;AAED,wBAAwB;AACxB,wBAAgB,QAAQ,IAAI,KAAK,CAAC,cAAc,CAAC,CAEhD;AAED,2BAA2B;AAC3B,wBAAgB,QAAQ,IAAI,KAAK,CAAC,cAAc,CAAC,CAEhD;AAED;;;GAGG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,IAAI,CAAC,EAAE,MAAM,GACZ,KAAK,CAAC,aAAa,CAAC,CAMtB;AAED,2BAA2B;AAC3B,wBAAgB,KAAK,CAAC,GAAG,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,KAAK,CAAC,SAAS,CAAC,CAElE;AAED,4DAA4D;AAC5D,wBAAgB,GAAG,CAAC,GAAG,KAAK,EAAE,SAAS,IAAI,EAAE,GAAG,KAAK,CAAC,OAAO,CAAC,CAE7D;AAED,mDAAmD;AACnD,wBAAgB,GAAG,CAAC,GAAG,KAAK,EAAE,SAAS,IAAI,EAAE,GAAG,KAAK,CAAC,OAAO,CAAC,CAE7D;AAED,uCAAuC;AACvC,wBAAgB,GAAG,CAAC,IAAI,EAAE,IAAI,GAAG,KAAK,CAAC,OAAO,CAAC,CAE9C;AAED,oDAAoD;AACpD,wBAAgB,MAAM,CAAC,CAAC,SAAS,cAAc,GAAG,SAAS,GAAG,aAAa,EACzE,IAAI,EAAE,CAAC,EACP,IAAI,EAAE,MAAM,GACX,KAAK,CAAC,CAAC,CAAC,CAEV"}

package/dist/build.js

@@ -0,0 +1,77 @@
+/**
+ * A readable way to write a rule, which is also the rule.
+ *
+ * `weekdays().and(timeOfDay("09:00", "17:00"))` reads better than the nested
+ * object literal it stands for — and it *is* that object literal, with methods
+ * hanging off it. `JSON.stringify` omits function-valued properties, so a built
+ * rule serialises to exactly the document a hand-written one would, with no
+ * `.build()` step and nothing to unwrap.
+ *
+ * That is the whole trick: there is no builder type to convert out of, because
+ * a built rule already satisfies `Rule`.
+ */
+function build(node) {
+    const self = {
+        ...node,
+        and: (...others) => build({ type: "all", rules: [self, ...others] }),
+        or: (...others) => build({ type: "any", rules: [self, ...others] }),
+        except: (...others) => build({
+            type: "all",
+            rules: [
+                self,
+                { type: "not", rule: { type: "any", rules: [...others] } },
+            ],
+        }),
+    };
+    return self;
+}
+/** All of time. */
+export function always() {
+    return build({ type: "always" });
+}
+/** No time at all. */
+export function never() {
+    return build({ type: "never" });
+}
+/** Whole days, by day of the week. */
+export function daysOfWeek(...days) {
+    return build({ type: "daysOfWeek", days });
+}
+/** Monday to Friday. */
+export function weekdays() {
+    return daysOfWeek("monday", "tuesday", "wednesday", "thursday", "friday");
+}
+/** Saturday and Sunday. */
+export function weekends() {
+    return daysOfWeek("saturday", "sunday");
+}
+/**
+ * A wall-clock window within each day. A `to` earlier than `from` wraps past
+ * midnight, so `timeOfDay("22:00", "06:00")` is a night shift.
+ */
+export function timeOfDay(from, to, zone) {
+    return build(zone === undefined
+        ? { type: "timeOfDay", from, to }
+        : { type: "timeOfDay", from, to, zone });
+}
+/** Whole days, by date. */
+export function dates(...days) {
+    return build({ type: "dates", dates: days });
+}
+/** Every one of these must hold. With none, all of time. */
+export function all(...rules) {
+    return build({ type: "all", rules });
+}
+/** Any one of these. With none, no time at all. */
+export function any(...rules) {
+    return build({ type: "any", rules });
+}
+/** The times a rule does not cover. */
+export function not(rule) {
+    return build({ type: "not", rule });
+}
+/** Whole days, by the zone a day is measured in. */
+export function inZone(rule, zone) {
+    return build({ ...rule, zone });
+}
+//# sourceMappingURL=build.js.map

package/dist/build.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.js","sourceRoot":"","sources":["../src/build.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AA+BH,SAAS,KAAK,CAAiB,IAAO;IACpC,MAAM,IAAI,GAAa;QACrB,GAAG,IAAI;QACP,GAAG,EAAE,CAAC,GAAG,MAAM,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,IAAI,EAAE,GAAG,MAAM,CAAC,EAAE,CAAC;QACpE,EAAE,EAAE,CAAC,GAAG,MAAM,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,IAAI,EAAE,GAAG,MAAM,CAAC,EAAE,CAAC;QACnE,MAAM,EAAE,CAAC,GAAG,MAAM,EAAE,EAAE,CACpB,KAAK,CAAC;YACJ,IAAI,EAAE,KAAK;YACX,KAAK,EAAE;gBACL,IAAI;gBACJ,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,GAAG,MAAM,CAAC,EAAE,EAAE;aAC3D;SACF,CAAC;KACL,CAAC;IACF,OAAO,IAAI,CAAC;AACd,CAAC;AAED,mBAAmB;AACnB,MAAM,UAAU,MAAM;IACpB,OAAO,KAAK,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;AACnC,CAAC;AAED,sBAAsB;AACtB,MAAM,UAAU,KAAK;IACnB,OAAO,KAAK,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;AAClC,CAAC;AAED,sCAAsC;AACtC,MAAM,UAAU,UAAU,CAAC,GAAG,IAAwB;IACpD,OAAO,KAAK,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC,CAAC;AAC7C,CAAC;AAED,wBAAwB;AACxB,MAAM,UAAU,QAAQ;IACtB,OAAO,UAAU,CAAC,QAAQ,EAAE,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC;AAC5E,CAAC;AAED,2BAA2B;AAC3B,MAAM,UAAU,QAAQ;IACtB,OAAO,UAAU,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;AAC1C,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,SAAS,CACvB,IAAY,EACZ,EAAU,EACV,IAAa;IAEb,OAAO,KAAK,CACV,IAAI,KAAK,SAAS;QAChB,CAAC,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,EAAE,EAAE;QACjC,CAAC,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,CAC1C,CAAC;AACJ,CAAC;AAED,2BAA2B;AAC3B,MAAM,UAAU,KAAK,CAAC,GAAG,IAAuB;IAC9C,OAAO,KAAK,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC/C,CAAC;AAED,4DAA4D;AAC5D,MAAM,UAAU,GAAG,CAAC,GAAG,KAAsB;IAC3C,OAAO,KAAK,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC;AACvC,CAAC;AAED,mDAAmD;AACnD,MAAM,UAAU,GAAG,CAAC,GAAG,KAAsB;IAC3C,OAAO,KAAK,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC;AACvC,CAAC;AAED,uCAAuC;AACvC,MAAM,UAAU,GAAG,CAAC,IAAU;IAC5B,OAAO,KAAK,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AACtC,CAAC;AAED,oDAAoD;AACpD,MAAM,UAAU,MAAM,CACpB,IAAO,EACP,IAAY;IAEZ,OAAO,KAAK,CAAC,EAAE,GAAG,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;AAClC,CAAC"}

package/dist/cascade.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Layers, and what holds inside them.
+ *
+ * A `Rule` says *when*. A `Cascade<V>` says *what holds when*: an ordered list
+ * of layers, each pairing a scope with what applies inside it, resolved like
+ * the rules in a stylesheet — the last layer to claim a moment wins.
+ *
+ * Keeping values here rather than on `Rule` is what lets the set algebra stay
+ * simple. If a rule carried a value then every combinator would be generic in
+ * it, and `not` would have to answer what the complement of a rota is. Values
+ * only appear where they are actually needed, which is assignment.
+ */
+import type { Interval } from "./interval.js";
+import type { Rule } from "./rule.js";
+/**
+ * An interval with a value assigned to it.
+ *
+ * Extends `Interval`, so everything that reads an interval — `duration`,
+ * `contains`, `isEmpty` — reads one of these unchanged.
+ */
+export interface Valued<V> extends Interval {
+    readonly value: V;
+}
+/**
+ * One layer: where it applies, and what applies there.
+ *
+ * The two forms are separate fields rather than one field holding either,
+ * because with one field the resolver would have to decide which meaning a
+ * value carries by inspecting the shape of the caller's own domain type — and
+ * for a `Cascade<Rule>` the two are indistinguishable.
+ */
+export type Layer<V> = ConstantLayer<V> | ReplacingLayer<V>;
+/** A layer assigning one value across the whole of its scope. */
+export interface ConstantLayer<V> {
+    readonly scope: Rule;
+    readonly value: V;
+}
+/**
+ * A layer whose scope is claimed, but whose value inside it comes from another
+ * cascade.
+ *
+ * This is the case a plain value cannot express. "On the eleventh we close at
+ * three" is not `(scope: the eleventh, value: closed)`, which would shut the
+ * whole day, and writing it as a value over 15:00–17:00 forces the author to
+ * know the hours it is overriding — which is the thing a cascade exists to
+ * avoid. What it means is: *within this scope, ignore the layers below and use
+ * this instead.*
+ */
+export interface ReplacingLayer<V> {
+    readonly scope: Rule;
+    readonly replace: Cascade<V>;
+}
+/**
+ * An ordered list of layers. Later layers win.
+ *
+ * Order is part of the meaning, so the JSON is an array and reordering it
+ * changes the answer.
+ */
+export interface Cascade<V> {
+    readonly type: "cascade";
+    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>;
+/** One value, across the whole of a scope. */
+export declare function layer<V>(scope: Rule, value: V): ConstantLayer<V>;
+/**
+ * True while a rule holds, and unassigned everywhere else.
+ *
+ * The bridge from *when* to *what*: it is how a plain schedule becomes a
+ * cascade, and what {@link replace} lifts a bare rule with.
+ */
+export declare function whenever(rule: Rule): Cascade<boolean>;
+/**
+ * A scope claimed outright, with what holds inside it given by another
+ * cascade — or, for a schedule, by a rule.
+ *
+ * The rule form is sugar: it stores the lifted cascade, so the document is the
+ * same either way and a stored layer never needs a reader to know which form
+ * was written.
+ */
+export declare function replace<V>(scope: Rule, replacement: Cascade<V>): ReplacingLayer<V>;
+export declare function replace(scope: Rule, replacement: Rule): ReplacingLayer<boolean>;
+//# sourceMappingURL=cascade.d.ts.map

package/dist/cascade.d.ts.map

@@ -0,0 +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"}

package/dist/cascade.js

@@ -0,0 +1,40 @@
+/**
+ * Layers, and what holds inside them.
+ *
+ * A `Rule` says *when*. A `Cascade<V>` says *what holds when*: an ordered list
+ * of layers, each pairing a scope with what applies inside it, resolved like
+ * the rules in a stylesheet — the last layer to claim a moment wins.
+ *
+ * Keeping values here rather than on `Rule` is what lets the set algebra stay
+ * simple. If a rule carried a value then every combinator would be generic in
+ * it, and `not` would have to answer what the complement of a rota is. Values
+ * only appear where they are actually needed, which is assignment.
+ */
+/** Whether a value is a cascade rather than a rule. */
+export function isCascade(value) {
+    return value.type === "cascade";
+}
+/** An ordered list of layers, lowest priority first. */
+export function cascade(...layers) {
+    return { type: "cascade", layers };
+}
+/** One value, across the whole of a scope. */
+export function layer(scope, value) {
+    return { scope, value };
+}
+/**
+ * True while a rule holds, and unassigned everywhere else.
+ *
+ * The bridge from *when* to *what*: it is how a plain schedule becomes a
+ * cascade, and what {@link replace} lifts a bare rule with.
+ */
+export function whenever(rule) {
+    return cascade(layer(rule, true));
+}
+export function replace(scope, replacement) {
+    return {
+        scope,
+        replace: isCascade(replacement) ? replacement : whenever(replacement),
+    };
+}
+//# sourceMappingURL=cascade.js.map

package/dist/cascade.js.map

@@ -0,0 +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"}

package/dist/context.d.ts

@@ -0,0 +1,44 @@
+/**
+ * What a rule is evaluated against.
+ *
+ * An object rather than a bare window, because rules need more than a window
+ * and always will: a sunrise rule needs coordinates, a rule written in the
+ * Hebrew calendar needs the calendar, a rendered description needs the locale.
+ * Adding a field here is harmless; changing a bare parameter into an object
+ * later would break every rule implementation, including anyone else's.
+ */
+export interface Context {
+    /**
+     * Where evaluation begins, and — since a `ZonedDateTime` carries one — the
+     * time zone any rule that does not name its own is read in. One source of
+     * truth: there is no way for a separate `zone` field to disagree with this.
+     */
+    readonly from: Temporal.ZonedDateTime;
+    /**
+     * Where evaluation stops. Optional, because a recurrence genuinely has no
+     * end and pretending otherwise would have callers guessing a window big
+     * enough to hold an answer they cannot predict.
+     *
+     * Leaving it out means the streams a rule produces may be endless. That is
+     * supported and sometimes what you want — `take(…, 3)` over an endless
+     * stream is exact and cheap — but a composition whose answer is empty then
+     * has nothing to discover that from, and will not finish. Bound the window
+     * when the answer might be empty.
+     */
+    readonly to?: Temporal.ZonedDateTime;
+    /** Where on Earth, for rules about the sun, the moon or the tide. */
+    readonly location?: {
+        readonly latitude: number;
+        readonly longitude: number;
+    };
+    /** For rendering a rule as text, and for locale-specific conventions. */
+    readonly locale?: string;
+}
+/** The context's window, in the form the interval algebra takes. */
+export declare function windowOf(context: Context): {
+    readonly start: Temporal.ZonedDateTime;
+    readonly end: Temporal.ZonedDateTime | undefined;
+};
+/** The zone a rule is read in when it does not name one of its own. */
+export declare function zoneOf(context: Context, override?: string): string;
+//# sourceMappingURL=context.d.ts.map

package/dist/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,WAAW,OAAO;IACtB;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,aAAa,CAAC;IAEtC;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,aAAa,CAAC;IAErC,qEAAqE;IACrE,QAAQ,CAAC,QAAQ,CAAC,EAAE;QAClB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;KAC5B,CAAC;IAEF,yEAAyE;IACzE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,oEAAoE;AACpE,wBAAgB,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG;IAC1C,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,aAAa,CAAC;IACvC,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,aAAa,GAAG,SAAS,CAAC;CAClD,CAEA;AAED,uEAAuE;AACvE,wBAAgB,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAElE"}

package/dist/context.js

@@ -0,0 +1,9 @@
+/** The context's window, in the form the interval algebra takes. */
+export function windowOf(context) {
+    return { start: context.from, end: context.to };
+}
+/** The zone a rule is read in when it does not name one of its own. */
+export function zoneOf(context, override) {
+    return override ?? context.from.timeZoneId;
+}
+//# sourceMappingURL=context.js.map

package/dist/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AAwCA,oEAAoE;AACpE,MAAM,UAAU,QAAQ,CAAC,OAAgB;IAIvC,OAAO,EAAE,KAAK,EAAE,OAAO,CAAC,IAAI,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC;AAClD,CAAC;AAED,uEAAuE;AACvE,MAAM,UAAU,MAAM,CAAC,OAAgB,EAAE,QAAiB;IACxD,OAAO,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC;AAC7C,CAAC"}

package/dist/day-rules.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Rules that select whole days: by weekday, and by date.
+ *
+ * Both uphold the stream contract — sorted, not overlapping, coalesced — and
+ * the coalescing is the fiddly part. Two selected days that happen to be
+ * consecutive are one interval, not two that touch at midnight, and a stream of
+ * touching intervals is one the sweeps in `interval-stream.ts` read wrongly.
+ */
+import { type Context } from "./context.js";
+import type { IntervalStream } from "./interval-stream.js";
+import { type Weekday } from "./rule.js";
+/** Whole days selected by day of the week. */
+export declare function weekdayIntervals(context: Context, days: readonly Weekday[], zone?: string): IntervalStream;
+/**
+ * Whole days named by date.
+ *
+ * Walks the given dates rather than the calendar, so a handful of dates costs a
+ * handful of steps however far apart they are, and the stream ends when they
+ * do. Sorted and de-duplicated first, because the contract is about the output
+ * and callers write dates in whatever order they think of them.
+ */
+export declare function dateIntervals(context: Context, dates: readonly string[], zone?: string): IntervalStream;
+//# sourceMappingURL=day-rules.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"day-rules.d.ts","sourceRoot":"","sources":["../src/day-rules.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,KAAK,OAAO,EAAU,MAAM,cAAc,CAAC;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EAAY,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AAsDnD,8CAA8C;AAC9C,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,SAAS,OAAO,EAAE,EACxB,IAAI,CAAC,EAAE,MAAM,GACZ,cAAc,CAehB;AAED;;;;;;;GAOG;AACH,wBAAiB,aAAa,CAC5B,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,IAAI,CAAC,EAAE,MAAM,GACZ,cAAc,CAiChB"}

package/dist/day-rules.js

@@ -0,0 +1,102 @@
+/**
+ * Rules that select whole days: by weekday, and by date.
+ *
+ * Both uphold the stream contract — sorted, not overlapping, coalesced — and
+ * the coalescing is the fiddly part. Two selected days that happen to be
+ * consecutive are one interval, not two that touch at midnight, and a stream of
+ * touching intervals is one the sweeps in `interval-stream.ts` read wrongly.
+ */
+import { zoneOf } from "./context.js";
+import { WEEKDAYS } from "./rule.js";
+function startOfDay(date, zone) {
+    return date.toZonedDateTime({ timeZone: zone, plainTime: "00:00" });
+}
+function weekdayOf(date) {
+    return WEEKDAYS[date.dayOfWeek - 1];
+}
+/**
+ * Whole days matching a predicate, walked forward from the context, with runs
+ * of consecutive matches merged into one interval.
+ *
+ * Endless unless the context bounds it. The run being built is flushed when the
+ * window ends, so a rule that matches every day still terminates — without
+ * that, a run that never closes would never yield anything at all.
+ */
+function* matchingDays(context, zone, matches) {
+    const stop = context.to;
+    let date = context.from.withTimeZone(zone).toPlainDate();
+    let runStart;
+    for (;;) {
+        const dayStart = startOfDay(date, zone);
+        if (stop !== undefined &&
+            Temporal.ZonedDateTime.compare(dayStart, stop) >= 0) {
+            if (runStart !== undefined) {
+                yield { start: startOfDay(runStart, zone), end: dayStart };
+            }
+            return;
+        }
+        if (matches(date)) {
+            runStart ??= date;
+        }
+        else if (runStart !== undefined) {
+            yield { start: startOfDay(runStart, zone), end: dayStart };
+            runStart = undefined;
+        }
+        date = date.add({ days: 1 });
+    }
+}
+/** Whole days selected by day of the week. */
+export function weekdayIntervals(context, days, zone) {
+    const wanted = new Set(days);
+    // Nothing can match, so there is nothing to walk the calendar for. Without
+    // this, an unbounded context sends `matchingDays` forward a day at a time
+    // until Temporal's year limit, thousands of centuries later, and reports it
+    // as a date range error rather than as the empty rule it is.
+    if (wanted.size === 0) {
+        return [];
+    }
+    return matchingDays(context, zoneOf(context, zone), (date) => {
+        const weekday = weekdayOf(date);
+        return weekday !== undefined && wanted.has(weekday);
+    });
+}
+/**
+ * Whole days named by date.
+ *
+ * Walks the given dates rather than the calendar, so a handful of dates costs a
+ * handful of steps however far apart they are, and the stream ends when they
+ * do. Sorted and de-duplicated first, because the contract is about the output
+ * and callers write dates in whatever order they think of them.
+ */
+export function* dateIntervals(context, dates, zone) {
+    const inZone = zoneOf(context, zone);
+    const days = [
+        ...new Set(dates.map((date) => Temporal.PlainDate.from(date).toString())),
+    ]
+        .toSorted()
+        .map((date) => Temporal.PlainDate.from(date));
+    let runStart;
+    let runEnd;
+    for (const day of days) {
+        if (runEnd !== undefined && Temporal.PlainDate.compare(day, runEnd) === 0) {
+            // Consecutive with the run so far, so it extends rather than starts one.
+            runEnd = day.add({ days: 1 });
+            continue;
+        }
+        if (runStart !== undefined && runEnd !== undefined) {
+            yield {
+                start: startOfDay(runStart, inZone),
+                end: startOfDay(runEnd, inZone),
+            };
+        }
+        runStart = day;
+        runEnd = day.add({ days: 1 });
+    }
+    if (runStart !== undefined && runEnd !== undefined) {
+        yield {
+            start: startOfDay(runStart, inZone),
+            end: startOfDay(runEnd, inZone),
+        };
+    }
+}
+//# sourceMappingURL=day-rules.js.map

package/dist/day-rules.js.map

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

package/dist/index.d.ts

@@ -2,8 +2,14 @@
  * Quando: declarative temporal rules for schedules, deadlines, constraints and
  * exceptions.
  *
- * What exists so far is the interval core — the algebra everything else is
- * built from. Rules, cascades and queries are still to come.
+ * What exists so far is the interval core, the rule language on top of it, and
+ * the two ends of "rules are data": a builder that writes one, and a parser
+ * that reads one back from whatever a database or a form actually held.
+ * Queries sit on top: is it open now, how much working time is in this window,
+ * when does it next open, and where do you get to after three hours that only
+ * count while it is open. Cascades sit beside them: ordered layers that carry
+ * values, resolved by precedence, for the questions a boolean schedule cannot
+ * answer.
  *
  * Requires a runtime with `Temporal`: Node 26 or later, or a browser that
  * implements it.
@@ -16,4 +22,22 @@ export { compareEnds, compareStarts, contains, duration, isEmpty, startsAtOrBefo
 export type { IntervalStream } from "./interval-stream.js";
 export { clip, complement, intersect, union } from "./interval-stream.js";
 export { take } from "./stream.js";
+export type { Context } from "./context.js";
+export type { AllRule, AnyRule, AlwaysRule, DatesRule, DaysOfWeekRule, NeverRule, NotRule, Rule, TimeOfDayRule, Weekday, } from "./rule.js";
+export { WEEKDAYS } from "./rule.js";
+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 { Cascade, ConstantLayer, Layer, ReplacingLayer, Valued, } from "./cascade.js";
+export { cascade, isCascade, layer, replace, whenever } from "./cascade.js";
+export type { ValuedStream } from "./valued-stream.js";
+export { resolve } from "./resolve.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 { Search } from "./query.js";
+export { activeAt, advanceBy, elapsed, next } from "./query.js";
 //# sourceMappingURL=index.d.ts.map