@kensio/quando 0.1.0-beta.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,9 @@
+# Quando
+
+Declarative temporal rules for schedules, deadlines, constraints, and exceptions.
+
+## Status
+
+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.

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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.
+ *
+ * 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 anywhere without
+ * one natively can load `temporal-polyfill` first and everything here works
+ * untouched.
+ */
+export type { Interval } from "./interval.js";
+export { compareEnds, compareStarts, contains, duration, isEmpty, startsAtOrBeforeEnd, startsBeforeEnd, } from "./interval.js";
+export type { IntervalStream } from "./interval-stream.js";
+export { clip, complement, intersect, union } from "./interval-stream.js";
+export { take } from "./stream.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -0,0 +1,17 @@
+/**
+ * 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.
+ *
+ * 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 anywhere without
+ * one natively can load `temporal-polyfill` first and everything here works
+ * untouched.
+ */
+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";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

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

package/dist/interval-stream.d.ts

@@ -0,0 +1,54 @@
+/**
+ * The interval algebra: intersection, union and complement over lazy streams.
+ *
+ * Streams are `Iterable`, and may be infinite — a weekly recurrence genuinely
+ * has no end, and modelling it as though it did would put callers back to
+ * guessing a window large enough to hold an answer they cannot predict.
+ *
+ * Every operation here is a sweep: it pulls from its sources only as far as it
+ * needs to produce the next result, so `take(3)` from an infinite intersection
+ * pulls a handful of intervals rather than expanding a year.
+ */
+import { type Interval } from "./interval.js";
+/**
+ * A lazy sequence of intervals.
+ *
+ * **Contract, which every producer must uphold:** intervals arrive sorted by
+ * start, do not overlap, and are already coalesced — no two touching intervals
+ * where one would do. The sweeps below are single-pass and rely on it; a
+ * producer that breaks it produces wrong answers rather than errors.
+ */
+export type IntervalStream = Iterable<Interval>;
+/**
+ * The times both streams cover.
+ *
+ * Terminates when either source does. Note that it will *not* terminate on two
+ * infinite sources that never overlap — there is nothing it could inspect to
+ * discover that the answer is empty. See the note on unbounded queries in the
+ * documentation; that case is the caller's to bound.
+ */
+export declare function intersect(left: IntervalStream, right: IntervalStream): IntervalStream;
+/**
+ * The times either stream covers, coalesced.
+ *
+ * Touching intervals are merged as well as overlapping ones, so the output
+ * satisfies the stream contract rather than merely being correct as a set.
+ */
+export declare function union(left: IntervalStream, right: IntervalStream): IntervalStream;
+/**
+ * The times a stream does not cover — the gaps, plus the unbounded stretches
+ * before the first interval and after the last.
+ *
+ * On an infinite source the trailing stretch is never reached, which is correct:
+ * there is no "after the last" when there is no last.
+ */
+export declare function complement(source: IntervalStream): IntervalStream;
+/**
+ * A stream limited to a window.
+ *
+ * This is what makes a composition over infinite sources terminate: bounded
+ * inputs run out, so the sweep above them runs out too. It relies on the
+ * sorted-by-start contract to stop early rather than draining its source.
+ */
+export declare function clip(source: IntervalStream, window: Interval): IntervalStream;
+//# sourceMappingURL=interval-stream.d.ts.map

package/dist/interval-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interval-stream.d.ts","sourceRoot":"","sources":["../src/interval-stream.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAIL,KAAK,QAAQ,EAMd,MAAM,eAAe,CAAC;AAGvB;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC,QAAQ,CAAC,CAAC;AAEhD;;;;;;;GAOG;AACH,wBAAiB,SAAS,CACxB,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,cAAc,GACpB,cAAc,CAwBhB;AAED;;;;;GAKG;AACH,wBAAiB,KAAK,CACpB,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,cAAc,GACpB,cAAc,CAgChB;AA8BD;;;;;;GAMG;AACH,wBAAiB,UAAU,CAAC,MAAM,EAAE,cAAc,GAAG,cAAc,CAyClE;AAED;;;;;;GAMG;AACH,wBAAgB,IAAI,CAAC,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,QAAQ,GAAG,cAAc,CAM7E"}

package/dist/interval-stream.js

@@ -0,0 +1,162 @@
+/**
+ * The interval algebra: intersection, union and complement over lazy streams.
+ *
+ * Streams are `Iterable`, and may be infinite — a weekly recurrence genuinely
+ * has no end, and modelling it as though it did would put callers back to
+ * guessing a window large enough to hold an answer they cannot predict.
+ *
+ * Every operation here is a sweep: it pulls from its sources only as far as it
+ * needs to produce the next result, so `take(3)` from an infinite intersection
+ * pulls a handful of intervals rather than expanding a year.
+ */
+import { compareEnds, compareStarts, earlierEnd, isEmpty, laterEnd, laterStart, startsAtOrBeforeEnd, startsBeforeEnd, } from "./interval.js";
+import { peekable } from "./stream.js";
+/**
+ * The times both streams cover.
+ *
+ * Terminates when either source does. Note that it will *not* terminate on two
+ * infinite sources that never overlap — there is nothing it could inspect to
+ * discover that the answer is empty. See the note on unbounded queries in the
+ * documentation; that case is the caller's to bound.
+ */
+export function* intersect(left, right) {
+    const a = peekable(left);
+    const b = peekable(right);
+    for (;;) {
+        const x = a.peek();
+        const y = b.peek();
+        if (x === undefined || y === undefined) {
+            return;
+        }
+        const start = laterStart(x.start, y.start);
+        const end = earlierEnd(x.end, y.end);
+        if (startsBeforeEnd(start, end)) {
+            yield { start, end };
+        }
+        // Drop whichever ends first: the other may still overlap what follows it.
+        if (compareEnds(x.end, y.end) <= 0) {
+            a.drop();
+        }
+        else {
+            b.drop();
+        }
+    }
+}
+/**
+ * The times either stream covers, coalesced.
+ *
+ * Touching intervals are merged as well as overlapping ones, so the output
+ * satisfies the stream contract rather than merely being correct as a set.
+ */
+export function* union(left, right) {
+    const a = peekable(left);
+    const b = peekable(right);
+    let open;
+    for (;;) {
+        const next = takeEarlier(a, b);
+        if (next === undefined) {
+            break;
+        }
+        if (open === undefined) {
+            open = next;
+        }
+        else if (startsAtOrBeforeEnd(next.start, open.end)) {
+            open = { start: open.start, end: laterEnd(open.end, next.end) };
+        }
+        else {
+            yield open;
+            open = next;
+        }
+        // Nothing can extend an interval that already runs to the unbounded
+        // future, so there is no reason to keep pulling — and every reason not to,
+        // since either source may be infinite and this would never yield at all.
+        if (open.end === undefined) {
+            yield open;
+            return;
+        }
+    }
+    if (open !== undefined) {
+        yield open;
+    }
+}
+/** Consume whichever stream's next interval starts earlier. */
+function takeEarlier(a, b) {
+    const x = a.peek();
+    const y = b.peek();
+    if (x === undefined) {
+        if (y === undefined) {
+            return undefined;
+        }
+        b.drop();
+        return y;
+    }
+    if (y === undefined) {
+        a.drop();
+        return x;
+    }
+    if (compareStarts(x.start, y.start) <= 0) {
+        a.drop();
+        return x;
+    }
+    b.drop();
+    return y;
+}
+/**
+ * The times a stream does not cover — the gaps, plus the unbounded stretches
+ * before the first interval and after the last.
+ *
+ * On an infinite source the trailing stretch is never reached, which is correct:
+ * there is no "after the last" when there is no last.
+ */
+export function* complement(source) {
+    /** Where the next gap begins: the end of the interval last seen. */
+    let cursor;
+    let seenAny = false;
+    for (const interval of source) {
+        // A zero-length interval covers nothing, so it neither opens a gap nor
+        // closes one. Letting it through would split the surrounding gap into two
+        // touching halves, and a stream of touching intervals is one this module's
+        // own sweeps would then read wrongly.
+        if (isEmpty(interval)) {
+            continue;
+        }
+        if (!seenAny) {
+            seenAny = true;
+            // The stretch before the first interval — unless the source itself begins
+            // at the unbounded past, in which case there is nothing before it. An
+            // absent `start` and an absent `end` mean opposite things, so this case
+            // has to be handled rather than falling out of a comparison.
+            if (interval.start !== undefined) {
+                yield { start: undefined, end: interval.start };
+            }
+        }
+        else if (cursor !== undefined &&
+            interval.start !== undefined &&
+            Temporal.ZonedDateTime.compare(cursor, interval.start) < 0) {
+            yield { start: cursor, end: interval.start };
+        }
+        if (interval.end === undefined) {
+            // The source runs to the unbounded future; nothing can follow it.
+            return;
+        }
+        cursor = interval.end;
+    }
+    // An exhausted source leaves everything after it uncovered. An empty one
+    // leaves everything uncovered, which is the same statement with no cursor.
+    yield { start: seenAny ? cursor : undefined, end: undefined };
+}
+/**
+ * A stream limited to a window.
+ *
+ * This is what makes a composition over infinite sources terminate: bounded
+ * inputs run out, so the sweep above them runs out too. It relies on the
+ * sorted-by-start contract to stop early rather than draining its source.
+ */
+export function clip(source, window) {
+    // Intersection with a single-interval stream, which is what clipping is. The
+    // early stop falls out of it: once the window is consumed the sweep has
+    // nothing left to intersect against and returns, so an infinite source is
+    // never drained.
+    return intersect(source, [window]);
+}
+//# sourceMappingURL=interval-stream.js.map

package/dist/interval-stream.js.map

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

package/dist/interval.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Intervals, and the comparisons the interval algebra is built from.
+ *
+ * An interval is half open: it includes its start and excludes its end. That is
+ * the only choice that makes boundaries unambiguous — under a closed interval a
+ * day ending at 17:00 and one beginning at 17:00 both contain that instant, and
+ * every boundary query has to pick a side.
+ */
+/**
+ * A span of time, half open: `[start, end)`.
+ *
+ * Either end may be `undefined`, which means unbounded. Position says which
+ * direction: an absent `start` is the unbounded past, an absent `end` the
+ * unbounded future. Both are real — "closed indefinitely from 2030" has no end,
+ * and the complement of any rule has no beginning.
+ */
+export interface Interval {
+    readonly start: Temporal.ZonedDateTime | undefined;
+    readonly end: Temporal.ZonedDateTime | undefined;
+}
+/**
+ * Compare two interval starts, where `undefined` is the unbounded past and so
+ * sorts before everything.
+ */
+export declare function compareStarts(a: Temporal.ZonedDateTime | undefined, b: Temporal.ZonedDateTime | undefined): number;
+/**
+ * Compare two interval ends, where `undefined` is the unbounded future and so
+ * sorts after everything.
+ *
+ * Separate from {@link compareStarts} because `undefined` means the opposite
+ * thing in the two positions, and a single comparison that took both would need
+ * telling which it was looking at anyway.
+ */
+export declare function compareEnds(a: Temporal.ZonedDateTime | undefined, b: Temporal.ZonedDateTime | undefined): number;
+/** The earlier of two starts. */
+export declare function earlierStart(a: Temporal.ZonedDateTime | undefined, b: Temporal.ZonedDateTime | undefined): Temporal.ZonedDateTime | undefined;
+/** The later of two starts. */
+export declare function laterStart(a: Temporal.ZonedDateTime | undefined, b: Temporal.ZonedDateTime | undefined): Temporal.ZonedDateTime | undefined;
+/** The earlier of two ends. */
+export declare function earlierEnd(a: Temporal.ZonedDateTime | undefined, b: Temporal.ZonedDateTime | undefined): Temporal.ZonedDateTime | undefined;
+/** The later of two ends. */
+export declare function laterEnd(a: Temporal.ZonedDateTime | undefined, b: Temporal.ZonedDateTime | undefined): Temporal.ZonedDateTime | undefined;
+/**
+ * Whether a start falls strictly before an end, which is what makes an interval
+ * non-empty. Either being unbounded settles it: nothing precedes the unbounded
+ * past and nothing follows the unbounded future.
+ */
+export declare function startsBeforeEnd(start: Temporal.ZonedDateTime | undefined, end: Temporal.ZonedDateTime | undefined): boolean;
+/**
+ * Whether a start falls at or before an end.
+ *
+ * The difference from {@link startsBeforeEnd} is what separates *touching* from
+ * *overlapping*, which is the test a union needs: `[09:00,12:00)` and
+ * `[12:00,17:00)` do not overlap, but they should still coalesce into one.
+ */
+export declare function startsAtOrBeforeEnd(start: Temporal.ZonedDateTime | undefined, end: Temporal.ZonedDateTime | undefined): boolean;
+/** Whether an interval contains no time at all. */
+export declare function isEmpty(interval: Interval): boolean;
+/**
+ * Whether an instant falls inside an interval. Half open, so an instant exactly
+ * at `end` is outside.
+ */
+export declare function contains(interval: Interval, at: Temporal.ZonedDateTime): boolean;
+/**
+ * How long an interval lasts in exact time, or `undefined` if it is unbounded
+ * and so has no finite length.
+ *
+ * Exact rather than wall clock: this is elapsed time, and across a daylight
+ * saving transition the two disagree. A `ZonedDateTime` knows its own offset,
+ * so `until` measures the real elapsed duration — 09:00 to 17:00 is eight hours
+ * on a transition day only because the transition falls outside it.
+ */
+export declare function duration(interval: Interval): Temporal.Duration | undefined;
+//# sourceMappingURL=interval.d.ts.map

package/dist/interval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interval.d.ts","sourceRoot":"","sources":["../src/interval.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;;;GAOG;AACH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,aAAa,GAAG,SAAS,CAAC;IACnD,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,aAAa,GAAG,SAAS,CAAC;CAClD;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,CAAC,EAAE,QAAQ,CAAC,aAAa,GAAG,SAAS,EACrC,CAAC,EAAE,QAAQ,CAAC,aAAa,GAAG,SAAS,GACpC,MAAM,CAQR;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CACzB,CAAC,EAAE,QAAQ,CAAC,aAAa,GAAG,SAAS,EACrC,CAAC,EAAE,QAAQ,CAAC,aAAa,GAAG,SAAS,GACpC,MAAM,CAQR;AAED,iCAAiC;AACjC,wBAAgB,YAAY,CAC1B,CAAC,EAAE,QAAQ,CAAC,aAAa,GAAG,SAAS,EACrC,CAAC,EAAE,QAAQ,CAAC,aAAa,GAAG,SAAS,GACpC,QAAQ,CAAC,aAAa,GAAG,SAAS,CAEpC;AAED,+BAA+B;AAC/B,wBAAgB,UAAU,CACxB,CAAC,EAAE,QAAQ,CAAC,aAAa,GAAG,SAAS,EACrC,CAAC,EAAE,QAAQ,CAAC,aAAa,GAAG,SAAS,GACpC,QAAQ,CAAC,aAAa,GAAG,SAAS,CAEpC;AAED,+BAA+B;AAC/B,wBAAgB,UAAU,CACxB,CAAC,EAAE,QAAQ,CAAC,aAAa,GAAG,SAAS,EACrC,CAAC,EAAE,QAAQ,CAAC,aAAa,GAAG,SAAS,GACpC,QAAQ,CAAC,aAAa,GAAG,SAAS,CAEpC;AAED,6BAA6B;AAC7B,wBAAgB,QAAQ,CACtB,CAAC,EAAE,QAAQ,CAAC,aAAa,GAAG,SAAS,EACrC,CAAC,EAAE,QAAQ,CAAC,aAAa,GAAG,SAAS,GACpC,QAAQ,CAAC,aAAa,GAAG,SAAS,CAEpC;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,QAAQ,CAAC,aAAa,GAAG,SAAS,EACzC,GAAG,EAAE,QAAQ,CAAC,aAAa,GAAG,SAAS,GACtC,OAAO,CAKT;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,QAAQ,CAAC,aAAa,GAAG,SAAS,EACzC,GAAG,EAAE,QAAQ,CAAC,aAAa,GAAG,SAAS,GACtC,OAAO,CAKT;AAED,mDAAmD;AACnD,wBAAgB,OAAO,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAEnD;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CACtB,QAAQ,EAAE,QAAQ,EAClB,EAAE,EAAE,QAAQ,CAAC,aAAa,GACzB,OAAO,CAIT;AAED;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,QAAQ,CAAC,QAAQ,GAAG,SAAS,CAM1E"}

package/dist/interval.js

@@ -0,0 +1,106 @@
+/**
+ * Intervals, and the comparisons the interval algebra is built from.
+ *
+ * An interval is half open: it includes its start and excludes its end. That is
+ * the only choice that makes boundaries unambiguous — under a closed interval a
+ * day ending at 17:00 and one beginning at 17:00 both contain that instant, and
+ * every boundary query has to pick a side.
+ */
+/**
+ * Compare two interval starts, where `undefined` is the unbounded past and so
+ * sorts before everything.
+ */
+export function compareStarts(a, b) {
+    if (a === undefined) {
+        return b === undefined ? 0 : -1;
+    }
+    if (b === undefined) {
+        return 1;
+    }
+    return Temporal.ZonedDateTime.compare(a, b);
+}
+/**
+ * Compare two interval ends, where `undefined` is the unbounded future and so
+ * sorts after everything.
+ *
+ * Separate from {@link compareStarts} because `undefined` means the opposite
+ * thing in the two positions, and a single comparison that took both would need
+ * telling which it was looking at anyway.
+ */
+export function compareEnds(a, b) {
+    if (a === undefined) {
+        return b === undefined ? 0 : 1;
+    }
+    if (b === undefined) {
+        return -1;
+    }
+    return Temporal.ZonedDateTime.compare(a, b);
+}
+/** The earlier of two starts. */
+export function earlierStart(a, b) {
+    return compareStarts(a, b) <= 0 ? a : b;
+}
+/** The later of two starts. */
+export function laterStart(a, b) {
+    return compareStarts(a, b) >= 0 ? a : b;
+}
+/** The earlier of two ends. */
+export function earlierEnd(a, b) {
+    return compareEnds(a, b) <= 0 ? a : b;
+}
+/** The later of two ends. */
+export function laterEnd(a, b) {
+    return compareEnds(a, b) >= 0 ? a : b;
+}
+/**
+ * Whether a start falls strictly before an end, which is what makes an interval
+ * non-empty. Either being unbounded settles it: nothing precedes the unbounded
+ * past and nothing follows the unbounded future.
+ */
+export function startsBeforeEnd(start, end) {
+    if (start === undefined || end === undefined) {
+        return true;
+    }
+    return Temporal.ZonedDateTime.compare(start, end) < 0;
+}
+/**
+ * Whether a start falls at or before an end.
+ *
+ * The difference from {@link startsBeforeEnd} is what separates *touching* from
+ * *overlapping*, which is the test a union needs: `[09:00,12:00)` and
+ * `[12:00,17:00)` do not overlap, but they should still coalesce into one.
+ */
+export function startsAtOrBeforeEnd(start, end) {
+    if (start === undefined || end === undefined) {
+        return true;
+    }
+    return Temporal.ZonedDateTime.compare(start, end) <= 0;
+}
+/** Whether an interval contains no time at all. */
+export function isEmpty(interval) {
+    return !startsBeforeEnd(interval.start, interval.end);
+}
+/**
+ * Whether an instant falls inside an interval. Half open, so an instant exactly
+ * at `end` is outside.
+ */
+export function contains(interval, at) {
+    return (compareStarts(interval.start, at) <= 0 && compareEnds(at, interval.end) < 0);
+}
+/**
+ * How long an interval lasts in exact time, or `undefined` if it is unbounded
+ * and so has no finite length.
+ *
+ * Exact rather than wall clock: this is elapsed time, and across a daylight
+ * saving transition the two disagree. A `ZonedDateTime` knows its own offset,
+ * so `until` measures the real elapsed duration — 09:00 to 17:00 is eight hours
+ * on a transition day only because the transition falls outside it.
+ */
+export function duration(interval) {
+    const { start, end } = interval;
+    if (start === undefined || end === undefined) {
+        return undefined;
+    }
+    return start.until(end, { largestUnit: "hour" });
+}
+//# sourceMappingURL=interval.js.map

package/dist/interval.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interval.js","sourceRoot":"","sources":["../src/interval.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAeH;;;GAGG;AACH,MAAM,UAAU,aAAa,CAC3B,CAAqC,EACrC,CAAqC;IAErC,IAAI,CAAC,KAAK,SAAS,EAAE,CAAC;QACpB,OAAO,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAClC,CAAC;IACD,IAAI,CAAC,KAAK,SAAS,EAAE,CAAC;QACpB,OAAO,CAAC,CAAC;IACX,CAAC;IACD,OAAO,QAAQ,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAC9C,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,WAAW,CACzB,CAAqC,EACrC,CAAqC;IAErC,IAAI,CAAC,KAAK,SAAS,EAAE,CAAC;QACpB,OAAO,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACjC,CAAC;IACD,IAAI,CAAC,KAAK,SAAS,EAAE,CAAC;QACpB,OAAO,CAAC,CAAC,CAAC;IACZ,CAAC;IACD,OAAO,QAAQ,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAC9C,CAAC;AAED,iCAAiC;AACjC,MAAM,UAAU,YAAY,CAC1B,CAAqC,EACrC,CAAqC;IAErC,OAAO,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAC1C,CAAC;AAED,+BAA+B;AAC/B,MAAM,UAAU,UAAU,CACxB,CAAqC,EACrC,CAAqC;IAErC,OAAO,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAC1C,CAAC;AAED,+BAA+B;AAC/B,MAAM,UAAU,UAAU,CACxB,CAAqC,EACrC,CAAqC;IAErC,OAAO,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACxC,CAAC;AAED,6BAA6B;AAC7B,MAAM,UAAU,QAAQ,CACtB,CAAqC,EACrC,CAAqC;IAErC,OAAO,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACxC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAC7B,KAAyC,EACzC,GAAuC;IAEvC,IAAI,KAAK,KAAK,SAAS,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;QAC7C,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO,QAAQ,CAAC,aAAa,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC;AACxD,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,mBAAmB,CACjC,KAAyC,EACzC,GAAuC;IAEvC,IAAI,KAAK,KAAK,SAAS,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;QAC7C,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO,QAAQ,CAAC,aAAa,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC;AACzD,CAAC;AAED,mDAAmD;AACnD,MAAM,UAAU,OAAO,CAAC,QAAkB;IACxC,OAAO,CAAC,eAAe,CAAC,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;AACxD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,QAAQ,CACtB,QAAkB,EAClB,EAA0B;IAE1B,OAAO,CACL,aAAa,CAAC,QAAQ,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,WAAW,CAAC,EAAE,EAAE,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAC5E,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,QAAQ,CAAC,QAAkB;IACzC,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,QAAQ,CAAC;IAChC,IAAI,KAAK,KAAK,SAAS,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;QAC7C,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,OAAO,KAAK,CAAC,KAAK,CAAC,GAAG,EAAE,EAAE,WAAW,EAAE,MAAM,EAAE,CAAC,CAAC;AACnD,CAAC"}

package/dist/stream.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Generic helpers for lazy sequences. Nothing here knows about intervals.
+ *
+ * They live apart from the interval algebra because they are not about time at
+ * all: one is a way to look at the front of a sequence without consuming it,
+ * the other a way to stop consuming one. Both read the same for any element
+ * type, and the sweeps next door need exactly one item of lookahead — a sweep
+ * that needed more would not be a sweep.
+ */
+/**
+ * `T` excludes `null` and `undefined` deliberately: `peek` uses `undefined` to
+ * mean exhausted, so a sequence that could yield `undefined` as a value would
+ * be indistinguishable from one that had ended.
+ */
+export interface Peekable<T extends NonNullable<unknown>> {
+    /** The next item without consuming it, or `undefined` once exhausted. */
+    readonly peek: () => T | undefined;
+    /** Consume the item last peeked, so the next `peek` moves on. */
+    readonly drop: () => void;
+}
+export declare function peekable<T extends NonNullable<unknown>>(source: Iterable<T>): Peekable<T>;
+/**
+ * The first `count` items of a sequence, as an array.
+ *
+ * The point of it is the stopping: the source may be infinite, and this pulls
+ * exactly as far as it needs and no further.
+ */
+export declare function take<T>(source: Iterable<T>, count: number): T[];
+//# sourceMappingURL=stream.d.ts.map

package/dist/stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../src/stream.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;GAIG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC,SAAS,WAAW,CAAC,OAAO,CAAC;IACtD,yEAAyE;IACzE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IACnC,iEAAiE;IACjE,QAAQ,CAAC,IAAI,EAAE,MAAM,IAAI,CAAC;CAC3B;AAED,wBAAgB,QAAQ,CAAC,CAAC,SAAS,WAAW,CAAC,OAAO,CAAC,EACrD,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,GAClB,QAAQ,CAAC,CAAC,CAAC,CAuBb;AAED;;;;;GAKG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC,EAAE,CAoB/D"}

package/dist/stream.js

@@ -0,0 +1,60 @@
+/**
+ * Generic helpers for lazy sequences. Nothing here knows about intervals.
+ *
+ * They live apart from the interval algebra because they are not about time at
+ * all: one is a way to look at the front of a sequence without consuming it,
+ * the other a way to stop consuming one. Both read the same for any element
+ * type, and the sweeps next door need exactly one item of lookahead — a sweep
+ * that needed more would not be a sweep.
+ */
+export function peekable(source) {
+    const iterator = source[Symbol.iterator]();
+    let buffered;
+    let buffering = false;
+    let exhausted = false;
+    return {
+        peek() {
+            if (!buffering && !exhausted) {
+                const step = iterator.next();
+                if (step.done === true) {
+                    exhausted = true;
+                }
+                else {
+                    buffered = step.value;
+                    buffering = true;
+                }
+            }
+            return buffering ? buffered : undefined;
+        },
+        drop() {
+            buffering = false;
+        },
+    };
+}
+/**
+ * The first `count` items of a sequence, as an array.
+ *
+ * The point of it is the stopping: the source may be infinite, and this pulls
+ * exactly as far as it needs and no further.
+ */
+export function take(source, count) {
+    // Rejected before anything is pulled. `NaN` and `Infinity` both fail every
+    // comparison that would end the loop, so on an infinite sequence either one
+    // hangs rather than returning something wrong — which is worse, and worth an
+    // error rather than a silent guess at what was meant.
+    if (!Number.isInteger(count)) {
+        throw new RangeError(`take() needs a whole number of items, not ${count}.`);
+    }
+    const taken = [];
+    if (count <= 0) {
+        return taken;
+    }
+    for (const item of source) {
+        taken.push(item);
+        if (taken.length >= count) {
+            break;
+        }
+    }
+    return taken;
+}
+//# sourceMappingURL=stream.js.map

package/dist/stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.js","sourceRoot":"","sources":["../src/stream.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAcH,MAAM,UAAU,QAAQ,CACtB,MAAmB;IAEnB,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;IAC3C,IAAI,QAAuB,CAAC;IAC5B,IAAI,SAAS,GAAG,KAAK,CAAC;IACtB,IAAI,SAAS,GAAG,KAAK,CAAC;IAEtB,OAAO;QACL,IAAI;YACF,IAAI,CAAC,SAAS,IAAI,CAAC,SAAS,EAAE,CAAC;gBAC7B,MAAM,IAAI,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC;gBAC7B,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;oBACvB,SAAS,GAAG,IAAI,CAAC;gBACnB,CAAC;qBAAM,CAAC;oBACN,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC;oBACtB,SAAS,GAAG,IAAI,CAAC;gBACnB,CAAC;YACH,CAAC;YACD,OAAO,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC;QAC1C,CAAC;QACD,IAAI;YACF,SAAS,GAAG,KAAK,CAAC;QACpB,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,IAAI,CAAI,MAAmB,EAAE,KAAa;IACxD,2EAA2E;IAC3E,4EAA4E;IAC5E,6EAA6E;IAC7E,sDAAsD;IACtD,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,UAAU,CAAC,6CAA6C,KAAK,GAAG,CAAC,CAAC;IAC9E,CAAC;IAED,MAAM,KAAK,GAAQ,EAAE,CAAC;IACtB,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;QACf,OAAO,KAAK,CAAC;IACf,CAAC;IACD,KAAK,MAAM,IAAI,IAAI,MAAM,EAAE,CAAC;QAC1B,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACjB,IAAI,KAAK,CAAC,MAAM,IAAI,KAAK,EAAE,CAAC;YAC1B,MAAM;QACR,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@kensio/quando",
+  "version": "0.1.0-beta.0",
+  "description": "Declarative temporal rules for schedules, deadlines, constraints, and exceptions",
+  "repository": "https://github.com/KensioSoftware/quando",
+  "homepage": "https://quandojs.dev",
+  "bugs": "https://github.com/KensioSoftware/quando/issues",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "imports": {
+    "#test/*": "./test/*"
+  },
+  "packageManager": "pnpm@11.21.0+sha512.521705bce689924eac72f5a3587122f362689ef6571e55ba80076fd637c11132ecffada26fad4ea79c485bfddbfd3d5a2a5b05805a77e893de71ec8a6cca3bb1",
+  "engines": {
+    "node": ">=26.0.0"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "prepack": "pnpm build",
+    "build:check": "tsc -p tsconfig.json --noEmit",
+    "fmt": "oxlint --fix . && oxfmt .",
+    "lint": "oxlint . && oxfmt --check .",
+    "lint:ci": "oxlint --format=github . && oxfmt --check .",
+    "docs:check": "./scripts/sh/docs-check.sh",
+    "fta": "./scripts/sh/fta.sh",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "pack:check": "./scripts/sh/pack-check.sh",
+    "check": "pnpm fmt && pnpm docs:check && pnpm fta && pnpm build:check && pnpm pack:check && pnpm test:coverage"
+  },
+  "devDependencies": {
+    "@kensio/smartass": "^1.33.0",
+    "@semantic-release/exec": "7.1.0",
+    "@types/node": "^26.0.0",
+    "@typescript/native": "npm:typescript@^7.0.2",
+    "@vitest/coverage-v8": "^4.1.10",
+    "conventional-changelog-conventionalcommits": "9.3.1",
+    "fta-cli": "^3.0.0",
+    "oxfmt": "^0.62.0",
+    "oxlint": "^1.77.0",
+    "oxlint-tsgolint": "^7.0.2001",
+    "semantic-release": "25.0.9",
+    "typescript": "npm:@typescript/typescript6@^6.0.2",
+    "vitest": "^4.1.10"
+  },
+  "keywords": [
+    "time",
+    "schedule",
+    "deadline",
+    "constraint"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "Kensio Software",
+  "license": "Apache-2.0",
+  "type": "module"
+}