@remit/calendar-service 0.0.18 → 0.0.20

package/dist/expand.d.ts

@@ -0,0 +1,73 @@
+import type { CalendarOccurrenceInput } from "@remit/data-ports";
+import ICAL from "ical.js";
+import type { ParsedCalendar } from "./parse.js";
+/**
+ * How far past a series' own start its occurrences are written out.
+ *
+ * A recurring event may have no end at all, so something has to bound the
+ * write. Two years covers every view a client asks for today and keeps the
+ * index one bounded write rather than an unbounded one; a resource whose series
+ * runs past it is marked with `expandedThrough` and stays the business of the
+ * live expansion that reads it.
+ */
+export declare const CALENDAR_EXPANSION_HORIZON_DAYS = 730;
+/**
+ * Ceiling on occurrences written for one resource, independent of the horizon.
+ * A per-minute RRULE fits three quarters of a million instances inside two
+ * years; the ceiling turns that into a marked, truncated index instead of a
+ * write that takes the process down.
+ */
+export declare const CALENDAR_EXPANSION_MAX_OCCURRENCES = 1000;
+/**
+ * Ceiling on iterator steps a live window expansion may take.
+ *
+ * A window expansion walks the series from its own start, because a rule is
+ * only meaningful from where it was anchored. A daily event written in 2005 is
+ * a few thousand steps away from today, which is cheap; a per-minute one is
+ * millions, which is a read that never returns. The cap turns the second case
+ * into a short answer rather than a hung request.
+ */
+export declare const CALENDAR_WINDOW_MAX_STEPS = 50000;
+export interface CalendarExpansion {
+    occurrences: CalendarOccurrenceInput[];
+    /**
+     * The instant through which `occurrences` is complete, or `""` when it holds
+     * the whole series.
+     */
+    expandedThrough: string;
+}
+/**
+ * The slot each override claims, canonicalized the way the iterator's slots
+ * are, so the two can be compared at all.
+ */
+export declare const overridesBySlot: (calendar: ParsedCalendar, collectionTimezone: string) => Map<string, ICAL.Component>;
+/**
+ * Flattens a resource into the occurrence rows a date-range read returns.
+ *
+ * A non-recurring resource is one row under an empty `recurrenceId`. A
+ * recurring one is a row per occurrence, each keyed by its RECURRENCE-ID slot
+ * as a UTC instant — the same canonical form an override's own RECURRENCE-ID
+ * resolves to, so an override lands on the occurrence it replaces instead of
+ * beside it.
+ *
+ * The horizon is anchored at the series' own start, not at today: two years of
+ * a series is a bounded write whatever a caller's clock says. A series running
+ * past it comes back marked with `expandedThrough`, which is what tells a later
+ * read to expand that resource live instead of trusting the index.
+ */
+export declare const expandCalendar: (calendar: ParsedCalendar, collectionTimezone: string) => CalendarExpansion;
+/**
+ * The occurrences of a resource that fall inside one window, computed rather
+ * than read.
+ *
+ * This is what serves a view of a series whose stored index stops before the
+ * window — an open-ended weekly meeting written years ago, whose horizon ran
+ * out long before today. The alternative is extending the index on read, which
+ * turns every view of an old series into an unbounded write; a bounded
+ * computation that persists nothing is the cheaper half of that trade, and the
+ * one that cannot leave anything behind to be wrong later.
+ */
+export declare const expandCalendarWindow: (calendar: ParsedCalendar, collectionTimezone: string, window: {
+    fromMs: number;
+    toMs: number;
+}) => CalendarOccurrenceInput[];

package/dist/expand.js

@@ -0,0 +1,188 @@
+import ICAL from "ical.js";
+import { hasRecurrence, projectEventDisplay } from "./project.js";
+import { dtEndTzid, dtStartTzid, resolveTime, toUtcIso, tzidOf, } from "./time.js";
+/**
+ * How far past a series' own start its occurrences are written out.
+ *
+ * A recurring event may have no end at all, so something has to bound the
+ * write. Two years covers every view a client asks for today and keeps the
+ * index one bounded write rather than an unbounded one; a resource whose series
+ * runs past it is marked with `expandedThrough` and stays the business of the
+ * live expansion that reads it.
+ */
+export const CALENDAR_EXPANSION_HORIZON_DAYS = 730;
+/**
+ * Ceiling on occurrences written for one resource, independent of the horizon.
+ * A per-minute RRULE fits three quarters of a million instances inside two
+ * years; the ceiling turns that into a marked, truncated index instead of a
+ * write that takes the process down.
+ */
+export const CALENDAR_EXPANSION_MAX_OCCURRENCES = 1000;
+/**
+ * Ceiling on iterator steps a live window expansion may take.
+ *
+ * A window expansion walks the series from its own start, because a rule is
+ * only meaningful from where it was anchored. A daily event written in 2005 is
+ * a few thousand steps away from today, which is cheap; a per-minute one is
+ * millions, which is a read that never returns. The cap turns the second case
+ * into a short answer rather than a hung request.
+ */
+export const CALENDAR_WINDOW_MAX_STEPS = 50_000;
+const HORIZON_MS = CALENDAR_EXPANSION_HORIZON_DAYS * 24 * 60 * 60 * 1000;
+const occurrenceOf = (collectionTimezone, recurrenceId, source, startDate, endDate, startTzid, endTzid) => {
+    const start = resolveTime(startDate, startTzid, collectionTimezone);
+    const end = resolveTime(endDate, endTzid, collectionTimezone);
+    return {
+        recurrenceId,
+        startAt: start.isoUtc,
+        endAt: end.isoUtc,
+        allDay: start.isDate,
+        ...projectEventDisplay(source),
+    };
+};
+/**
+ * The slot each override claims, canonicalized the way the iterator's slots
+ * are, so the two can be compared at all.
+ */
+export const overridesBySlot = (calendar, collectionTimezone) => {
+    const bySlot = new Map();
+    for (const override of calendar.overrides) {
+        const recurrenceId = override.getFirstPropertyValue("recurrence-id");
+        if (!(recurrenceId instanceof ICAL.Time))
+            continue;
+        const slot = resolveTime(recurrenceId, tzidOf(override.getFirstProperty("recurrence-id")), collectionTimezone).isoUtc;
+        bySlot.set(slot, override);
+    }
+    return bySlot;
+};
+/**
+ * Walks a recurring resource's occurrences between the bounds it is given.
+ *
+ * EXDATEs are ical.js's business — `ICAL.Event` skips them. Overrides are not
+ * left entirely to it: the iterator yields the master's own RRULE and RDATE
+ * slots, so an override whose RECURRENCE-ID names a slot the rule never
+ * produces — the shape a client writes after moving one instance and then
+ * editing the rule — would never be reached. Those are walked explicitly, so
+ * every VEVENT in the resource is an occurrence somebody can find.
+ */
+const walkOccurrences = (calendar, collectionTimezone, bounds) => {
+    const event = new ICAL.Event(calendar.master);
+    for (const override of calendar.overrides) {
+        event.relateException(override);
+    }
+    const overrideBySlot = overridesBySlot(calendar, collectionTimezone);
+    const masterStartTzid = dtStartTzid(calendar.master);
+    const occurrences = [];
+    const claimed = new Set();
+    const iterator = event.iterator();
+    let truncated = false;
+    let steps = 0;
+    let lastIteratedStart = "";
+    let next = iterator.next();
+    while (next) {
+        const slot = resolveTime(next, masterStartTzid, collectionTimezone);
+        if (slot.instantMs > bounds.throughMs ||
+            occurrences.length >= bounds.maxOccurrences ||
+            steps >= bounds.maxSteps) {
+            truncated = true;
+            break;
+        }
+        steps += 1;
+        claimed.add(slot.isoUtc);
+        if (slot.instantMs >= bounds.fromMs) {
+            // An overridden slot hands back the override's own DTSTART and DTEND, so
+            // the zones to read them in are the override's. A plain slot hands back
+            // the rule's start and an end derived from the master's duration, both in
+            // the master's start zone.
+            const source = overrideBySlot.get(slot.isoUtc);
+            const details = event.getOccurrenceDetails(next);
+            occurrences.push(occurrenceOf(collectionTimezone, slot.isoUtc, source ?? calendar.master, details.startDate, details.endDate, dtStartTzid(source ?? calendar.master), source ? dtEndTzid(source) : masterStartTzid));
+            lastIteratedStart = occurrences[occurrences.length - 1]?.startAt ?? "";
+        }
+        next = iterator.next();
+    }
+    // Overrides the rule never reached. Kept regardless of the horizon: they are
+    // a bounded, explicit list, and one moved instance is exactly the thing a
+    // user goes looking for.
+    for (const [slot, override] of overrideBySlot) {
+        if (claimed.has(slot))
+            continue;
+        const overrideEvent = new ICAL.Event(override);
+        const occurrence = occurrenceOf(collectionTimezone, slot, override, overrideEvent.startDate, overrideEvent.endDate, dtStartTzid(override), dtEndTzid(override));
+        const startMs = Date.parse(occurrence.startAt);
+        if (startMs < bounds.fromMs || startMs > bounds.throughMs)
+            continue;
+        occurrences.push(occurrence);
+    }
+    occurrences.sort((left, right) => left.startAt.localeCompare(right.startAt));
+    return { occurrences, truncated, lastIteratedStart };
+};
+/** The one occurrence a resource that does not recur produces. */
+const singleOccurrence = (calendar, collectionTimezone) => {
+    const event = new ICAL.Event(calendar.master);
+    return occurrenceOf(collectionTimezone, "", calendar.master, event.startDate, event.endDate, dtStartTzid(calendar.master), dtEndTzid(calendar.master));
+};
+/**
+ * Flattens a resource into the occurrence rows a date-range read returns.
+ *
+ * A non-recurring resource is one row under an empty `recurrenceId`. A
+ * recurring one is a row per occurrence, each keyed by its RECURRENCE-ID slot
+ * as a UTC instant — the same canonical form an override's own RECURRENCE-ID
+ * resolves to, so an override lands on the occurrence it replaces instead of
+ * beside it.
+ *
+ * The horizon is anchored at the series' own start, not at today: two years of
+ * a series is a bounded write whatever a caller's clock says. A series running
+ * past it comes back marked with `expandedThrough`, which is what tells a later
+ * read to expand that resource live instead of trusting the index.
+ */
+export const expandCalendar = (calendar, collectionTimezone) => {
+    if (!hasRecurrence(calendar)) {
+        return {
+            occurrences: [singleOccurrence(calendar, collectionTimezone)],
+            expandedThrough: "",
+        };
+    }
+    const event = new ICAL.Event(calendar.master);
+    const seriesStart = resolveTime(event.startDate, dtStartTzid(calendar.master), collectionTimezone).instantMs;
+    const walk = walkOccurrences(calendar, collectionTimezone, {
+        fromMs: Number.NEGATIVE_INFINITY,
+        throughMs: seriesStart + HORIZON_MS,
+        maxOccurrences: CALENDAR_EXPANSION_MAX_OCCURRENCES,
+        maxSteps: Number.POSITIVE_INFINITY,
+    });
+    // Every truncated walk is marked, including one that collected nothing — a
+    // series whose first occurrence lands past the horizon. Its index is empty
+    // from the series start, which is the honest floor to write; `""` would
+    // claim the whole series is held and the live expansion would never run.
+    return {
+        occurrences: walk.occurrences,
+        expandedThrough: walk.truncated
+            ? toUtcIso(walk.lastIteratedStart
+                ? Date.parse(walk.lastIteratedStart)
+                : seriesStart)
+            : "",
+    };
+};
+/**
+ * The occurrences of a resource that fall inside one window, computed rather
+ * than read.
+ *
+ * This is what serves a view of a series whose stored index stops before the
+ * window — an open-ended weekly meeting written years ago, whose horizon ran
+ * out long before today. The alternative is extending the index on read, which
+ * turns every view of an old series into an unbounded write; a bounded
+ * computation that persists nothing is the cheaper half of that trade, and the
+ * one that cannot leave anything behind to be wrong later.
+ */
+export const expandCalendarWindow = (calendar, collectionTimezone, window) => {
+    if (!hasRecurrence(calendar)) {
+        return [singleOccurrence(calendar, collectionTimezone)];
+    }
+    return walkOccurrences(calendar, collectionTimezone, {
+        fromMs: window.fromMs,
+        throughMs: window.toMs,
+        maxOccurrences: CALENDAR_EXPANSION_MAX_OCCURRENCES,
+        maxSteps: CALENDAR_WINDOW_MAX_STEPS,
+    }).occurrences;
+};

package/dist/feed.d.ts

@@ -0,0 +1,81 @@
+import type { CalendarCollectionItem, CalendarObjectItem } from "@remit/data-ports";
+/** Random bytes behind a feed token (issue #1067). */
+export declare const CALENDAR_FEED_TOKEN_BYTES = 32;
+/** Where a feed lives, as the one place the shape of that path is written. */
+export declare const CALENDAR_FEED_PATH_PREFIX = "/feeds/calendar/";
+export declare const CALENDAR_FEED_PATH_SUFFIX = ".ics";
+/** A minted feed address: the secret, handed out once, and what is stored. */
+export interface CalendarFeedSecret {
+    token: string;
+    tokenHash: string;
+}
+export declare const hashCalendarFeedToken: (token: string) => string;
+/**
+ * A fresh feed token and the hash that will stand in for it.
+ *
+ * 32 random bytes rather than a stretched password: nothing about this value is
+ * user-chosen, so there is no dictionary to search and a slow hash would only
+ * tax every poll of every subscribed client.
+ */
+export declare const mintCalendarFeedToken: () => CalendarFeedSecret;
+/**
+ * Whether a path segment can be a feed token at all.
+ *
+ * Checked before anything is hashed or read, so a request carrying a megabyte
+ * of path or a `../` never reaches the store. A refusal here is the same 404 a
+ * revoked token gets — the caller learns nothing from the difference.
+ */
+export declare const isCalendarFeedToken: (token: string) => boolean;
+/**
+ * The token a request path carries, or `null` when the path is not a feed
+ * address. One segment only: a slash inside it would name a different route.
+ */
+export declare const readCalendarFeedToken: (path: string) => string | null;
+/**
+ * The feed path with its token taken out, for a log line or a metric label.
+ *
+ * The token is the whole credential, so a path that carries one is not a field
+ * that can be recorded. Redacted rather than dropped: which route was served is
+ * what an operator reads a log for, and a blank path loses that too.
+ */
+export declare const redactCalendarFeedPath: (path: string) => string;
+/** The bytes a feed serves, and what a conditional request needs to skip them. */
+export interface CalendarFeed {
+    icalData: string;
+    etag: string;
+}
+/**
+ * One VCALENDAR carrying every event in a collection.
+ *
+ * The stored components are copied across as they are: a recurring event
+ * travels as its master plus its RRULE, never as an expansion, because a
+ * subscriber renders occurrences itself and expects to keep doing so past any
+ * horizon this server would have chosen. VTIMEZONE definitions come along for
+ * the same reason — without them a client reads a TZID it cannot resolve.
+ *
+ * `X-WR-CALNAME` is a property of the calendar, not of the response: Apple
+ * Calendar, Google Calendar and Thunderbird all name a subscription from it.
+ */
+export declare const buildCalendarFeed: (collection: CalendarCollectionItem, objects: readonly CalendarObjectItem[]) => CalendarFeed;
+/**
+ * Whether an `If-None-Match` covers the tag the feed would serve.
+ *
+ * Accepts the weak form and `*`, and reads the header as the list RFC 9110
+ * 13.1.2 says it is — a subscriber that has polled through a proxy may get its
+ * own tag back with a `W/` on it, and answering 200 to that resends the whole
+ * calendar for nothing.
+ */
+export declare const calendarFeedIsUnchanged: (ifNoneMatch: string | undefined, etag: string) => boolean;
+/**
+ * Whether the calendar has stood still since the date an `If-Modified-Since`
+ * carries.
+ *
+ * Compared at whole seconds, which is the resolution an HTTP-date has: a
+ * `Last-Modified` served from a millisecond timestamp is rounded down on the
+ * way out, and comparing the unrounded value against what comes back declares
+ * every calendar modified within the second it was last written.
+ *
+ * An unreadable date is not a condition (RFC 9110 13.1.3) — the full calendar
+ * is served rather than a 304 nobody asked for.
+ */
+export declare const calendarFeedIsUnmodifiedSince: (ifModifiedSince: string | undefined, lastModifiedAt: number) => boolean;

package/dist/feed.js

@@ -0,0 +1,157 @@
+import { createHash, randomBytes } from "node:crypto";
+import ICAL from "ical.js";
+import { CALENDAR_PRODID } from "./build.js";
+import { computeEtag } from "./etag.js";
+import { serializeCalendar } from "./parse.js";
+/** Random bytes behind a feed token (issue #1067). */
+export const CALENDAR_FEED_TOKEN_BYTES = 32;
+/** Where a feed lives, as the one place the shape of that path is written. */
+export const CALENDAR_FEED_PATH_PREFIX = "/feeds/calendar/";
+export const CALENDAR_FEED_PATH_SUFFIX = ".ics";
+/** base64url over `CALENDAR_FEED_TOKEN_BYTES`, so the length is fixed. */
+const TOKEN_LENGTH = Math.ceil((CALENDAR_FEED_TOKEN_BYTES * 4) / 3);
+const TOKEN_SHAPE = new RegExp(`^[A-Za-z0-9_-]{${TOKEN_LENGTH}}$`);
+export const hashCalendarFeedToken = (token) => createHash("sha256").update(token, "utf8").digest("hex");
+/**
+ * A fresh feed token and the hash that will stand in for it.
+ *
+ * 32 random bytes rather than a stretched password: nothing about this value is
+ * user-chosen, so there is no dictionary to search and a slow hash would only
+ * tax every poll of every subscribed client.
+ */
+export const mintCalendarFeedToken = () => {
+    const token = randomBytes(CALENDAR_FEED_TOKEN_BYTES).toString("base64url");
+    return { token, tokenHash: hashCalendarFeedToken(token) };
+};
+/**
+ * Whether a path segment can be a feed token at all.
+ *
+ * Checked before anything is hashed or read, so a request carrying a megabyte
+ * of path or a `../` never reaches the store. A refusal here is the same 404 a
+ * revoked token gets — the caller learns nothing from the difference.
+ */
+export const isCalendarFeedToken = (token) => TOKEN_SHAPE.test(token);
+/**
+ * The token a request path carries, or `null` when the path is not a feed
+ * address. One segment only: a slash inside it would name a different route.
+ */
+export const readCalendarFeedToken = (path) => {
+    if (!path.startsWith(CALENDAR_FEED_PATH_PREFIX))
+        return null;
+    if (!path.endsWith(CALENDAR_FEED_PATH_SUFFIX))
+        return null;
+    const token = path.slice(CALENDAR_FEED_PATH_PREFIX.length, -CALENDAR_FEED_PATH_SUFFIX.length);
+    if (token.includes("/"))
+        return null;
+    return token;
+};
+/**
+ * The feed path with its token taken out, for a log line or a metric label.
+ *
+ * The token is the whole credential, so a path that carries one is not a field
+ * that can be recorded. Redacted rather than dropped: which route was served is
+ * what an operator reads a log for, and a blank path loses that too.
+ */
+export const redactCalendarFeedPath = (path) => readCalendarFeedToken(path) === null
+    ? path
+    : `${CALENDAR_FEED_PATH_PREFIX}<redacted>${CALENDAR_FEED_PATH_SUFFIX}`;
+/**
+ * A TEXT value as RFC 5545 3.3.11 writes one.
+ *
+ * ical.js escapes TEXT only for the properties in its design set, and no `X-`
+ * property is in it, so a value goes out verbatim: a comma or a semicolon
+ * reads back as a value list, and a line break as the start of a whole
+ * component the subscriber never had. TEXT has no encoding for a control
+ * character, so one is dropped rather than served.
+ */
+const escapeIcalText = (value) => value
+    .replace(/\\/g, "\\\\")
+    .replace(/;/g, "\\;")
+    .replace(/,/g, "\\,")
+    .replace(/\r\n|\r|\n/g, "\\n")
+    // biome-ignore lint/suspicious/noControlCharactersInRegex: RFC 5545 TEXT excludes CONTROL.
+    .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, "");
+/**
+ * One VCALENDAR carrying every event in a collection.
+ *
+ * The stored components are copied across as they are: a recurring event
+ * travels as its master plus its RRULE, never as an expansion, because a
+ * subscriber renders occurrences itself and expects to keep doing so past any
+ * horizon this server would have chosen. VTIMEZONE definitions come along for
+ * the same reason — without them a client reads a TZID it cannot resolve.
+ *
+ * `X-WR-CALNAME` is a property of the calendar, not of the response: Apple
+ * Calendar, Google Calendar and Thunderbird all name a subscription from it.
+ */
+export const buildCalendarFeed = (collection, objects) => {
+    const feed = new ICAL.Component("vcalendar");
+    feed.updatePropertyWithValue("prodid", CALENDAR_PRODID);
+    feed.updatePropertyWithValue("version", "2.0");
+    feed.updatePropertyWithValue("calscale", "GREGORIAN");
+    feed.updatePropertyWithValue("x-wr-calname", escapeIcalText(collection.displayName));
+    if (collection.timezone !== "") {
+        feed.updatePropertyWithValue("x-wr-timezone", escapeIcalText(collection.timezone));
+    }
+    const zonesSeen = new Set();
+    for (const object of objects) {
+        const stored = new ICAL.Component(ICAL.parse(object.icalData));
+        // A copy of the list, not the list: adding a component reparents it,
+        // which splices it out of the array `getAllSubcomponents` handed back and
+        // would drop whatever followed it.
+        for (const child of [...stored.getAllSubcomponents()]) {
+            if (child.name === "vtimezone") {
+                const tzid = child.getFirstPropertyValue("tzid");
+                const key = typeof tzid === "string" ? tzid : "";
+                if (zonesSeen.has(key))
+                    continue;
+                zonesSeen.add(key);
+            }
+            feed.addSubcomponent(child);
+        }
+    }
+    // ical.js leaves the last content line unterminated. Every line in an
+    // iCalendar stream ends with CRLF (RFC 5545 3.1), END:VCALENDAR included.
+    const serialized = serializeCalendar(feed);
+    const icalData = serialized.endsWith("\r\n")
+        ? serialized
+        : `${serialized}\r\n`;
+    return { icalData, etag: computeEtag(icalData) };
+};
+/**
+ * Whether an `If-None-Match` covers the tag the feed would serve.
+ *
+ * Accepts the weak form and `*`, and reads the header as the list RFC 9110
+ * 13.1.2 says it is — a subscriber that has polled through a proxy may get its
+ * own tag back with a `W/` on it, and answering 200 to that resends the whole
+ * calendar for nothing.
+ */
+export const calendarFeedIsUnchanged = (ifNoneMatch, etag) => {
+    if (ifNoneMatch === undefined || ifNoneMatch === "")
+        return false;
+    if (ifNoneMatch.trim() === "*")
+        return true;
+    return ifNoneMatch
+        .split(",")
+        .map((candidate) => candidate.trim().replace(/^W\//, "").replace(/^"|"$/g, ""))
+        .includes(etag);
+};
+/**
+ * Whether the calendar has stood still since the date an `If-Modified-Since`
+ * carries.
+ *
+ * Compared at whole seconds, which is the resolution an HTTP-date has: a
+ * `Last-Modified` served from a millisecond timestamp is rounded down on the
+ * way out, and comparing the unrounded value against what comes back declares
+ * every calendar modified within the second it was last written.
+ *
+ * An unreadable date is not a condition (RFC 9110 13.1.3) — the full calendar
+ * is served rather than a 304 nobody asked for.
+ */
+export const calendarFeedIsUnmodifiedSince = (ifModifiedSince, lastModifiedAt) => {
+    if (ifModifiedSince === undefined || ifModifiedSince === "")
+        return false;
+    const since = Date.parse(ifModifiedSince);
+    if (Number.isNaN(since))
+        return false;
+    return Math.floor(lastModifiedAt / 1000) * 1000 <= since;
+};

package/dist/fixtures.d.ts

@@ -0,0 +1,19 @@
+/**
+ * iCalendar fixtures, assembled from lines so the CRLF the RFC requires is
+ * explicit rather than a property of this file's own line endings.
+ */
+export declare const ical: (...lines: string[]) => string;
+/**
+ * The same resource as a client that ignores RFC 5545 3.1 would send it. Real
+ * `.ics` files arrive LF-only often enough — anything that has been through a
+ * text-mode checkout, an editor, or a naive copy — that reading them is part of
+ * the job, not an edge case.
+ */
+export declare const asLf: (icalData: string) => string;
+/**
+ * Europe/Amsterdam as a client writes it into a resource. Present so a
+ * DST-crossing series resolves against the definition the resource itself
+ * carries, which is the only zone data RFC 5545 promises a server.
+ */
+export declare const AMSTERDAM_VTIMEZONE: string[];
+export declare const singleEvent: (...eventLines: string[]) => string;

package/dist/fixtures.js

@@ -0,0 +1,37 @@
+/**
+ * iCalendar fixtures, assembled from lines so the CRLF the RFC requires is
+ * explicit rather than a property of this file's own line endings.
+ */
+export const ical = (...lines) => `${lines.join("\r\n")}\r\n`;
+/**
+ * The same resource as a client that ignores RFC 5545 3.1 would send it. Real
+ * `.ics` files arrive LF-only often enough — anything that has been through a
+ * text-mode checkout, an editor, or a naive copy — that reading them is part of
+ * the job, not an edge case.
+ */
+export const asLf = (icalData) => icalData.replace(/\r\n/g, "\n");
+/**
+ * Europe/Amsterdam as a client writes it into a resource. Present so a
+ * DST-crossing series resolves against the definition the resource itself
+ * carries, which is the only zone data RFC 5545 promises a server.
+ */
+export const AMSTERDAM_VTIMEZONE = [
+    "BEGIN:VTIMEZONE",
+    "TZID:Europe/Amsterdam",
+    "BEGIN:DAYLIGHT",
+    "TZOFFSETFROM:+0100",
+    "TZOFFSETTO:+0200",
+    "TZNAME:CEST",
+    "DTSTART:19700329T020000",
+    "RRULE:FREQ=YEARLY;BYMONTH=3;BYDAY=-1SU",
+    "END:DAYLIGHT",
+    "BEGIN:STANDARD",
+    "TZOFFSETFROM:+0200",
+    "TZOFFSETTO:+0100",
+    "TZNAME:CET",
+    "DTSTART:19701025T030000",
+    "RRULE:FREQ=YEARLY;BYMONTH=10;BYDAY=-1SU",
+    "END:STANDARD",
+    "END:VTIMEZONE",
+];
+export const singleEvent = (...eventLines) => ical("BEGIN:VCALENDAR", "VERSION:2.0", "PRODID:-//Remit//Calendar Tests//EN", "BEGIN:VEVENT", "UID:fixture@example.com", "DTSTAMP:20260801T090000Z", ...eventLines, "END:VEVENT", "END:VCALENDAR");

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+export { type AcceptCalendarSuggestionInput, type AcceptedCalendarSuggestion, acceptCalendarSuggestion, buildAcceptedCalendar, } from "./accept.js";
+export { applyEventFields, buildEventCalendar, CALENDAR_PRODID, type CalendarEventFields, eventTimeFields, OFFSET_BEARING, readEventTime, readRecurrenceRule, } from "./build.js";
+export { correctCalendarSuggestion } from "./correct.js";
+export type { CalendarResult, CalendarValidationCode, CalendarValidationError, } from "./errors.js";
+export { computeEtag } from "./etag.js";
+export { CALENDAR_EXPANSION_HORIZON_DAYS, CALENDAR_EXPANSION_MAX_OCCURRENCES, CALENDAR_WINDOW_MAX_STEPS, type CalendarExpansion, expandCalendar, expandCalendarWindow, } from "./expand.js";
+export { buildCalendarFeed, CALENDAR_FEED_PATH_PREFIX, CALENDAR_FEED_PATH_SUFFIX, CALENDAR_FEED_TOKEN_BYTES, type CalendarFeed, type CalendarFeedSecret, calendarFeedIsUnchanged, calendarFeedIsUnmodifiedSince, hashCalendarFeedToken, isCalendarFeedToken, mintCalendarFeedToken, readCalendarFeedToken, redactCalendarFeedPath, } from "./feed.js";
+export { type ParsedCalendar, parseCalendar, serializeCalendar, } from "./parse.js";
+export { type CalendarObjectProjection, projectCalendar, } from "./project.js";
+export { DEFAULT_CALENDAR_URL_SEGMENT, deleteCalendarObject, deleteCalendarObjectWrite, type PutCalendarObjectInput, prepareCalendarObject, provisionDefaultCalendar, putCalendarObject, readWrittenObject, } from "./put.js";
+export { answersOvertakenBy, type ReopenCalendarSuggestionInput, reopenCalendarSuggestion, } from "./reopen.js";
+export { applyScopedDelete, applyScopedUpdate, findOccurrence, followingUidOf, followingUidPrefix, type RecurrenceScopeValue, type ScopedWrite, type ScopedWriteInput, } from "./scope.js";
+export { CALENDAR_SUBSCRIPTION_MAX_BYTES, CALENDAR_SUBSCRIPTION_TIMEOUT_MS, type CalendarFeedFetch, type CalendarFeedFetcher, type CalendarFeedResource, type CalendarFeedSplit, type CalendarFeedWrite, type CalendarSubscriptionRefresh, type CalendarSubscriptionTarget, fetchCalendarFeed, isSubscriptionDue, readCalendarFeed, readSubscriptionUrl, recordCalendarFeedFailure, refreshCalendarSubscription, splitCalendarFeed, writeCalendarFeed, } from "./subscribe.js";
+export { type CalendarSuggestionProjection, inviteMethodOf, mailAddressOf, projectSuggestion, type RecordCalendarSuggestionInput, type RecordedCalendarSuggestion, recordCalendarSuggestion, } from "./suggest.js";
+export { civilInZone, isResolvableZone, type ResolvedTime, resolveTime, toOffsetIso, toUtcIso, } from "./time.js";
+export { type BusySpan, CALENDAR_WINDOW_LOOKBACK_DAYS, type CalendarInstance, type CalendarWindow, type CalendarWindowRepositories, isBusy, listBusySpans, listCalendarInstances, listObjectInstances, mergeBusySpans, } from "./window.js";

package/dist/index.js

@@ -0,0 +1,15 @@
+export { acceptCalendarSuggestion, buildAcceptedCalendar, } from "./accept.js";
+export { applyEventFields, buildEventCalendar, CALENDAR_PRODID, eventTimeFields, OFFSET_BEARING, readEventTime, readRecurrenceRule, } from "./build.js";
+export { correctCalendarSuggestion } from "./correct.js";
+export { computeEtag } from "./etag.js";
+export { CALENDAR_EXPANSION_HORIZON_DAYS, CALENDAR_EXPANSION_MAX_OCCURRENCES, CALENDAR_WINDOW_MAX_STEPS, expandCalendar, expandCalendarWindow, } from "./expand.js";
+export { buildCalendarFeed, CALENDAR_FEED_PATH_PREFIX, CALENDAR_FEED_PATH_SUFFIX, CALENDAR_FEED_TOKEN_BYTES, calendarFeedIsUnchanged, calendarFeedIsUnmodifiedSince, hashCalendarFeedToken, isCalendarFeedToken, mintCalendarFeedToken, readCalendarFeedToken, redactCalendarFeedPath, } from "./feed.js";
+export { parseCalendar, serializeCalendar, } from "./parse.js";
+export { projectCalendar, } from "./project.js";
+export { DEFAULT_CALENDAR_URL_SEGMENT, deleteCalendarObject, deleteCalendarObjectWrite, prepareCalendarObject, provisionDefaultCalendar, putCalendarObject, readWrittenObject, } from "./put.js";
+export { answersOvertakenBy, reopenCalendarSuggestion, } from "./reopen.js";
+export { applyScopedDelete, applyScopedUpdate, findOccurrence, followingUidOf, followingUidPrefix, } from "./scope.js";
+export { CALENDAR_SUBSCRIPTION_MAX_BYTES, CALENDAR_SUBSCRIPTION_TIMEOUT_MS, fetchCalendarFeed, isSubscriptionDue, readCalendarFeed, readSubscriptionUrl, recordCalendarFeedFailure, refreshCalendarSubscription, splitCalendarFeed, writeCalendarFeed, } from "./subscribe.js";
+export { inviteMethodOf, mailAddressOf, projectSuggestion, recordCalendarSuggestion, } from "./suggest.js";
+export { civilInZone, isResolvableZone, resolveTime, toOffsetIso, toUtcIso, } from "./time.js";
+export { CALENDAR_WINDOW_LOOKBACK_DAYS, isBusy, listBusySpans, listCalendarInstances, listObjectInstances, mergeBusySpans, } from "./window.js";