@kensio/quando 0.1.0 → 1.0.0

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

@@ -0,0 +1,107 @@
+/**
+ * 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 { MergeStrategy } from "./merge.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";
+    /**
+     * 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>;
+/**
+ * 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,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

@@ -0,0 +1,53 @@
+/**
+ * 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 };
+}
+/**
+ * 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 };
+}
+/**
+ * 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;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/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,33 @@ 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 { 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, 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;;;;;;;;;;;;GAYG;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"}
+{"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

@@ -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.
@@ -14,4 +20,20 @@
 export { compareEnds, compareStarts, contains, duration, isEmpty, startsAtOrBeforeEnd, startsBeforeEnd, } from "./interval.js";
 export { clip, complement, intersect, union } from "./interval-stream.js";
 export { take } from "./stream.js";
+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 { 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

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EACL,WAAW,EACX,aAAa,EACb,QAAQ,EACR,QAAQ,EACR,OAAO,EACP,mBAAmB,EACnB,eAAe,GAChB,MAAM,eAAe,CAAC;AAGvB,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAE1E,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,EACL,WAAW,EACX,aAAa,EACb,QAAQ,EACR,QAAQ,EACR,OAAO,EACP,mBAAmB,EACnB,eAAe,GAChB,MAAM,eAAe,CAAC;AAGvB,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAE1E,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAgBnC,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAErC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAG3C,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;AAGvC,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAS7D,OAAO,EACL,OAAO,EACP,SAAS,EACT,KAAK,EACL,MAAM,EACN,OAAO,EACP,QAAQ,GACT,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAG9C,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;AAKhE,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAGzC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAGjC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAGnC,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAG7D,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC"}

package/dist/interpret.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Reading a rule as the times it covers.
+ *
+ * One function over the whole rule language rather than a method on each rule
+ * type, which is what lets the next operation over rules — describing them,
+ * validating them, drawing them — be another function here rather than another
+ * method everywhere.
+ *
+ * Everything is clipped to the context's window. That is not tidiness: a
+ * composition whose answer is empty has nothing to discover that from, so the
+ * only thing that makes it terminate is its sources running out. Clipping at
+ * the leaves is what makes them run out.
+ */
+import { type Context } from "./context.js";
+import { type IntervalStream } from "./interval-stream.js";
+import type { Rule } from "./rule.js";
+/**
+ * The intervals a rule covers within a context, in order and coalesced.
+ *
+ * The stream is lazy, and endless when the context has no end and the rule
+ * recurs — which is the point. Take what you need from it.
+ *
+ * Every interval comes back in the context's zone. The algebra compares
+ * instants, so a sweep is free to take one interval's start and another's end,
+ * and those two may have been written in different zones — a London rule read
+ * from a Tokyo context would otherwise hand back an interval whose two halves
+ * disagree about what time it is. The instants are unaffected either way; this
+ * only settles which zone reads them back.
+ */
+export declare function intervals(rule: Rule, context: Context): IntervalStream;
+//# sourceMappingURL=interpret.d.ts.map

package/dist/interpret.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interpret.d.ts","sourceRoot":"","sources":["../src/interpret.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,KAAK,OAAO,EAAY,MAAM,cAAc,CAAC;AACtD,OAAO,EAIL,KAAK,cAAc,EAEpB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAUtC;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,GAAG,cAAc,CAEtE"}