slotlock 0.8.0 → 0.10.0

package/booking-rules.d.ts

@@ -1,3 +1,4 @@
+import { type SlotlockRankedException } from './hours.js';
 import type { Interval, WeeklyAvailabilityRule } from './types.js';
 /**
  * A resource's booking rules: what a booking made through Slotlock (hold, reservation, agent event)
@@ -24,10 +25,52 @@ export interface SlotlockBookingRules {
      */
     bufferBeforeMinutes?: number;
     /**
-     * Minutes kept free after each booking made under the rule, as its trailing buffer: 0-1,440.
-     * Bookings made before the rule, or imported, keep what they have.
+     * Minutes kept free after each booking made under the rule, as its trailing buffer: 0-10,080 (a
+     * week, for a vehicle's service after a long hire). Bookings made before the rule, or imported,
+     * keep what they have.
      */
     turnaroundMinutes?: number;
+    /** A booking lasts at least this many minutes: 1-525,600 (a year). */
+    minDurationMinutes?: number;
+    /** A booking lasts at most this many minutes: 1-525,600. */
+    maxDurationMinutes?: number;
+    /** A booking lasts exactly one of these many minutes: 1-20 lengths, each 1-525,600. */
+    allowedDurations?: number[];
+    /** The length a search offers when it is asked for none: 1-525,600, and allowed by the others. */
+    defaultDurationMinutes?: number;
+    /**
+     * A booking from one local day to another (a hire) starts inside one of these windows of the day,
+     * in the resource's time zone: 1-4 windows. A booking within one day is not held to them.
+     */
+    pickupTimes?: SlotlockDayWindow[];
+    /** Such a booking ends inside one of these windows of the day, alike. */
+    returnTimes?: SlotlockDayWindow[];
+    /**
+     * How the bookable hours hold a booking from one local day to another (a hire): `whole`, every
+     * minute of it inside them; `ends`, only its start and end, the resource being out between. A
+     * booking within one day lies inside them either way. By default `ends` where `pickupTimes` or
+     * `returnTimes` are given, else `whole`. Writes are held to it under `enforceHours`; searches
+     * (slots and ranges) follow it always.
+     */
+    hoursApply?: SlotlockHoursApply;
+    /**
+     * A booking is cancelled at least this many minutes before it starts (RFC 0004 B5): 0-525,600.
+     * Later, cancelling it is refused (`cancel_cutoff`) unless an admin overrides with a reason.
+     */
+    cancelCutoffMinutes?: number;
+    /** A booking is moved at least this many minutes before it starts, alike (`reschedule_cutoff`). */
+    rescheduleCutoffMinutes?: number;
+    /**
+     * What a cancellation costs, recorded on it for the integrator to charge: Slotlock never moves
+     * money. With `withinMinutes`, only a cancellation that late before the start.
+     */
+    cancellationFee?: SlotlockCancellationFee;
+    /**
+     * What holding the resource costs, set by the tenant (RFC 0004 C3): an agent's hold of it waits for
+     * this payment (at most 30 minutes) whatever the agent asks, an agent names no other price, and an
+     * agent books it only from such a hold, once paid. The tenant's own systems set their own.
+     */
+    holdPrice?: SlotlockHoldPrice;
     /** A booking lies inside the resource's bookable hours. */
     enforceHours?: boolean;
     /**
@@ -43,8 +86,25 @@ export interface SlotlockBookingRules {
      */
     requireCertain?: boolean;
 }
+/** A cancellation's fee: an amount in the currency's minor unit (cents), ISO 4217 currency. */
+export interface SlotlockCancellationFee {
+    amountMinor: number;
+    currency: string;
+    /** Only a cancellation this many minutes or fewer before the start: 0-525,600. */
+    withinMinutes?: number;
+}
+/** A hold's price: an amount in the currency's minor unit (cents), ISO 4217 currency. */
+export interface SlotlockHoldPrice {
+    amountMinor: number;
+    currency: string;
+}
+/** A window of a day: minutes after local midnight, and how long (it may run past midnight). */
+export interface SlotlockDayWindow {
+    startMinutes: number;
+    durationMinutes: number;
+}
 /** Which rule a write broke, as its refusal names it. */
-export type SlotlockBookingRule = 'min_notice' | 'max_advance' | 'slot_step' | 'outside_hours' | 'uncertain';
+export type SlotlockBookingRule = 'min_notice' | 'max_advance' | 'slot_step' | 'outside_hours' | 'uncertain' | 'min_duration' | 'max_duration' | 'duration_not_allowed' | 'pickup_time' | 'return_time' | 'cancel_cutoff' | 'reschedule_cutoff';
 /** Each numeric rule's least and greatest value. */
 export declare const SLOTLOCK_BOOKING_RULE_LIMITS: Readonly<{
     readonly minNoticeMinutes: readonly [0, 525600];
@@ -54,7 +114,29 @@ export declare const SLOTLOCK_BOOKING_RULE_LIMITS: Readonly<{
     readonly bufferBeforeMinutes: readonly [0, number];
     readonly turnaroundMinutes: readonly [0, number];
     readonly checkInMinutes: readonly [1, number];
+    readonly minDurationMinutes: readonly [1, 525600];
+    readonly maxDurationMinutes: readonly [1, 525600];
+    readonly defaultDurationMinutes: readonly [1, 525600];
+    readonly cancelCutoffMinutes: readonly [0, 525600];
+    readonly rescheduleCutoffMinutes: readonly [0, 525600];
 }>;
+/** Lengths `allowedDurations` may list. */
+export declare const SLOTLOCK_MAX_ALLOWED_DURATIONS = 20;
+/** Windows `pickupTimes` and `returnTimes` may each hold. */
+export declare const SLOTLOCK_MAX_DAY_WINDOWS = 4;
+/** How the hours hold a hire (`hoursApply`). */
+export type SlotlockHoursApply = 'whole' | 'ends';
+/** The `hoursApply` a resource's rules mean: as given, else `ends` with pick-up or return times. */
+export declare function hoursApplyOf(rules: SlotlockBookingRules | undefined): SlotlockHoursApply;
+/**
+ * The cutoff rule a cancellation or move of a booking starting at `start`, made at `now`, breaks,
+ * or null (RFC 0004 B5).
+ */
+export declare function cutoffRuleBroken(rules: SlotlockBookingRules | undefined, kind: 'cancel' | 'reschedule', start: Date, now: Date): 'cancel_cutoff' | 'reschedule_cutoff' | null;
+/** The fee a cancellation of a booking starting at `start`, made at `now`, records, or null. */
+export declare function cancellationFeeDue(rules: SlotlockBookingRules | undefined, start: Date, now: Date): SlotlockCancellationFee | null;
+/** The duration rule a booking of `minutes` breaks, or null. */
+export declare function durationRuleBroken(rules: SlotlockBookingRules | undefined, minutes: number): 'min_duration' | 'max_duration' | 'duration_not_allowed' | null;
 /** Booking rules from untrusted input, or a TypeError naming the field that is wrong. */
 export declare function parseBookingRules(value: unknown): SlotlockBookingRules;
 /**
@@ -83,13 +165,27 @@ export declare function bookingBufferBeforeMs(rules: SlotlockBookingRules | unde
  */
 export declare function nextStepStart(from: Date, stepMinutes: number, timezone: string, offsetMinutes?: number): Date;
 /**
- * The rule a booking of `interval` made at `now` breaks, or null. `hours` (the resource's own, or
- * the default) are read only when enforced.
+ * Whether a booking runs from one local day into another (a hire): its last moment falls on a later
+ * local day than its start. One that ends at midnight stays on its day.
+ */
+export declare function isMultiDay(interval: Interval, timezone: string): boolean;
+/**
+ * Whether `instant` lies in one of the windows of its local day: `[start, start + length)`, or with
+ * `closed` (a return) up to and including the window's end.
+ */
+export declare function withinDayWindows(instant: Date, windows: readonly SlotlockDayWindow[], timezone: string, closed?: boolean): boolean;
+/**
+ * The rule a booking of `interval` made at `now` breaks, or null. `hours` (the resource's own, else
+ * inherited, else the default) and `exceptions` are read only when enforced. A hire (a booking from
+ * one local day to another) under `pickupTimes` or `returnTimes` starts and ends in them, and under
+ * `enforceHours` lies inside the hours as `hoursApply` says: wholly, or only at its start and end
+ * (the resource being out between).
  */
 export declare function bookingRuleBroken(params: {
     rules: SlotlockBookingRules | undefined;
     timezone: string;
     hours: readonly WeeklyAvailabilityRule[];
+    exceptions?: readonly SlotlockRankedException[];
     interval: Interval;
     now: Date;
 }): SlotlockBookingRule | null;
@@ -114,6 +210,8 @@ export declare function bookingSearch(params: {
     window: Interval;
     now: Date;
     bufferAfterMs?: number;
+    /** The length searched for: a length the duration rules refuse finds nothing. */
+    durationMs?: number;
 }): SlotlockBookingSearch | null;
 /** The time a search must read as free or busy: its window widened by a slot's buffers. */
 export declare function bookingSearchReach(search: SlotlockBookingSearch): Interval;

package/booking-rules.js

@@ -1,4 +1,4 @@
-import { expandRules } from './rules.js';
+import { coveredByOpenWindows, openWindows } from './hours.js';
 import { zonedOffsetMinutes } from './timezone.js';
 const MINUTE_MS = 60_000;
 const DAY_MINUTES = 24 * 60;
@@ -9,10 +9,147 @@ export const SLOTLOCK_BOOKING_RULE_LIMITS = Object.freeze({
     slotStepMinutes: [1, DAY_MINUTES],
     stepOffsetMinutes: [0, DAY_MINUTES - 1],
     bufferBeforeMinutes: [0, DAY_MINUTES],
-    turnaroundMinutes: [0, DAY_MINUTES],
+    turnaroundMinutes: [0, 7 * DAY_MINUTES],
     checkInMinutes: [1, DAY_MINUTES],
+    minDurationMinutes: [1, 525_600],
+    maxDurationMinutes: [1, 525_600],
+    defaultDurationMinutes: [1, 525_600],
+    cancelCutoffMinutes: [0, 525_600],
+    rescheduleCutoffMinutes: [0, 525_600],
 });
 const LIMITS = SLOTLOCK_BOOKING_RULE_LIMITS;
+/** Lengths `allowedDurations` may list. */
+export const SLOTLOCK_MAX_ALLOWED_DURATIONS = 20;
+/** Windows `pickupTimes` and `returnTimes` may each hold. */
+export const SLOTLOCK_MAX_DAY_WINDOWS = 4;
+const LIST_RULES = new Set(['allowedDurations', 'pickupTimes', 'returnTimes', 'cancellationFee', 'holdPrice']);
+/** The `hoursApply` a resource's rules mean: as given, else `ends` with pick-up or return times. */
+export function hoursApplyOf(rules) {
+    if (rules?.hoursApply !== undefined)
+        return rules.hoursApply;
+    return rules?.pickupTimes !== undefined || rules?.returnTimes !== undefined ? 'ends' : 'whole';
+}
+function parseHoursApply(value) {
+    if (value !== 'whole' && value !== 'ends')
+        throw new TypeError("Slotlock booking rule hoursApply must be 'whole' or 'ends'");
+    return value;
+}
+/** `holdPrice` from untrusted input, or a TypeError. */
+function parseHoldPrice(value) {
+    const price = value;
+    if (typeof price !== 'object' ||
+        price === null ||
+        Array.isArray(price) ||
+        Object.keys(price).some((key) => !['amountMinor', 'currency'].includes(key)) ||
+        !Number.isSafeInteger(price.amountMinor) ||
+        price.amountMinor < 1 ||
+        price.amountMinor > 1_000_000_000_000 ||
+        typeof price.currency !== 'string' ||
+        !/^[A-Z]{3}$/.test(price.currency)) {
+        throw new TypeError('Slotlock booking rule holdPrice needs amountMinor (a whole 1-1,000,000,000,000) and currency (ISO 4217, like EUR)');
+    }
+    return { amountMinor: price.amountMinor, currency: price.currency };
+}
+/** `cancellationFee` from untrusted input, or a TypeError. */
+function parseCancellationFee(value) {
+    const fee = value;
+    if (typeof fee !== 'object' ||
+        fee === null ||
+        Array.isArray(fee) ||
+        Object.keys(fee).some((key) => !['amountMinor', 'currency', 'withinMinutes'].includes(key)) ||
+        !Number.isSafeInteger(fee.amountMinor) ||
+        fee.amountMinor < 0 ||
+        fee.amountMinor > 1_000_000_000_000 ||
+        typeof fee.currency !== 'string' ||
+        !/^[A-Z]{3}$/.test(fee.currency) ||
+        (fee.withinMinutes !== undefined &&
+            (!Number.isSafeInteger(fee.withinMinutes) || fee.withinMinutes < 0 || fee.withinMinutes > 525_600))) {
+        throw new TypeError('Slotlock booking rule cancellationFee needs amountMinor (a whole 0-1,000,000,000,000), currency (ISO 4217, like EUR) and optionally withinMinutes (0-525600)');
+    }
+    return {
+        amountMinor: fee.amountMinor,
+        currency: fee.currency,
+        ...(fee.withinMinutes !== undefined ? { withinMinutes: fee.withinMinutes } : {}),
+    };
+}
+/**
+ * The cutoff rule a cancellation or move of a booking starting at `start`, made at `now`, breaks,
+ * or null (RFC 0004 B5).
+ */
+export function cutoffRuleBroken(rules, kind, start, now) {
+    const minutes = kind === 'cancel' ? rules?.cancelCutoffMinutes : rules?.rescheduleCutoffMinutes;
+    if (minutes === undefined)
+        return null;
+    return now.getTime() > start.getTime() - minutes * MINUTE_MS ? (kind === 'cancel' ? 'cancel_cutoff' : 'reschedule_cutoff') : null;
+}
+/** The fee a cancellation of a booking starting at `start`, made at `now`, records, or null. */
+export function cancellationFeeDue(rules, start, now) {
+    const fee = rules?.cancellationFee;
+    if (!fee)
+        return null;
+    if (fee.withinMinutes !== undefined && now.getTime() < start.getTime() - fee.withinMinutes * MINUTE_MS)
+        return null;
+    return fee;
+}
+/** `allowedDurations` from untrusted input, or a TypeError. */
+function parseAllowedDurations(value) {
+    if (!Array.isArray(value) ||
+        value.length < 1 ||
+        value.length > SLOTLOCK_MAX_ALLOWED_DURATIONS ||
+        !value.every((length) => Number.isSafeInteger(length) && length >= 1 && length <= 525_600) ||
+        new Set(value).size !== value.length) {
+        throw new TypeError(`Slotlock booking rule allowedDurations must be 1-${SLOTLOCK_MAX_ALLOWED_DURATIONS} different whole minutes, each 1-525600`);
+    }
+    return [...value].sort((a, b) => a - b);
+}
+/** `pickupTimes` or `returnTimes` from untrusted input, or a TypeError. */
+function parseDayWindows(key, value) {
+    const valid = Array.isArray(value) &&
+        value.length >= 1 &&
+        value.length <= SLOTLOCK_MAX_DAY_WINDOWS &&
+        value.every((window) => typeof window === 'object' &&
+            window !== null &&
+            !Array.isArray(window) &&
+            Object.keys(window).every((name) => name === 'startMinutes' || name === 'durationMinutes') &&
+            Number.isSafeInteger(window.startMinutes) &&
+            window.startMinutes >= 0 &&
+            window.startMinutes < DAY_MINUTES &&
+            Number.isSafeInteger(window.durationMinutes) &&
+            window.durationMinutes >= 1 &&
+            window.durationMinutes <= DAY_MINUTES);
+    if (!valid) {
+        throw new TypeError(`Slotlock booking rule ${key} must be 1-${SLOTLOCK_MAX_DAY_WINDOWS} windows of startMinutes (0-1439) and durationMinutes (1-1440)`);
+    }
+    return value.map((window) => ({
+        startMinutes: window.startMinutes,
+        durationMinutes: window.durationMinutes,
+    }));
+}
+/** Refuse durations that leave no length a booking may have (a TypeError naming them). */
+function checkDurations(rules) {
+    const min = rules.minDurationMinutes ?? 1;
+    const max = rules.maxDurationMinutes ?? 525_600;
+    if (min > max)
+        throw new TypeError('Slotlock booking rule minDurationMinutes must not exceed maxDurationMinutes');
+    if (rules.allowedDurations && !rules.allowedDurations.some((length) => length >= min && length <= max)) {
+        throw new TypeError('Slotlock booking rule allowedDurations has no length within the minimum and maximum');
+    }
+    if (rules.defaultDurationMinutes !== undefined && durationRuleBroken(rules, rules.defaultDurationMinutes) !== null) {
+        throw new TypeError('Slotlock booking rule defaultDurationMinutes must be a length the other rules allow');
+    }
+}
+/** The duration rule a booking of `minutes` breaks, or null. */
+export function durationRuleBroken(rules, minutes) {
+    if (!rules)
+        return null;
+    if (rules.minDurationMinutes !== undefined && minutes < rules.minDurationMinutes)
+        return 'min_duration';
+    if (rules.maxDurationMinutes !== undefined && minutes > rules.maxDurationMinutes)
+        return 'max_duration';
+    if (rules.allowedDurations !== undefined && !rules.allowedDurations.includes(minutes))
+        return 'duration_not_allowed';
+    return null;
+}
 /** Booking rules from untrusted input, or a TypeError naming the field that is wrong. */
 export function parseBookingRules(value) {
     if (typeof value !== 'object' || value === null || Array.isArray(value)) {
@@ -21,10 +158,22 @@ export function parseBookingRules(value) {
     const input = value;
     const rules = {};
     for (const key of Object.keys(input)) {
-        if (!(key in LIMITS) && key !== 'enforceHours' && key !== 'requireCertain') {
+        if (!(key in LIMITS) && key !== 'enforceHours' && key !== 'requireCertain' && key !== 'hoursApply' && !LIST_RULES.has(key)) {
             throw new TypeError(`Slotlock booking rules have no ${key}`);
         }
     }
+    if (input.hoursApply !== undefined)
+        rules.hoursApply = parseHoursApply(input.hoursApply);
+    if (input.allowedDurations !== undefined)
+        rules.allowedDurations = parseAllowedDurations(input.allowedDurations);
+    if (input.cancellationFee !== undefined)
+        rules.cancellationFee = parseCancellationFee(input.cancellationFee);
+    if (input.holdPrice !== undefined)
+        rules.holdPrice = parseHoldPrice(input.holdPrice);
+    if (input.pickupTimes !== undefined)
+        rules.pickupTimes = parseDayWindows('pickupTimes', input.pickupTimes);
+    if (input.returnTimes !== undefined)
+        rules.returnTimes = parseDayWindows('returnTimes', input.returnTimes);
     for (const [key, [min, max]] of Object.entries(LIMITS)) {
         const field = input[key];
         if (field === undefined)
@@ -51,6 +200,7 @@ export function parseBookingRules(value) {
         rules.stepOffsetMinutes >= rules.slotStepMinutes) {
         throw new TypeError('Slotlock booking rule stepOffsetMinutes must be less than slotStepMinutes');
     }
+    checkDurations(rules);
     return rules;
 }
 /**
@@ -73,6 +223,29 @@ export function parseEffectiveBookingRules(value) {
                 dropped.push(key);
             continue;
         }
+        if (key === 'hoursApply') {
+            if (field === 'whole' || field === 'ends')
+                rules.hoursApply = field;
+            else
+                dropped.push(key);
+            continue;
+        }
+        if (LIST_RULES.has(key)) {
+            try {
+                if (key === 'allowedDurations')
+                    rules.allowedDurations = parseAllowedDurations(field);
+                else if (key === 'cancellationFee')
+                    rules.cancellationFee = parseCancellationFee(field);
+                else if (key === 'holdPrice')
+                    rules.holdPrice = parseHoldPrice(field);
+                else
+                    rules[key] = parseDayWindows(key, field);
+            }
+            catch {
+                dropped.push(key);
+            }
+            continue;
+        }
         const limits = LIMITS[key];
         if (limits === undefined ||
             typeof field !== 'number' ||
@@ -84,6 +257,13 @@ export function parseEffectiveBookingRules(value) {
         }
         rules[key] = field;
     }
+    // Levels are validated alone: a combination that leaves no length refuses every booking.
+    try {
+        checkDurations(rules);
+    }
+    catch {
+        dropped.push('durations');
+    }
     return { rules, dropped };
 }
 /**
@@ -138,9 +318,35 @@ export function nextStepStart(from, stepMinutes, timezone, offsetMinutes = 0) {
     }
     return candidate;
 }
+/** The local day an instant falls on in `timezone`, as days since 1970-01-01. */
+function localDay(instant, timezone) {
+    const local = instant.getTime() + zonedOffsetMinutes(instant, timezone) * MINUTE_MS;
+    return Math.floor(local / (DAY_MINUTES * MINUTE_MS));
+}
 /**
- * The rule a booking of `interval` made at `now` breaks, or null. `hours` (the resource's own, or
- * the default) are read only when enforced.
+ * Whether a booking runs from one local day into another (a hire): its last moment falls on a later
+ * local day than its start. One that ends at midnight stays on its day.
+ */
+export function isMultiDay(interval, timezone) {
+    return localDay(new Date(interval.end.getTime() - 1), timezone) > localDay(interval.start, timezone);
+}
+/**
+ * Whether `instant` lies in one of the windows of its local day: `[start, start + length)`, or with
+ * `closed` (a return) up to and including the window's end.
+ */
+export function withinDayWindows(instant, windows, timezone, closed = false) {
+    const minutes = localMinutes(instant, timezone);
+    return windows.some((window) => {
+        const into = (((minutes - window.startMinutes) % DAY_MINUTES) + DAY_MINUTES) % DAY_MINUTES;
+        return closed ? into <= window.durationMinutes : into < window.durationMinutes;
+    });
+}
+/**
+ * The rule a booking of `interval` made at `now` breaks, or null. `hours` (the resource's own, else
+ * inherited, else the default) and `exceptions` are read only when enforced. A hire (a booking from
+ * one local day to another) under `pickupTimes` or `returnTimes` starts and ends in them, and under
+ * `enforceHours` lies inside the hours as `hoursApply` says: wholly, or only at its start and end
+ * (the resource being out between).
  */
 export function bookingRuleBroken(params) {
     const { rules, interval, now } = params;
@@ -158,18 +364,37 @@ export function bookingRuleBroken(params) {
         !onStep(interval.start, rules.slotStepMinutes, params.timezone, stepOffset(rules))) {
         return 'slot_step';
     }
+    const duration = durationRuleBroken(rules, (interval.end.getTime() - start) / MINUTE_MS);
+    if (duration)
+        return duration;
+    const multiDay = isMultiDay(interval, params.timezone);
+    if (multiDay && rules.pickupTimes && !withinDayWindows(interval.start, rules.pickupTimes, params.timezone)) {
+        return 'pickup_time';
+    }
+    if (multiDay && rules.returnTimes && !withinDayWindows(interval.end, rules.returnTimes, params.timezone, true)) {
+        return 'return_time';
+    }
+    // A hire the hours hold only at its ends.
+    const hire = multiDay && hoursApplyOf(rules) === 'ends';
     if (rules.enforceHours === true) {
-        const open = expandRules([...params.hours], interval, params.timezone);
-        let covered = interval.start.getTime();
-        for (const window of open.sort((a, b) => a.start.getTime() - b.start.getTime())) {
-            if (window.start.getTime() > covered)
-                break;
-            covered = Math.max(covered, window.end.getTime());
-            if (covered >= interval.end.getTime())
-                break;
+        const open = (window) => openWindows({
+            hours: params.hours,
+            ...(params.exceptions !== undefined ? { exceptions: params.exceptions } : {}),
+            timezone: params.timezone,
+            window,
+        });
+        if (hire) {
+            // Open at the start, and open up to the end: the hours a hire is collected and returned in.
+            const minute = MINUTE_MS;
+            const atStart = { start: interval.start, end: new Date(start + minute) };
+            const atEnd = { start: new Date(interval.end.getTime() - minute), end: interval.end };
+            if (!coveredByOpenWindows(open(atStart), atStart) || !coveredByOpenWindows(open(atEnd), atEnd)) {
+                return 'outside_hours';
+            }
         }
-        if (covered < interval.end.getTime())
+        else if (!coveredByOpenWindows(open(interval), interval)) {
             return 'outside_hours';
+        }
     }
     return null;
 }
@@ -179,6 +404,9 @@ export function bookingRuleBroken(params) {
  */
 export function bookingSearch(params) {
     const { rules, window, now } = params;
+    if (params.durationMs !== undefined && durationRuleBroken(rules, params.durationMs / MINUTE_MS) !== null) {
+        return null;
+    }
     let start = window.start.getTime();
     const end = window.end.getTime();
     if (rules?.minNoticeMinutes !== undefined) {
@@ -188,7 +416,27 @@ export function bookingSearch(params) {
     const bufferBeforeMs = bookingBufferBeforeMs(rules);
     const step = rules?.slotStepMinutes;
     const offset = stepOffset(rules);
-    const toStep = step === undefined ? undefined : (from) => nextStepStart(from, step, params.timezone, offset);
+    const stepped = step === undefined ? undefined : (from) => nextStepStart(from, step, params.timezone, offset);
+    // A slot that runs from one local day into another starts and ends in the pick-up and return
+    // times: candidates move on a minute (or a step) at a time, for at most two days.
+    const durationMs = params.durationMs;
+    const hireRules = rules && (rules.pickupTimes !== undefined || rules.returnTimes !== undefined) ? rules : undefined;
+    const toStep = hireRules === undefined || durationMs === undefined
+        ? stepped
+        : (from) => {
+            let candidate = stepped ? stepped(from) : new Date(Math.ceil(from.getTime() / MINUTE_MS) * MINUTE_MS);
+            for (let tries = 0; tries <= 2 * DAY_MINUTES; tries++) {
+                const slot = { start: candidate, end: new Date(candidate.getTime() + durationMs) };
+                if (!isMultiDay(slot, params.timezone) ||
+                    ((!hireRules.pickupTimes || withinDayWindows(slot.start, hireRules.pickupTimes, params.timezone)) &&
+                        (!hireRules.returnTimes || withinDayWindows(slot.end, hireRules.returnTimes, params.timezone, true)))) {
+                    return candidate;
+                }
+                const next = new Date(Math.floor(candidate.getTime() / MINUTE_MS) * MINUTE_MS + MINUTE_MS);
+                candidate = stepped ? stepped(next) : next;
+            }
+            return new Date(end + 1);
+        };
     const searched = { start: new Date(start), end: new Date(end) };
     if (rules?.maxAdvanceDays !== undefined) {
         const latestStart = now.getTime() + rules.maxAdvanceDays * DAY_MINUTES * MINUTE_MS;

package/config.d.ts

@@ -42,6 +42,41 @@ export interface SlotlockServeDashboardConfig {
      * `'enabled'`: those an owner turned on from the dashboard (Teams on Cloud, teams.ts).
      */
     organizations?: string[] | 'enabled';
+    /**
+     * Team workspaces (SLOTLOCK_DASHBOARD_TEAM_WORKSPACES=on): anyone signed in creates one and invites
+     * people to it by email, each with a role (workspaces.ts).
+     */
+    teamWorkspaces?: boolean;
+    /**
+     * Team invitations sent by email (SLOTLOCK_INVITATION_EMAIL resend or postmark, with
+     * SLOTLOCK_INVITATION_EMAIL_KEY and SLOTLOCK_INVITATION_EMAIL_FROM); without it, the person inviting
+     * sends the link.
+     */
+    invitationEmail?: {
+        provider: 'resend' | 'postmark';
+        key: string;
+        from: string;
+    };
+    /**
+     * Verified domains (SLOTLOCK_VERIFIED_DOMAINS=on, with team workspaces): a team's Owner proves a
+     * domain with a DNS record, and the people whose verified address is at it may ask to join. Looked
+     * up over DNS-over-HTTPS, or with the system's resolver (SLOTLOCK_DNS_RESOLVER=system, a server only).
+     */
+    verifiedDomains?: {
+        resolver: 'doh' | 'system';
+    };
+    /**
+     * Single sign-on through each team's own identity provider (SLOTLOCK_TEAM_SSO=on, with verified
+     * domains): its client secrets sealed under SLOTLOCK_SSO_SECRET.
+     */
+    teamSso?: {
+        secret: string;
+    };
+    /**
+     * SCIM provisioning (SLOTLOCK_TEAM_SCIM=on, with verified domains): each team's identity provider
+     * adds, deactivates and groups its people at the dashboard's /scim/v2.
+     */
+    teamScim?: boolean;
     /** What the deployment is called in the dashboard (SLOTLOCK_DASHBOARD_NAME). */
     name?: string;
     /**
@@ -85,6 +120,21 @@ export declare function readDashboardConfig(env: SlotlockEnv): SlotlockServeDash
  * organizations' keys, and only theirs.
  */
 export declare function readDashboardOrganizations(env: SlotlockEnv): string[] | 'enabled' | undefined;
+/**
+ * SLOTLOCK_VERIFIED_DOMAINS: on or off (the default), only with team workspaces; and
+ * SLOTLOCK_DNS_RESOLVER, how a domain's record is looked up: doh (the default: Cloudflare's
+ * DNS-over-HTTPS, cross-checked by Google's) or system (the server's own resolver, which follows
+ * split-horizon DNS). Read on its own as well: the server that runs maintenance checks the domains
+ * each day, wherever the dashboard runs.
+ */
+export declare function readVerifiedDomains(env: SlotlockEnv): {
+    resolver: 'doh' | 'system';
+} | undefined;
+/**
+ * SLOTLOCK_DASHBOARD_TEAM_WORKSPACES: on or off (the default). Read on its own as well: a server whose
+ * dashboard runs elsewhere (on Cloudflare Workers) takes team workspaces' keys only with it on.
+ */
+export declare function readDashboardTeamWorkspaces(env: SlotlockEnv): boolean;
 /** A token bucket: `perSecond` tokens come back each second, and it holds at most `burst`. */
 export interface SlotlockRate {
     perSecond: number;