@tasknotes/calendar 0.0.0-stage → 0.1.1

package/dist/esm/chunk-DVMZ5OXN.js

@@ -0,0 +1,694 @@
+// src/core/date.ts
+var DAY_MS = 864e5;
+var MINUTES_PER_DAY = 1440;
+function dayFromYMD(year, month, day) {
+  const d = /* @__PURE__ */ new Date(0);
+  d.setUTCFullYear(year, month - 1, day);
+  d.setUTCHours(0, 0, 0, 0);
+  return Math.floor(d.getTime() / DAY_MS);
+}
+function ymdOfDay(day) {
+  const d = new Date(day * DAY_MS);
+  return { year: d.getUTCFullYear(), month: d.getUTCMonth() + 1, day: d.getUTCDate() };
+}
+function weekdayOf(day) {
+  return ((day + 4) % 7 + 7) % 7;
+}
+function startOfWeek(day, firstDay) {
+  return day - (weekdayOf(day) - firstDay + 7) % 7;
+}
+function startOfMonth(day) {
+  const { year, month } = ymdOfDay(day);
+  return dayFromYMD(year, month, 1);
+}
+function daysInMonth(year, month) {
+  return dayFromYMD(year, month + 1, 1) - dayFromYMD(year, month, 1);
+}
+function addMonths(day, months) {
+  const { year, month, day: dom } = ymdOfDay(day);
+  const total = year * 12 + (month - 1) + months;
+  const y = Math.floor(total / 12);
+  const m = total % 12 + 1;
+  return dayFromYMD(y, m, Math.min(dom, daysInMonth(y, m)));
+}
+function startOfYear(day) {
+  return dayFromYMD(ymdOfDay(day).year, 1, 1);
+}
+var pad2 = (n) => String(n).padStart(2, "0");
+function formatDay(day) {
+  const { year, month, day: d } = ymdOfDay(day);
+  const y = year < 0 ? "-" + String(-year).padStart(6, "0") : String(year).padStart(4, "0");
+  return `${y}-${pad2(month)}-${pad2(d)}`;
+}
+var DATE_RE = /^(\d{4})-(\d{2})-(\d{2})$/;
+function parseDay(value) {
+  const m = DATE_RE.exec(value.trim());
+  if (!m) return null;
+  const year = Number(m[1]);
+  const month = Number(m[2]);
+  const d = Number(m[3]);
+  if (month < 1 || month > 12 || d < 1 || d > daysInMonth(year, month)) return null;
+  return dayFromYMD(year, month, d);
+}
+function isoWeekNumber(day) {
+  const thursday = day - (weekdayOf(day) + 6) % 7 + 3;
+  const jan1 = dayFromYMD(ymdOfDay(thursday).year, 1, 1);
+  return Math.floor((thursday - jan1) / 7) + 1;
+}
+function parseDurationMinutes(value, fallback) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value !== "string") return fallback;
+  const m = /^(-?\d{1,3}):(\d{2})(?::(\d{2}))?$/.exec(value.trim());
+  if (!m) return fallback;
+  const sign = m[1].startsWith("-") ? -1 : 1;
+  return sign * (Math.abs(Number(m[1])) * 60 + Number(m[2]) + Number(m[3] ?? 0) / 60);
+}
+function formatMinutes(minutes) {
+  const m = (Math.round(minutes) % MINUTES_PER_DAY + MINUTES_PER_DAY) % MINUTES_PER_DAY;
+  return `${pad2(Math.floor(m / 60))}:${pad2(m % 60)}`;
+}
+
+// src/core/zone.ts
+var LocalZone = class {
+  id = "local";
+  offsetAt(ms) {
+    return -new Date(ms).getTimezoneOffset();
+  }
+};
+var IanaZone = class {
+  constructor(id) {
+    this.id = id;
+    this.fmt = new Intl.DateTimeFormat("en-US", {
+      timeZone: id,
+      hourCycle: "h23",
+      year: "numeric",
+      month: "numeric",
+      day: "numeric",
+      hour: "numeric",
+      minute: "numeric",
+      second: "numeric"
+    });
+  }
+  id;
+  fmt;
+  cache = /* @__PURE__ */ new Map();
+  offsetAt(ms) {
+    const bucket = Math.floor(ms / 9e5);
+    const hit = this.cache.get(bucket);
+    if (hit !== void 0) return hit;
+    const at = bucket * 9e5;
+    const p = {};
+    for (const part of this.fmt.formatToParts(new Date(at))) {
+      if (part.type !== "literal") p[part.type] = Number(part.value);
+    }
+    const wall = dayFromYMD(p.year, p.month, p.day) * DAY_MS + ((p.hour * 60 + p.minute) * 60 + p.second) * 1e3;
+    const offset = Math.round((wall - at) / 6e4);
+    if (this.cache.size > 5e3) this.cache.clear();
+    this.cache.set(bucket, offset);
+    return offset;
+  }
+};
+var zones = /* @__PURE__ */ new Map();
+function getTimeZone(id) {
+  const key = !id || id === "local" ? "local" : id;
+  let z = zones.get(key);
+  if (!z) {
+    z = key === "local" ? new LocalZone() : new IanaZone(key);
+    zones.set(key, z);
+  }
+  return z;
+}
+function isValidTimeZone(id) {
+  if (id === "local") return true;
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: id });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function wallTime(ms, zone) {
+  const local = ms + zone.offsetAt(ms) * 6e4;
+  const day = Math.floor(local / DAY_MS);
+  return { day, minute: Math.floor((local - day * DAY_MS) / 6e4) };
+}
+function dayOf(ms, zone) {
+  return wallTime(ms, zone).day;
+}
+function toInstant(day, minute, zone) {
+  const localTs = day * DAY_MS + minute * 6e4;
+  const o = zone.offsetAt(localTs);
+  let utc = localTs - o * 6e4;
+  const o2 = zone.offsetAt(utc);
+  if (o === o2) return utc;
+  utc -= (o2 - o) * 6e4;
+  const o3 = zone.offsetAt(utc);
+  if (o2 === o3) return utc;
+  return localTs - Math.min(o2, o3) * 6e4;
+}
+function startOfDayInstant(day, zone) {
+  return toInstant(day, 0, zone);
+}
+function dayLengthMinutes(day, zone) {
+  return Math.round((startOfDayInstant(day + 1, zone) - startOfDayInstant(day, zone)) / 6e4);
+}
+var FLOATING_RE = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,3})\d*)?)?$/;
+var DATE_ONLY_RE = /^(\d{4})-(\d{2})-(\d{2})$/;
+function parseDateInput(value, zone) {
+  if (value instanceof Date) {
+    const t2 = value.getTime();
+    return Number.isNaN(t2) ? null : { kind: "instant", ms: t2 };
+  }
+  if (typeof value === "number") return Number.isFinite(value) ? { kind: "instant", ms: value } : null;
+  const s = value.trim();
+  let m = DATE_ONLY_RE.exec(s);
+  if (m) return { kind: "day", day: dayFromYMD(Number(m[1]), Number(m[2]), Number(m[3])) };
+  m = FLOATING_RE.exec(s);
+  if (m) {
+    const day = dayFromYMD(Number(m[1]), Number(m[2]), Number(m[3]));
+    const minute = Number(m[4]) * 60 + Number(m[5]);
+    const extraMs = Number(m[6] ?? 0) * 1e3 + Number((m[7] ?? "0").padEnd(3, "0"));
+    return { kind: "instant", ms: toInstant(day, minute, zone) + extraMs };
+  }
+  const t = Date.parse(s);
+  return Number.isNaN(t) ? null : { kind: "instant", ms: t };
+}
+function formatFloating(ms, zone) {
+  const { day, minute } = wallTime(ms, zone);
+  const d = new Date(day * DAY_MS);
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${d.getUTCFullYear()}-${pad(d.getUTCMonth() + 1)}-${pad(d.getUTCDate())}T${pad(Math.floor(minute / 60))}:${pad(minute % 60)}`;
+}
+
+// src/core/store.ts
+var DEFAULTS = { defaultTimedMinutes: 60, defaultAllDayDays: 1 };
+function signature(item) {
+  if (item.rev !== void 0) return `${item.id}#${String(item.rev)}`;
+  try {
+    return JSON.stringify(item, (_k, v) => v instanceof Date ? v.getTime() : v);
+  } catch {
+    return `${item.id}#${Math.random()}`;
+  }
+}
+var ItemStore = class _ItemStore {
+  zone;
+  opts;
+  items = /* @__PURE__ */ new Map();
+  timedByDay = /* @__PURE__ */ new Map();
+  spanning = /* @__PURE__ */ new Set();
+  pending = _ItemStore.emptyChange();
+  /** Bumped on every change; cheap staleness check for caches. */
+  version = 0;
+  constructor(zone, opts = {}) {
+    this.zone = zone;
+    this.opts = { ...DEFAULTS, ...opts };
+  }
+  static emptyChange() {
+    return { added: [], updated: [], removed: [], days: /* @__PURE__ */ new Set(), spans: false };
+  }
+  get size() {
+    return this.items.size;
+  }
+  get timeZone() {
+    return this.zone;
+  }
+  /** Re-resolves every item; used when the zone or defaults change. */
+  reconfigure(zone, opts = {}) {
+    this.zone = zone;
+    this.opts = { ...this.opts, ...opts };
+    const all = [...this.items.values()].map((n) => n.item);
+    this.items.clear();
+    this.timedByDay.clear();
+    this.spanning.clear();
+    for (const it of all) this.insert(it, "added");
+    this.pending.spans = true;
+  }
+  normalize(item) {
+    const zone = this.zone;
+    const s = parseDateInput(item.start, zone);
+    if (!s) return null;
+    const e = item.end != null && item.end !== "" ? parseDateInput(item.end, zone) : null;
+    const allDay = item.allDay ?? s.kind === "day";
+    const sig = signature(item);
+    if (allDay) {
+      const startDay2 = s.kind === "day" ? s.day : dayOf(s.ms, zone);
+      let endDay2 = startDay2 + this.opts.defaultAllDayDays;
+      if (e) {
+        const ed = e.kind === "day" ? e.day : dayOf(e.ms - 1, zone) + 1;
+        if (ed > startDay2) endDay2 = ed;
+      }
+      return {
+        id: item.id,
+        item,
+        allDay: true,
+        startDay: startDay2,
+        endDay: endDay2,
+        startMs: startOfDayInstant(startDay2, zone),
+        endMs: startOfDayInstant(endDay2, zone),
+        sig
+      };
+    }
+    const startMs = s.kind === "instant" ? s.ms : startOfDayInstant(s.day, zone);
+    let endMs = startMs + this.opts.defaultTimedMinutes * 6e4;
+    if (e) {
+      const em = e.kind === "instant" ? e.ms : startOfDayInstant(e.day, zone);
+      if (em > startMs) endMs = em;
+    }
+    const startDay = dayOf(startMs, zone);
+    const endDay = dayOf(endMs - 1, zone) + 1;
+    return { id: item.id, item, allDay: false, startMs, endMs, startDay, endDay, sig };
+  }
+  insert(item, kind) {
+    const n = this.normalize(item);
+    if (!n) return false;
+    this.items.set(n.id, n);
+    this.index(n);
+    this.pending[kind].push(n.id);
+    return true;
+  }
+  index(n) {
+    if (n.item.display === "none") return;
+    if (n.allDay) {
+      this.spanning.add(n.id);
+      this.pending.spans = true;
+      return;
+    }
+    if (n.endDay - n.startDay > 1) {
+      this.spanning.add(n.id);
+      this.pending.spans = true;
+    }
+    for (let d = n.startDay; d < n.endDay; d++) {
+      let set = this.timedByDay.get(d);
+      if (!set) this.timedByDay.set(d, set = /* @__PURE__ */ new Set());
+      set.add(n.id);
+      this.pending.days.add(d);
+    }
+    this.pending.spans = true;
+  }
+  unindex(n) {
+    if (this.spanning.delete(n.id)) this.pending.spans = true;
+    if (!n.allDay) {
+      for (let d = n.startDay; d < n.endDay; d++) {
+        this.timedByDay.get(d)?.delete(n.id);
+        this.pending.days.add(d);
+      }
+      this.pending.spans = true;
+    }
+  }
+  /** Replaces the whole item set, touching only items whose signature changed. */
+  setAll(items) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const item of items) {
+      if (seen.has(item.id)) continue;
+      seen.add(item.id);
+      this.upsertOne(item);
+    }
+    for (const [id, n] of this.items) {
+      if (!seen.has(id)) {
+        this.unindex(n);
+        this.items.delete(id);
+        this.pending.removed.push(id);
+      }
+    }
+    return this.flush();
+  }
+  /** Upserts items without removing others. */
+  upsert(items) {
+    for (const item of items) this.upsertOne(item);
+    return this.flush();
+  }
+  remove(ids) {
+    for (const id of ids) {
+      const n = this.items.get(id);
+      if (!n) continue;
+      this.unindex(n);
+      this.items.delete(id);
+      this.pending.removed.push(id);
+    }
+    return this.flush();
+  }
+  upsertOne(item) {
+    const prev = this.items.get(item.id);
+    if (prev) {
+      if (prev.sig === signature(item)) {
+        if (prev.item !== item) this.items.set(item.id, { ...prev, item });
+        return;
+      }
+      this.unindex(prev);
+      this.items.delete(item.id);
+      if (!this.insert(item, "updated")) this.pending.removed.push(item.id);
+      return;
+    }
+    this.insert(item, "added");
+  }
+  flush() {
+    const out = this.pending;
+    this.pending = _ItemStore.emptyChange();
+    if (out.added.length || out.updated.length || out.removed.length || out.spans || out.days.size) this.version++;
+    return out;
+  }
+  get(id) {
+    return this.items.get(id);
+  }
+  all() {
+    return this.items.values();
+  }
+  /** Timed items touching `day`. */
+  timedOn(day) {
+    const set = this.timedByDay.get(day);
+    if (!set) return [];
+    const out = [];
+    for (const id of set) {
+      const n = this.items.get(id);
+      if (n) out.push(n);
+    }
+    return out;
+  }
+  /** All-day items (and, if asked, multi-day timed items) overlapping [startDay, endDay). */
+  spanningIn(startDay, endDay, includeTimedMultiDay) {
+    const out = [];
+    for (const id of this.spanning) {
+      const n = this.items.get(id);
+      if (!n || n.startDay >= endDay || n.endDay <= startDay) continue;
+      if (!n.allDay && !includeTimedMultiDay) continue;
+      out.push(n);
+    }
+    return out;
+  }
+  /** Every visible item overlapping [startDay, endDay). */
+  inRange(startDay, endDay) {
+    const seen = /* @__PURE__ */ new Set();
+    const out = [];
+    for (const n of this.spanningIn(startDay, endDay, true)) {
+      seen.add(n.id);
+      out.push(n);
+    }
+    for (let d = startDay; d < endDay; d++) {
+      for (const n of this.timedOn(d)) {
+        if (seen.has(n.id)) continue;
+        seen.add(n.id);
+        out.push(n);
+      }
+    }
+    return out;
+  }
+};
+function daysOfRange(startMs, endMs, zone) {
+  return [dayOf(startMs, zone), dayOf(Math.max(startMs, endMs - 1), zone) + 1];
+}
+
+// src/core/layout.ts
+function segmentOn(n, day, zone) {
+  return segmentInWindow(n, day, 0, MINUTES_PER_DAY, zone);
+}
+function segmentInWindow(n, day, minMinute, maxMinute, zone) {
+  const winStart = toInstant(day, minMinute, zone);
+  const winEnd = toInstant(day, maxMinute, zone);
+  const s = Math.max(n.startMs, winStart);
+  const e = Math.min(n.endMs, winEnd);
+  const zeroLength = n.startMs === n.endMs && n.startMs >= winStart && n.startMs < winEnd;
+  if (e <= s && !zeroLength) return null;
+  const rel = (ms) => {
+    const w = wallTime(ms, zone);
+    return (w.day - day) * MINUTES_PER_DAY + w.minute;
+  };
+  const startMin = s === winStart ? minMinute : rel(s);
+  let endMin = e === winEnd ? maxMinute : rel(e);
+  if (endMin < startMin) endMin = Math.min(maxMinute, startMin + Math.round((e - s) / 6e4));
+  return {
+    item: n,
+    day,
+    startMin,
+    endMin,
+    isStart: n.startMs >= winStart,
+    isEnd: n.endMs <= winEnd
+  };
+}
+var defaultOrder = (a, b) => a.startMs - b.startMs || b.endMs - b.startMs - (a.endMs - a.startMs) || Number(b.allDay) - Number(a.allDay) || a.item.title.localeCompare(b.item.title);
+function packTimed(segs, minMinutes, order = defaultOrder) {
+  const sorted = segs.map((s) => ({ ...s, end: Math.max(s.endMin, s.startMin + minMinutes) })).sort((a, b) => a.startMin - b.startMin || b.end - a.end || order(a.item, b.item));
+  const out = [];
+  let cluster = [];
+  let colEnds = [];
+  let clusterEnd = -Infinity;
+  let clusterIndex = 0;
+  const flush = () => {
+    if (cluster.length) clusterIndex++;
+    const cols = colEnds.length;
+    for (const p of cluster) {
+      p.cols = cols;
+      let span = 1;
+      while (p.col + span < cols && !cluster.some((o) => o.col === p.col + span && o.startMin < p.end && p.startMin < o.end)) span++;
+      p.span = span;
+    }
+    cluster = [];
+    colEnds = [];
+  };
+  for (const s of sorted) {
+    if (s.startMin >= clusterEnd) {
+      flush();
+      clusterEnd = -Infinity;
+    }
+    let col = colEnds.findIndex((end) => end <= s.startMin);
+    if (col < 0) {
+      col = colEnds.length;
+      colEnds.push(0);
+    }
+    colEnds[col] = s.end;
+    const p = { ...s, col, cols: 1, span: 1, cluster: clusterIndex };
+    cluster.push(p);
+    out.push(p);
+    clusterEnd = Math.max(clusterEnd, s.end);
+  }
+  flush();
+  for (const p of out) delete p.end;
+  return out;
+}
+function layoutTimedDay(items, day, zone, minMinutes, order, window = [0, MINUTES_PER_DAY]) {
+  const plan = [];
+  const actual = [];
+  const background = [];
+  for (const n of items) {
+    const seg = segmentInWindow(n, day, window[0], window[1], zone);
+    if (!seg) continue;
+    if (n.item.display === "background") background.push(seg);
+    else if (n.item.lane === "actual") actual.push(seg);
+    else plan.push(seg);
+  }
+  return { day, plan: packTimed(plan, minMinutes, order), actual: packTimed(actual, minMinutes, order), background };
+}
+function layoutRow(items, days, order = defaultOrder) {
+  const first = days[0];
+  const last = days[days.length - 1];
+  const countByCol = new Array(days.length).fill(0);
+  if (first === void 0 || last === void 0) return { placements: [], countByCol, levels: 0 };
+  const colOf = (d) => {
+    let lo = 0;
+    let hi = days.length;
+    while (lo < hi) {
+      const mid = lo + hi >> 1;
+      if (days[mid] < d) lo = mid + 1;
+      else hi = mid;
+    }
+    return lo;
+  };
+  const sorted = items.filter((n) => n.startDay <= last && n.endDay > first).sort((a, b) => {
+    const sa = Math.max(a.startDay, first);
+    const sb = Math.max(b.startDay, first);
+    return sa - sb || b.endDay - b.startDay - (a.endDay - a.startDay) || order(a, b);
+  });
+  const levelEnds = [];
+  const placements = [];
+  for (const n of sorted) {
+    const startCol = colOf(n.startDay);
+    const endCol = colOf(n.endDay);
+    if (endCol <= startCol) continue;
+    let level = 0;
+    for (; ; level++) {
+      const occ = levelEnds[level] ??= [];
+      let free = true;
+      for (let c = startCol; c < endCol; c++) if (occ[c]) free = false;
+      if (free) {
+        for (let c = startCol; c < endCol; c++) occ[c] = 1;
+        break;
+      }
+    }
+    for (let c = startCol; c < endCol; c++) countByCol[c]++;
+    placements.push({
+      item: n,
+      startCol,
+      endCol,
+      level,
+      isStart: n.startDay >= days[startCol],
+      isEnd: n.endDay <= days[endCol - 1] + 1
+    });
+  }
+  return { placements, countByCol, levels: levelEnds.length };
+}
+function layoutLane(items, windowStart, windowEnd) {
+  const sorted = items.filter((n) => n.endMs > windowStart && n.startMs < windowEnd).sort((a, b) => a.startMs - b.startMs || b.endMs - a.endMs);
+  const levelEnds = [];
+  const bars = [];
+  for (const n of sorted) {
+    let level = levelEnds.findIndex((end) => end <= n.startMs);
+    if (level < 0) {
+      level = levelEnds.length;
+      levelEnds.push(0);
+    }
+    levelEnds[level] = Math.max(n.endMs, n.startMs + 1);
+    bars.push({
+      item: n,
+      startMs: Math.max(n.startMs, windowStart),
+      endMs: Math.min(n.endMs, windowEnd),
+      clippedStart: n.startMs < windowStart,
+      clippedEnd: n.endMs > windowEnd,
+      level
+    });
+  }
+  return { bars, levels: levelEnds.length };
+}
+
+// src/core/order.ts
+var BUILTIN = {
+  start: (n) => n.startMs,
+  end: (n) => n.endMs,
+  duration: (n) => n.endMs - n.startMs,
+  allDay: (n) => n.allDay ? 0 : 1,
+  title: (n) => n.item.title,
+  id: (n) => n.id
+};
+function compare(a, b) {
+  if (a === b) return 0;
+  if (a == null) return 1;
+  if (b == null) return -1;
+  if (typeof a === "number" && typeof b === "number") return a - b;
+  const str = (v) => typeof v === "string" ? v : JSON.stringify(v) ?? "";
+  return str(a).localeCompare(str(b));
+}
+function parseOrder(spec) {
+  if (typeof spec === "function") return spec;
+  const parts = (spec ?? "start,-duration,allDay,title").split(",").map((p) => p.trim()).filter(Boolean).map((p) => {
+    const desc = p.startsWith("-");
+    const name = desc ? p.slice(1) : p;
+    const field = BUILTIN[name] ?? ((n) => {
+      const own = n.item[name];
+      if (own !== void 0) return own;
+      const data = n.item.data;
+      return data && typeof data === "object" ? data[name] : void 0;
+    });
+    return { field, sign: desc ? -1 : 1 };
+  });
+  return (a, b) => {
+    for (const { field, sign } of parts) {
+      const c = compare(field(a), field(b));
+      if (c) return c * sign;
+    }
+    return 0;
+  };
+}
+
+// src/core/plan.ts
+function plannedMinutes(store, days) {
+  const zone = store.timeZone;
+  const out = /* @__PURE__ */ new Map();
+  for (const day of days) {
+    const start = toInstant(day, 0, zone);
+    const end = toInstant(day + 1, 0, zone);
+    let total = 0;
+    for (const n of store.timedOn(day)) {
+      if (n.item.display === "background" || n.item.lane === "actual") continue;
+      total += Math.max(0, Math.min(n.endMs, end) - Math.max(n.startMs, start)) / 6e4;
+    }
+    out.set(day, total);
+  }
+  return out;
+}
+function itemDependencies(item) {
+  return (item.dependsOn ?? []).map((d) => typeof d === "string" ? { id: d, type: "FS" } : { id: d.id, type: d.type ?? "FS" });
+}
+function dependencyType(fromEdge, toEdge) {
+  return `${fromEdge === "start" ? "S" : "F"}${toEdge === "start" ? "S" : "F"}`;
+}
+function dependencySatisfied(type, pred, succ) {
+  const from = type[0] === "S" ? pred.startMs : pred.endMs;
+  const to = type[1] === "S" ? succ.startMs : succ.endMs;
+  return from <= to;
+}
+function dependencyConflicts(store) {
+  const out = /* @__PURE__ */ new Map();
+  for (const n of store.all()) {
+    if (!n.item.dependsOn?.length) continue;
+    for (const dep of itemDependencies(n.item)) {
+      const d = store.get(dep.id);
+      if (!d || dependencySatisfied(dep.type, d, n)) continue;
+      const list = out.get(n.id) ?? [];
+      list.push(dep.id);
+      out.set(n.id, list);
+    }
+  }
+  return out;
+}
+function findFreeSlot(store, q) {
+  const zone = store.timeZone;
+  const snap = (q.snapMinutes ?? 15) * 6e4;
+  const need = q.durationMinutes * 6e4;
+  for (let day = q.fromDay; day < q.toDay; day++) {
+    if (q.skipDay?.(day)) continue;
+    const winStart = toInstant(day, q.window[0], zone);
+    const winEnd = toInstant(day, q.window[1], zone);
+    const busy = store.timedOn(day).filter((n) => n.item.display !== "background" && n.item.lane !== "actual" && !(q.ignore?.(n) ?? false)).map((n) => [n.startMs, n.endMs]).sort((a, b) => a[0] - b[0]);
+    let cursor = Math.max(winStart, q.notBefore ?? -Infinity);
+    cursor = Math.ceil(cursor / snap) * snap;
+    for (const [s, e] of busy) {
+      if (e <= cursor) continue;
+      if (s - cursor >= need && cursor + need <= winEnd) return { startMs: cursor, endMs: cursor + need };
+      cursor = Math.max(cursor, Math.ceil(e / snap) * snap);
+      if (cursor >= winEnd) break;
+    }
+    if (cursor + need <= winEnd) return { startMs: cursor, endMs: cursor + need };
+  }
+  return null;
+}
+
+export {
+  DAY_MS,
+  MINUTES_PER_DAY,
+  dayFromYMD,
+  ymdOfDay,
+  weekdayOf,
+  startOfWeek,
+  startOfMonth,
+  daysInMonth,
+  addMonths,
+  startOfYear,
+  formatDay,
+  parseDay,
+  isoWeekNumber,
+  parseDurationMinutes,
+  formatMinutes,
+  getTimeZone,
+  isValidTimeZone,
+  wallTime,
+  dayOf,
+  toInstant,
+  startOfDayInstant,
+  dayLengthMinutes,
+  parseDateInput,
+  formatFloating,
+  ItemStore,
+  daysOfRange,
+  segmentOn,
+  segmentInWindow,
+  defaultOrder,
+  packTimed,
+  layoutTimedDay,
+  layoutRow,
+  layoutLane,
+  parseOrder,
+  plannedMinutes,
+  itemDependencies,
+  dependencyType,
+  dependencySatisfied,
+  dependencyConflicts,
+  findFreeSlot
+};