stickyinc 0.5.2 → 0.6.0

package/dist/bundle/stickyinc-mcp.mjs

@@ -3575,24 +3575,24 @@ var require_fast_uri = __commonJS({
     function normalize(uri, options) {
       if (typeof uri === "string") {
         uri = /** @type {T} */
-        serialize(parse3(uri, options), options);
+        serialize(parse4(uri, options), options);
       } else if (typeof uri === "object") {
         uri = /** @type {T} */
-        parse3(serialize(uri, options), options);
+        parse4(serialize(uri, options), options);
       }
       return uri;
     }
     function resolve2(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
-      const resolved = resolveComponent(parse3(baseURI, schemelessOptions), parse3(relativeURI, schemelessOptions), schemelessOptions, true);
+      const resolved = resolveComponent(parse4(baseURI, schemelessOptions), parse4(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
       return serialize(resolved, schemelessOptions);
     }
     function resolveComponent(base, relative, options, skipNormalization) {
       const target = {};
       if (!skipNormalization) {
-        base = parse3(serialize(base, options), options);
-        relative = parse3(serialize(relative, options), options);
+        base = parse4(serialize(base, options), options);
+        relative = parse4(serialize(relative, options), options);
       }
       options = options || {};
       if (!options.tolerant && relative.scheme) {
@@ -3644,13 +3644,13 @@ var require_fast_uri = __commonJS({
     function equal(uriA, uriB, options) {
       if (typeof uriA === "string") {
         uriA = unescape(uriA);
-        uriA = serialize(normalizeComponentEncoding(parse3(uriA, options), true), { ...options, skipEscape: true });
+        uriA = serialize(normalizeComponentEncoding(parse4(uriA, options), true), { ...options, skipEscape: true });
       } else if (typeof uriA === "object") {
         uriA = serialize(normalizeComponentEncoding(uriA, true), { ...options, skipEscape: true });
       }
       if (typeof uriB === "string") {
         uriB = unescape(uriB);
-        uriB = serialize(normalizeComponentEncoding(parse3(uriB, options), true), { ...options, skipEscape: true });
+        uriB = serialize(normalizeComponentEncoding(parse4(uriB, options), true), { ...options, skipEscape: true });
       } else if (typeof uriB === "object") {
         uriB = serialize(normalizeComponentEncoding(uriB, true), { ...options, skipEscape: true });
       }
@@ -3719,7 +3719,7 @@ var require_fast_uri = __commonJS({
       return uriTokens.join("");
     }
     var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
-    function parse3(uri, opts) {
+    function parse4(uri, opts) {
       const options = Object.assign({}, opts);
       const parsed = {
         scheme: void 0,
@@ -3813,7 +3813,7 @@ var require_fast_uri = __commonJS({
       resolveComponent,
       equal,
       serialize,
-      parse: parse3
+      parse: parse4
     };
     module.exports = fastUri;
     module.exports.default = fastUri;
@@ -4224,7 +4224,7 @@ var require_core = __commonJS({
       errorsText(errors = this.errors, { separator = ", ", dataVar = "data" } = {}) {
         if (!errors || errors.length === 0)
           return "No errors";
-        return errors.map((e) => `${dataVar}${e.instancePath} ${e.message}`).reduce((text, msg) => text + separator + msg);
+        return errors.map((e) => `${dataVar}${e.instancePath} ${e.message}`).reduce((text2, msg) => text2 + separator + msg);
       }
       $dataMetaSchema(metaSchema, keywordsJsonPointers) {
         const rules = this.RULES.all;
@@ -21016,6 +21016,22 @@ import { mkdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { DatabaseSync } from "node:sqlite";
+
+// src/search.ts
+function searchWords(query) {
+  return query.match(/[\p{L}\p{N}]+/gu) ?? [];
+}
+function ftsQuery(words) {
+  return words.map((w) => `"${w}"*`).join(" ");
+}
+function toSqliteUtc(iso) {
+  return iso.replace("T", " ").replace(/(\.\d+)?Z$/, "");
+}
+function likeAnywhere(word) {
+  return `%${word.replace(/[\\%_]/g, "\\$&")}%`;
+}
+
+// src/db.ts
 function dbPath() {
   const override = process.env.STICKYINC_DB;
   if (!override) return join(homedir(), ".stickyinc", "tasks.db");
@@ -21044,203 +21060,3255 @@ db.exec(`
     created_at TEXT NOT NULL DEFAULT (datetime('now')),
     completed_at TEXT,
     due_at TEXT,
+    due_phrase TEXT,
     source TEXT NOT NULL DEFAULT 'claude',
-    fingerprint TEXT
+    fingerprint TEXT,
+    source_client TEXT,
+    source_ref TEXT,
+    source_excerpt TEXT
   );
   CREATE INDEX IF NOT EXISTS idx_tasks_completed ON tasks(completed_at);
   CREATE INDEX IF NOT EXISTS idx_tasks_due ON tasks(due_at);
 
-  CREATE TABLE IF NOT EXISTS meta (
-    key TEXT PRIMARY KEY,
-    value TEXT NOT NULL
-  );
+  CREATE TABLE IF NOT EXISTS meta (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS task_events (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    event_uuid TEXT NOT NULL UNIQUE,
+    task_uuid TEXT NOT NULL,
+    op TEXT NOT NULL CHECK (op IN ('create','complete','uncomplete','edit','delete')),
+    payload TEXT,
+    device_id TEXT NOT NULL,
+    ts TEXT NOT NULL DEFAULT (datetime('now')),
+    lamport INTEGER NOT NULL DEFAULT 0
+  );
+  CREATE INDEX IF NOT EXISTS idx_task_events_task ON task_events(task_uuid);
+  CREATE INDEX IF NOT EXISTS idx_task_events_lamport ON task_events(device_id, lamport);
+
+  -- User-defined routines: a named prompt, and a hint of when to run it
+  -- (StickyInc doesn't run them itself; see docs/routines.md).
+  CREATE TABLE IF NOT EXISTS routines (
+    name TEXT PRIMARY KEY,
+    prompt TEXT NOT NULL,
+    schedule TEXT,
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+`);
+{
+  const cols = db.prepare(`PRAGMA table_info(tasks)`).all();
+  if (!cols.some((c) => c.name === "fingerprint")) {
+    db.exec(`ALTER TABLE tasks ADD COLUMN fingerprint TEXT`);
+  }
+  if (!cols.some((c) => c.name === "uuid")) {
+    db.exec(`ALTER TABLE tasks ADD COLUMN uuid TEXT`);
+  }
+  if (!cols.some((c) => c.name === "due_phrase")) {
+    db.exec(`ALTER TABLE tasks ADD COLUMN due_phrase TEXT`);
+  }
+  for (const col of ["source_client", "source_ref", "source_excerpt"]) {
+    if (!cols.some((c) => c.name === col)) {
+      db.exec(`ALTER TABLE tasks ADD COLUMN ${col} TEXT`);
+    }
+  }
+  const pending = db.prepare(`SELECT id FROM tasks WHERE uuid IS NULL`).all();
+  if (pending.length > 0) {
+    const setUuid = db.prepare(`UPDATE tasks SET uuid = ? WHERE id = ?`);
+    inTransaction(() => {
+      for (const row of pending) setUuid.run(randomUUID(), row.id);
+    });
+  }
+}
+db.exec(`
+  CREATE INDEX IF NOT EXISTS idx_tasks_fingerprint ON tasks(fingerprint);
+  CREATE UNIQUE INDEX IF NOT EXISTS idx_tasks_uuid ON tasks(uuid);
+`);
+function ensureDeviceId() {
+  const row = db.prepare(`SELECT value FROM meta WHERE key = 'device_id'`).get();
+  if (row) return row.value;
+  const id = randomUUID();
+  db.prepare(
+    `INSERT OR IGNORE INTO meta (key, value) VALUES ('device_id', ?)`
+  ).run(id);
+  const final = db.prepare(`SELECT value FROM meta WHERE key = 'device_id'`).get();
+  return final.value;
+}
+var DEVICE_ID = ensureDeviceId();
+function nextLamport() {
+  const row = db.prepare(`SELECT MAX(lamport) as m FROM task_events WHERE device_id = ?`).get(DEVICE_ID);
+  return (row.m ?? 0) + 1;
+}
+var insertEventStmt = db.prepare(
+  `INSERT INTO task_events (event_uuid, task_uuid, op, payload, device_id, lamport)
+   VALUES (?, ?, ?, ?, ?, ?)`
+);
+function recordEvent(op, taskUuid, payload) {
+  insertEventStmt.run(
+    randomUUID(),
+    taskUuid,
+    op,
+    payload === null ? null : JSON.stringify(payload),
+    DEVICE_ID,
+    nextLamport()
+  );
+}
+var insertTaskStmt = db.prepare(
+  `INSERT INTO tasks (uuid, text, due_at, due_phrase, source, fingerprint,
+                      source_client, source_ref, source_excerpt)
+   VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING *`
+);
+var findOpenByFingerprintStmt = db.prepare(
+  `SELECT * FROM tasks WHERE fingerprint = ? AND completed_at IS NULL LIMIT 1`
+);
+var countDoneTodayStmt = db.prepare(
+  `SELECT COUNT(*) as n FROM tasks WHERE completed_at IS NOT NULL
+     AND date(completed_at, 'localtime') = date('now', 'localtime')`
+);
+var selectOpenStmt = db.prepare(
+  `SELECT * FROM tasks WHERE completed_at IS NULL ORDER BY
+     CASE WHEN due_at IS NULL THEN 1 ELSE 0 END, due_at ASC, created_at ASC`
+);
+var selectAllStmt = db.prepare(
+  `SELECT * FROM tasks ORDER BY created_at DESC LIMIT ?`
+);
+var selectRecentDoneStmt = db.prepare(
+  `SELECT * FROM tasks
+   WHERE completed_at IS NOT NULL
+     AND completed_at >= datetime('now', ?)
+   ORDER BY completed_at DESC`
+);
+var selectArchivedStmt = db.prepare(
+  `SELECT * FROM tasks
+   WHERE completed_at IS NOT NULL
+     AND completed_at < datetime('now', ?)
+   ORDER BY completed_at DESC
+   LIMIT ?`
+);
+var completeTaskFindStmt = db.prepare(
+  `SELECT uuid, completed_at FROM tasks WHERE id = ?`
+);
+var completeTaskUpdateStmt = db.prepare(
+  `UPDATE tasks SET completed_at = datetime('now') WHERE id = ? AND completed_at IS NULL`
+);
+var getTaskStmt = db.prepare(`SELECT * FROM tasks WHERE id = ?`);
+function fingerprint(text2) {
+  return createHash("sha256").update(text2.toLowerCase().replace(/\s+/g, " ").trim()).digest("hex").slice(0, 16);
+}
+function insertTask({ text: text2, due: due2 = null, source = "claude", from }) {
+  const taskUuid = randomUUID();
+  const row = {
+    due_at: due2?.at ?? null,
+    due_phrase: due2?.phrase ?? null,
+    source_client: from?.client ?? null,
+    source_ref: from?.ref ?? null,
+    source_excerpt: from?.excerpt ?? null
+  };
+  const task = insertTaskStmt.get(
+    taskUuid,
+    text2,
+    row.due_at,
+    row.due_phrase,
+    source,
+    fingerprint(text2),
+    row.source_client,
+    row.source_ref,
+    row.source_excerpt
+  );
+  recordEvent("create", taskUuid, { text: text2, ...row, due_ref: due2?.ref ?? null, source });
+  return task;
+}
+function addTaskUnique(t) {
+  return inTransaction(() => {
+    const existing = findOpenByFingerprintStmt.get(fingerprint(t.text));
+    if (existing) return { task: existing, inserted: false };
+    return { task: insertTask(t), inserted: true };
+  });
+}
+function countDoneToday() {
+  return countDoneTodayStmt.get().n;
+}
+function listOpenTasks() {
+  return selectOpenStmt.all();
+}
+function listAllTasks(limit = 50) {
+  return selectAllStmt.all(limit);
+}
+function listRecentlyCompleted(hoursAgo = 24) {
+  return selectRecentDoneStmt.all(`-${hoursAgo} hours`);
+}
+function listArchived(hoursAgo = 24, limit = 100) {
+  return selectArchivedStmt.all(`-${hoursAgo} hours`, limit);
+}
+function completeTask(id) {
+  return inTransaction(() => {
+    const prior = completeTaskFindStmt.get(id);
+    if (!prior) return null;
+    const completed = prior.completed_at === null;
+    if (completed) {
+      completeTaskUpdateStmt.run(id);
+      recordEvent("complete", prior.uuid, null);
+    }
+    return { task: getTaskStmt.get(id), completed };
+  });
+}
+var HAS_FTS5 = (() => {
+  try {
+    db.exec(
+      `CREATE VIRTUAL TABLE IF NOT EXISTS temp.task_search
+         USING fts5(text, excerpt, tokenize = 'unicode61 remove_diacritics 2')`
+    );
+    return true;
+  } catch {
+    return false;
+  }
+})();
+function searchTasks({
+  query = "",
+  status = "all",
+  since,
+  completedSince,
+  limit = 20
+}) {
+  const words = searchWords(query);
+  const where = [];
+  const params = [];
+  if (status === "open") where.push("t.completed_at IS NULL");
+  if (status === "done") where.push("t.completed_at IS NOT NULL");
+  if (since) {
+    where.push("t.created_at >= ?");
+    params.push(toSqliteUtc(since));
+  }
+  if (completedSince) {
+    where.push("t.completed_at >= ?");
+    params.push(toSqliteUtc(completedSince));
+  }
+  if (words.length > 0 && HAS_FTS5) {
+    db.exec(
+      `DELETE FROM temp.task_search;
+       INSERT INTO temp.task_search (rowid, text, excerpt)
+         SELECT id, text, source_excerpt FROM main.tasks;`
+    );
+    const filters2 = where.map((w) => ` AND ${w}`).join("");
+    return db.prepare(
+      `SELECT t.* FROM temp.task_search JOIN main.tasks t ON t.id = task_search.rowid
+         WHERE task_search MATCH ?${filters2}
+         ORDER BY task_search.rank LIMIT ?`
+    ).all(ftsQuery(words), ...params, limit);
+  }
+  for (const word of words) {
+    where.push(`(t.text LIKE ? ESCAPE '\\' OR t.source_excerpt LIKE ? ESCAPE '\\')`);
+    params.push(likeAnywhere(word), likeAnywhere(word));
+  }
+  const filters = where.length > 0 ? `WHERE ${where.join(" AND ")}` : "";
+  return db.prepare(`SELECT t.* FROM main.tasks t ${filters} ORDER BY t.created_at DESC, t.id DESC LIMIT ?`).all(...params, limit);
+}
+function listRoutines() {
+  return db.prepare(`SELECT * FROM routines ORDER BY name`).all();
+}
+function saveRoutine(r) {
+  return inTransaction(() => {
+    const existed = db.prepare(`SELECT 1 FROM routines WHERE name = ?`).get(r.name) !== void 0;
+    db.prepare(
+      `INSERT INTO routines (name, prompt, schedule, updated_at) VALUES (?, ?, ?, datetime('now'))
+       ON CONFLICT (name) DO UPDATE SET prompt = excluded.prompt, schedule = excluded.schedule,
+         updated_at = excluded.updated_at`
+    ).run(r.name, r.prompt, r.schedule ?? null);
+    return !existed;
+  });
+}
+function deleteRoutine(name) {
+  return Number(db.prepare(`DELETE FROM routines WHERE name = ?`).run(name).changes) > 0;
+}
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/types.js
+var Meridiem;
+(function(Meridiem2) {
+  Meridiem2[Meridiem2["AM"] = 0] = "AM";
+  Meridiem2[Meridiem2["PM"] = 1] = "PM";
+})(Meridiem || (Meridiem = {}));
+var Weekday;
+(function(Weekday2) {
+  Weekday2[Weekday2["SUNDAY"] = 0] = "SUNDAY";
+  Weekday2[Weekday2["MONDAY"] = 1] = "MONDAY";
+  Weekday2[Weekday2["TUESDAY"] = 2] = "TUESDAY";
+  Weekday2[Weekday2["WEDNESDAY"] = 3] = "WEDNESDAY";
+  Weekday2[Weekday2["THURSDAY"] = 4] = "THURSDAY";
+  Weekday2[Weekday2["FRIDAY"] = 5] = "FRIDAY";
+  Weekday2[Weekday2["SATURDAY"] = 6] = "SATURDAY";
+})(Weekday || (Weekday = {}));
+var Month;
+(function(Month2) {
+  Month2[Month2["JANUARY"] = 1] = "JANUARY";
+  Month2[Month2["FEBRUARY"] = 2] = "FEBRUARY";
+  Month2[Month2["MARCH"] = 3] = "MARCH";
+  Month2[Month2["APRIL"] = 4] = "APRIL";
+  Month2[Month2["MAY"] = 5] = "MAY";
+  Month2[Month2["JUNE"] = 6] = "JUNE";
+  Month2[Month2["JULY"] = 7] = "JULY";
+  Month2[Month2["AUGUST"] = 8] = "AUGUST";
+  Month2[Month2["SEPTEMBER"] = 9] = "SEPTEMBER";
+  Month2[Month2["OCTOBER"] = 10] = "OCTOBER";
+  Month2[Month2["NOVEMBER"] = 11] = "NOVEMBER";
+  Month2[Month2["DECEMBER"] = 12] = "DECEMBER";
+})(Month || (Month = {}));
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/utils/dates.js
+function assignSimilarDate(component, target) {
+  component.assign("day", target.getDate());
+  component.assign("month", target.getMonth() + 1);
+  component.assign("year", target.getFullYear());
+}
+function assignSimilarTime(component, target) {
+  component.assign("hour", target.getHours());
+  component.assign("minute", target.getMinutes());
+  component.assign("second", target.getSeconds());
+  component.assign("millisecond", target.getMilliseconds());
+  component.assign("meridiem", target.getHours() < 12 ? Meridiem.AM : Meridiem.PM);
+}
+function implySimilarDate(component, target) {
+  component.imply("day", target.getDate());
+  component.imply("month", target.getMonth() + 1);
+  component.imply("year", target.getFullYear());
+}
+function implySimilarTime(component, target) {
+  component.imply("hour", target.getHours());
+  component.imply("minute", target.getMinutes());
+  component.imply("second", target.getSeconds());
+  component.imply("millisecond", target.getMilliseconds());
+  component.imply("meridiem", target.getHours() < 12 ? Meridiem.AM : Meridiem.PM);
+}
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/timezone.js
+var TIMEZONE_ABBR_MAP = {
+  ACDT: 630,
+  ACST: 570,
+  ADT: -180,
+  AEDT: 660,
+  AEST: 600,
+  AFT: 270,
+  AKDT: -480,
+  AKST: -540,
+  ALMT: 360,
+  AMST: -180,
+  AMT: -240,
+  ANAST: 720,
+  ANAT: 720,
+  AQTT: 300,
+  ART: -180,
+  AST: -240,
+  AWDT: 540,
+  AWST: 480,
+  AZOST: 0,
+  AZOT: -60,
+  AZST: 300,
+  AZT: 240,
+  BNT: 480,
+  BOT: -240,
+  BRST: -120,
+  BRT: -180,
+  BST: 60,
+  BTT: 360,
+  CAST: 480,
+  CAT: 120,
+  CCT: 390,
+  CDT: -300,
+  CEST: 120,
+  CET: {
+    timezoneOffsetDuringDst: 2 * 60,
+    timezoneOffsetNonDst: 60,
+    dstStart: (year) => getLastWeekdayOfMonth(year, Month.MARCH, Weekday.SUNDAY, 2),
+    dstEnd: (year) => getLastWeekdayOfMonth(year, Month.OCTOBER, Weekday.SUNDAY, 3)
+  },
+  CHADT: 825,
+  CHAST: 765,
+  CKT: -600,
+  CLST: -180,
+  CLT: -240,
+  COT: -300,
+  CST: -360,
+  CT: {
+    timezoneOffsetDuringDst: -5 * 60,
+    timezoneOffsetNonDst: -6 * 60,
+    dstStart: (year) => getNthWeekdayOfMonth(year, Month.MARCH, Weekday.SUNDAY, 2, 2),
+    dstEnd: (year) => getNthWeekdayOfMonth(year, Month.NOVEMBER, Weekday.SUNDAY, 1, 2)
+  },
+  CVT: -60,
+  CXT: 420,
+  ChST: 600,
+  DAVT: 420,
+  EASST: -300,
+  EAST: -360,
+  EAT: 180,
+  ECT: -300,
+  EDT: -240,
+  EEST: 180,
+  EET: 120,
+  EGST: 0,
+  EGT: -60,
+  EST: -300,
+  ET: {
+    timezoneOffsetDuringDst: -4 * 60,
+    timezoneOffsetNonDst: -5 * 60,
+    dstStart: (year) => getNthWeekdayOfMonth(year, Month.MARCH, Weekday.SUNDAY, 2, 2),
+    dstEnd: (year) => getNthWeekdayOfMonth(year, Month.NOVEMBER, Weekday.SUNDAY, 1, 2)
+  },
+  FJST: 780,
+  FJT: 720,
+  FKST: -180,
+  FKT: -240,
+  FNT: -120,
+  GALT: -360,
+  GAMT: -540,
+  GET: 240,
+  GFT: -180,
+  GILT: 720,
+  GMT: 0,
+  GST: 240,
+  GYT: -240,
+  HAA: -180,
+  HAC: -300,
+  HADT: -540,
+  HAE: -240,
+  HAP: -420,
+  HAR: -360,
+  HAST: -600,
+  HAT: -90,
+  HAY: -480,
+  HKT: 480,
+  HLV: -210,
+  HNA: -240,
+  HNC: -360,
+  HNE: -300,
+  HNP: -480,
+  HNR: -420,
+  HNT: -150,
+  HNY: -540,
+  HOVT: 420,
+  ICT: 420,
+  IDT: 180,
+  IOT: 360,
+  IRDT: 270,
+  IRKST: 540,
+  IRKT: 540,
+  IRST: 210,
+  IST: 330,
+  JST: 540,
+  KGT: 360,
+  KRAST: 480,
+  KRAT: 480,
+  KST: 540,
+  KUYT: 240,
+  LHDT: 660,
+  LHST: 630,
+  LINT: 840,
+  MAGST: 720,
+  MAGT: 720,
+  MART: -510,
+  MAWT: 300,
+  MDT: -360,
+  MESZ: 120,
+  MEZ: 60,
+  MHT: 720,
+  MMT: 390,
+  MSD: 240,
+  MSK: 180,
+  MST: -420,
+  MT: {
+    timezoneOffsetDuringDst: -6 * 60,
+    timezoneOffsetNonDst: -7 * 60,
+    dstStart: (year) => getNthWeekdayOfMonth(year, Month.MARCH, Weekday.SUNDAY, 2, 2),
+    dstEnd: (year) => getNthWeekdayOfMonth(year, Month.NOVEMBER, Weekday.SUNDAY, 1, 2)
+  },
+  MUT: 240,
+  MVT: 300,
+  MYT: 480,
+  NCT: 660,
+  NDT: -90,
+  NFT: 690,
+  NOVST: 420,
+  NOVT: 360,
+  NPT: 345,
+  NST: -150,
+  NUT: -660,
+  NZDT: 780,
+  NZST: 720,
+  OMSST: 420,
+  OMST: 420,
+  PDT: -420,
+  PET: -300,
+  PETST: 720,
+  PETT: 720,
+  PGT: 600,
+  PHOT: 780,
+  PHT: 480,
+  PKT: 300,
+  PMDT: -120,
+  PMST: -180,
+  PONT: 660,
+  PST: -480,
+  PT: {
+    timezoneOffsetDuringDst: -7 * 60,
+    timezoneOffsetNonDst: -8 * 60,
+    dstStart: (year) => getNthWeekdayOfMonth(year, Month.MARCH, Weekday.SUNDAY, 2, 2),
+    dstEnd: (year) => getNthWeekdayOfMonth(year, Month.NOVEMBER, Weekday.SUNDAY, 1, 2)
+  },
+  PWT: 540,
+  PYST: -180,
+  PYT: -240,
+  RET: 240,
+  SAMT: 240,
+  SAST: 120,
+  SBT: 660,
+  SCT: 240,
+  SGT: 480,
+  SRT: -180,
+  SST: -660,
+  TAHT: -600,
+  TFT: 300,
+  TJT: 300,
+  TKT: 780,
+  TLT: 540,
+  TMT: 300,
+  TVT: 720,
+  ULAT: 480,
+  UTC: 0,
+  UYST: -120,
+  UYT: -180,
+  UZT: 300,
+  VET: -210,
+  VLAST: 660,
+  VLAT: 660,
+  VUT: 660,
+  WAST: 120,
+  WAT: 60,
+  WEST: 60,
+  WESZ: 60,
+  WET: 0,
+  WEZ: 0,
+  WFT: 720,
+  WGST: -120,
+  WGT: -180,
+  WIB: 420,
+  WIT: 540,
+  WITA: 480,
+  WST: 780,
+  WT: 0,
+  YAKST: 600,
+  YAKT: 600,
+  YAPT: 600,
+  YEKST: 360,
+  YEKT: 360
+};
+function getNthWeekdayOfMonth(year, month, weekday, n, hour = 0) {
+  let dayOfMonth = 0;
+  let i = 0;
+  while (i < n) {
+    dayOfMonth++;
+    const date3 = new Date(year, month - 1, dayOfMonth);
+    if (date3.getDay() === weekday)
+      i++;
+  }
+  return new Date(year, month - 1, dayOfMonth, hour);
+}
+function getLastWeekdayOfMonth(year, month, weekday, hour = 0) {
+  const oneIndexedWeekday = weekday === 0 ? 7 : weekday;
+  const date3 = new Date(year, month - 1 + 1, 1, 12);
+  const firstWeekdayNextMonth = date3.getDay() === 0 ? 7 : date3.getDay();
+  let dayDiff;
+  if (firstWeekdayNextMonth === oneIndexedWeekday)
+    dayDiff = 7;
+  else if (firstWeekdayNextMonth < oneIndexedWeekday)
+    dayDiff = 7 + firstWeekdayNextMonth - oneIndexedWeekday;
+  else
+    dayDiff = firstWeekdayNextMonth - oneIndexedWeekday;
+  date3.setDate(date3.getDate() - dayDiff);
+  return new Date(year, month - 1, date3.getDate(), hour);
+}
+function toTimezoneOffset(timezoneInput, date3, timezoneOverrides = {}) {
+  if (timezoneInput == null) {
+    return null;
+  }
+  if (typeof timezoneInput === "number") {
+    return timezoneInput;
+  }
+  const matchedTimezone = timezoneOverrides[timezoneInput] ?? TIMEZONE_ABBR_MAP[timezoneInput];
+  if (matchedTimezone == null) {
+    return null;
+  }
+  if (typeof matchedTimezone == "number") {
+    return matchedTimezone;
+  }
+  if (date3 == null) {
+    return null;
+  }
+  if (date3 > matchedTimezone.dstStart(date3.getFullYear()) && !(date3 > matchedTimezone.dstEnd(date3.getFullYear()))) {
+    return matchedTimezone.timezoneOffsetDuringDst;
+  }
+  return matchedTimezone.timezoneOffsetNonDst;
+}
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/calculation/duration.js
+var EmptyDuration = {
+  day: 0,
+  second: 0,
+  millisecond: 0
+};
+function addDuration(ref, duration3) {
+  let date3 = new Date(ref);
+  if (duration3["y"]) {
+    duration3["year"] = duration3["y"];
+    delete duration3["y"];
+  }
+  if (duration3["mo"]) {
+    duration3["month"] = duration3["mo"];
+    delete duration3["mo"];
+  }
+  if (duration3["M"]) {
+    duration3["month"] = duration3["M"];
+    delete duration3["M"];
+  }
+  if (duration3["w"]) {
+    duration3["week"] = duration3["w"];
+    delete duration3["w"];
+  }
+  if (duration3["d"]) {
+    duration3["day"] = duration3["d"];
+    delete duration3["d"];
+  }
+  if (duration3["h"]) {
+    duration3["hour"] = duration3["h"];
+    delete duration3["h"];
+  }
+  if (duration3["m"]) {
+    duration3["minute"] = duration3["m"];
+    delete duration3["m"];
+  }
+  if (duration3["s"]) {
+    duration3["second"] = duration3["s"];
+    delete duration3["s"];
+  }
+  if (duration3["ms"]) {
+    duration3["millisecond"] = duration3["ms"];
+    delete duration3["ms"];
+  }
+  if ("year" in duration3) {
+    const floor = Math.floor(duration3["year"]);
+    date3.setFullYear(date3.getFullYear() + floor);
+    const remainingFraction = duration3["year"] - floor;
+    if (remainingFraction > 0) {
+      duration3.month = duration3?.month ?? 0;
+      duration3.month += remainingFraction * 12;
+    }
+  }
+  if ("quarter" in duration3) {
+    const floor = Math.floor(duration3["quarter"]);
+    date3.setMonth(date3.getMonth() + floor * 3);
+  }
+  if ("month" in duration3) {
+    const floor = Math.floor(duration3["month"]);
+    date3.setMonth(date3.getMonth() + floor);
+    const remainingFraction = duration3["month"] - floor;
+    if (remainingFraction > 0) {
+      duration3.week = duration3?.week ?? 0;
+      duration3.week += remainingFraction * 4;
+    }
+  }
+  if ("week" in duration3) {
+    const floor = Math.floor(duration3["week"]);
+    date3.setDate(date3.getDate() + floor * 7);
+    const remainingFraction = duration3["week"] - floor;
+    if (remainingFraction > 0) {
+      duration3.day = duration3?.day ?? 0;
+      duration3.day += Math.round(remainingFraction * 7);
+    }
+  }
+  if ("day" in duration3) {
+    const floor = Math.floor(duration3["day"]);
+    date3.setDate(date3.getDate() + floor);
+    const remainingFraction = duration3["day"] - floor;
+    if (remainingFraction > 0) {
+      duration3.hour = duration3?.hour ?? 0;
+      duration3.hour += Math.round(remainingFraction * 24);
+    }
+  }
+  if ("hour" in duration3) {
+    const floor = Math.floor(duration3["hour"]);
+    date3.setHours(date3.getHours() + floor);
+    const remainingFraction = duration3["hour"] - floor;
+    if (remainingFraction > 0) {
+      duration3.minute = duration3?.minute ?? 0;
+      duration3.minute += Math.round(remainingFraction * 60);
+    }
+  }
+  if ("minute" in duration3) {
+    const floor = Math.floor(duration3["minute"]);
+    date3.setMinutes(date3.getMinutes() + floor);
+    const remainingFraction = duration3["minute"] - floor;
+    if (remainingFraction > 0) {
+      duration3.second = duration3?.second ?? 0;
+      duration3.second += Math.round(remainingFraction * 60);
+    }
+  }
+  if ("second" in duration3) {
+    const floor = Math.floor(duration3["second"]);
+    date3.setSeconds(date3.getSeconds() + floor);
+    const remainingFraction = duration3["second"] - floor;
+    if (remainingFraction > 0) {
+      duration3.millisecond = duration3?.millisecond ?? 0;
+      duration3.millisecond += Math.round(remainingFraction * 1e3);
+    }
+  }
+  if ("millisecond" in duration3) {
+    const floor = Math.floor(duration3["millisecond"]);
+    date3.setMilliseconds(date3.getMilliseconds() + floor);
+  }
+  return date3;
+}
+function reverseDuration(duration3) {
+  const reversed = {};
+  for (const key in duration3) {
+    reversed[key] = -duration3[key];
+  }
+  return reversed;
+}
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/results.js
+var ReferenceWithTimezone = class _ReferenceWithTimezone {
+  instant;
+  timezoneOffset;
+  constructor(instant, timezoneOffset) {
+    this.instant = instant ?? /* @__PURE__ */ new Date();
+    this.timezoneOffset = timezoneOffset ?? null;
+  }
+  static fromDate(date3) {
+    return new _ReferenceWithTimezone(date3);
+  }
+  static fromInput(input, timezoneOverrides) {
+    if (input instanceof Date) {
+      return _ReferenceWithTimezone.fromDate(input);
+    }
+    const instant = input?.instant ?? /* @__PURE__ */ new Date();
+    const timezoneOffset = toTimezoneOffset(input?.timezone, instant, timezoneOverrides);
+    return new _ReferenceWithTimezone(instant, timezoneOffset);
+  }
+  getDateWithAdjustedTimezone() {
+    const date3 = new Date(this.instant);
+    if (this.timezoneOffset !== null) {
+      date3.setMinutes(date3.getMinutes() - this.getSystemTimezoneAdjustmentMinute(this.instant));
+    }
+    return date3;
+  }
+  getSystemTimezoneAdjustmentMinute(date3, overrideTimezoneOffset) {
+    if (!date3) {
+      date3 = /* @__PURE__ */ new Date();
+    }
+    const currentTimezoneOffset = -date3.getTimezoneOffset();
+    const targetTimezoneOffset = overrideTimezoneOffset ?? this.timezoneOffset ?? currentTimezoneOffset;
+    return currentTimezoneOffset - targetTimezoneOffset;
+  }
+  getTimezoneOffset() {
+    return this.timezoneOffset ?? -this.instant.getTimezoneOffset();
+  }
+};
+var ParsingComponents = class _ParsingComponents {
+  knownValues;
+  impliedValues;
+  reference;
+  _tags = /* @__PURE__ */ new Set();
+  constructor(reference, knownComponents) {
+    this.reference = reference;
+    this.knownValues = {};
+    this.impliedValues = {};
+    if (knownComponents) {
+      for (const key in knownComponents) {
+        this.knownValues[key] = knownComponents[key];
+      }
+    }
+    const date3 = reference.getDateWithAdjustedTimezone();
+    this.imply("day", date3.getDate());
+    this.imply("month", date3.getMonth() + 1);
+    this.imply("year", date3.getFullYear());
+    this.imply("hour", 12);
+    this.imply("minute", 0);
+    this.imply("second", 0);
+    this.imply("millisecond", 0);
+  }
+  static createRelativeFromReference(reference, duration3 = EmptyDuration) {
+    let date3 = addDuration(reference.getDateWithAdjustedTimezone(), duration3);
+    const components = new _ParsingComponents(reference);
+    components.addTag("result/relativeDate");
+    if ("hour" in duration3 || "minute" in duration3 || "second" in duration3 || "millisecond" in duration3) {
+      components.addTag("result/relativeDateAndTime");
+      assignSimilarTime(components, date3);
+      assignSimilarDate(components, date3);
+      components.assign("timezoneOffset", reference.getTimezoneOffset());
+    } else {
+      implySimilarTime(components, date3);
+      components.imply("timezoneOffset", reference.getTimezoneOffset());
+      if ("day" in duration3) {
+        components.assign("day", date3.getDate());
+        components.assign("month", date3.getMonth() + 1);
+        components.assign("year", date3.getFullYear());
+        components.assign("weekday", date3.getDay());
+      } else if ("week" in duration3) {
+        components.assign("day", date3.getDate());
+        components.assign("month", date3.getMonth() + 1);
+        components.assign("year", date3.getFullYear());
+        components.imply("weekday", date3.getDay());
+      } else {
+        components.imply("day", date3.getDate());
+        if ("month" in duration3) {
+          components.assign("month", date3.getMonth() + 1);
+          components.assign("year", date3.getFullYear());
+        } else {
+          components.imply("month", date3.getMonth() + 1);
+          if ("year" in duration3) {
+            components.assign("year", date3.getFullYear());
+          } else {
+            components.imply("year", date3.getFullYear());
+          }
+        }
+      }
+    }
+    return components;
+  }
+  get(component) {
+    if (component in this.knownValues) {
+      return this.knownValues[component];
+    }
+    if (component in this.impliedValues) {
+      return this.impliedValues[component];
+    }
+    return null;
+  }
+  isCertain(component) {
+    return component in this.knownValues;
+  }
+  getCertainComponents() {
+    return Object.keys(this.knownValues);
+  }
+  imply(component, value) {
+    if (component in this.knownValues) {
+      return this;
+    }
+    this.impliedValues[component] = value;
+    return this;
+  }
+  assign(component, value) {
+    this.knownValues[component] = value;
+    delete this.impliedValues[component];
+    return this;
+  }
+  addDurationAsImplied(duration3) {
+    const currentDate = this.dateWithoutTimezoneAdjustment();
+    const date3 = addDuration(currentDate, duration3);
+    if ("day" in duration3 || "week" in duration3 || "month" in duration3 || "year" in duration3) {
+      this.delete(["day", "weekday", "month", "year"]);
+      this.imply("day", date3.getDate());
+      this.imply("weekday", date3.getDay());
+      this.imply("month", date3.getMonth() + 1);
+      this.imply("year", date3.getFullYear());
+    }
+    if ("second" in duration3 || "minute" in duration3 || "hour" in duration3) {
+      this.delete(["second", "minute", "hour"]);
+      this.imply("second", date3.getSeconds());
+      this.imply("minute", date3.getMinutes());
+      this.imply("hour", date3.getHours());
+    }
+    return this;
+  }
+  delete(components) {
+    if (typeof components === "string") {
+      components = [components];
+    }
+    for (const component of components) {
+      delete this.knownValues[component];
+      delete this.impliedValues[component];
+    }
+  }
+  clone() {
+    const component = new _ParsingComponents(this.reference);
+    component.knownValues = {};
+    component.impliedValues = {};
+    for (const key in this.knownValues) {
+      component.knownValues[key] = this.knownValues[key];
+    }
+    for (const key in this.impliedValues) {
+      component.impliedValues[key] = this.impliedValues[key];
+    }
+    return component;
+  }
+  isOnlyDate() {
+    return !this.isCertain("hour") && !this.isCertain("minute") && !this.isCertain("second");
+  }
+  isOnlyTime() {
+    return !this.isCertain("weekday") && !this.isCertain("day") && !this.isCertain("month") && !this.isCertain("year");
+  }
+  isOnlyWeekdayComponent() {
+    return this.isCertain("weekday") && !this.isCertain("day") && !this.isCertain("month");
+  }
+  isDateWithUnknownYear() {
+    return this.isCertain("month") && !this.isCertain("year");
+  }
+  isValidDate() {
+    const date3 = new Date(Date.UTC(this.get("year"), this.get("month") - 1, this.get("day"), this.get("hour"), this.get("minute"), this.get("second"), this.get("millisecond")));
+    date3.setUTCFullYear(this.get("year"));
+    if (date3.getUTCFullYear() !== this.get("year"))
+      return false;
+    if (date3.getUTCMonth() !== this.get("month") - 1)
+      return false;
+    if (date3.getUTCDate() !== this.get("day"))
+      return false;
+    if (this.get("hour") != null && date3.getUTCHours() != this.get("hour"))
+      return false;
+    if (this.get("minute") != null && date3.getUTCMinutes() != this.get("minute"))
+      return false;
+    return true;
+  }
+  toString() {
+    return `[ParsingComponents {
+            tags: ${JSON.stringify(Array.from(this._tags).sort())}, 
+            knownValues: ${JSON.stringify(this.knownValues)}, 
+            impliedValues: ${JSON.stringify(this.impliedValues)}}, 
+            reference: ${JSON.stringify(this.reference)}]`;
+  }
+  date() {
+    const timezoneOffset = this.get("timezoneOffset") ?? this.reference.timezoneOffset;
+    if (timezoneOffset === null || timezoneOffset === void 0) {
+      return this.dateWithoutTimezoneAdjustment();
+    }
+    const date3 = new Date(Date.UTC(this.get("year"), this.get("month") - 1, this.get("day"), this.get("hour"), this.get("minute"), this.get("second"), this.get("millisecond")));
+    date3.setUTCFullYear(this.get("year"));
+    return new Date(date3.getTime() - timezoneOffset * 6e4);
+  }
+  addTag(tag) {
+    this._tags.add(tag);
+    return this;
+  }
+  addTags(tags) {
+    for (const tag of tags) {
+      this._tags.add(tag);
+    }
+    return this;
+  }
+  tags() {
+    return new Set(this._tags);
+  }
+  dateWithoutTimezoneAdjustment() {
+    const date3 = new Date(this.get("year"), this.get("month") - 1, this.get("day"), this.get("hour"), this.get("minute"), this.get("second"), this.get("millisecond"));
+    date3.setFullYear(this.get("year"));
+    return date3;
+  }
+};
+var ParsingResult = class _ParsingResult {
+  refDate;
+  index;
+  text;
+  reference;
+  start;
+  end;
+  constructor(reference, index, text2, start, end) {
+    this.reference = reference;
+    this.refDate = reference.instant;
+    this.index = index;
+    this.text = text2;
+    this.start = start || new ParsingComponents(reference);
+    this.end = end;
+  }
+  clone() {
+    const result = new _ParsingResult(this.reference, this.index, this.text);
+    result.start = this.start ? this.start.clone() : null;
+    result.end = this.end ? this.end.clone() : null;
+    return result;
+  }
+  date() {
+    return this.start.date();
+  }
+  addTag(tag) {
+    this.start.addTag(tag);
+    if (this.end) {
+      this.end.addTag(tag);
+    }
+    return this;
+  }
+  addTags(tags) {
+    this.start.addTags(tags);
+    if (this.end) {
+      this.end.addTags(tags);
+    }
+    return this;
+  }
+  tags() {
+    const combinedTags = new Set(this.start.tags());
+    if (this.end) {
+      for (const tag of this.end.tags()) {
+        combinedTags.add(tag);
+      }
+    }
+    return combinedTags;
+  }
+  toString() {
+    const tags = Array.from(this.tags()).sort();
+    return `[ParsingResult {index: ${this.index}, text: '${this.text}', tags: ${JSON.stringify(tags)} ...}]`;
+  }
+};
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/utils/pattern.js
+function repeatedTimeunitPattern(prefix, singleTimeunitPattern, connectorPattern = "\\s{0,5},?\\s{0,5}") {
+  const singleTimeunitPatternNoCapture = singleTimeunitPattern.replace(/\((?!\?)/g, "(?:");
+  return `${prefix}${singleTimeunitPatternNoCapture}(?:${connectorPattern}${singleTimeunitPatternNoCapture}){0,10}`;
+}
+function extractTerms(dictionary) {
+  let keys;
+  if (dictionary instanceof Array) {
+    keys = [...dictionary];
+  } else if (dictionary instanceof Map) {
+    keys = Array.from(dictionary.keys());
+  } else {
+    keys = Object.keys(dictionary);
+  }
+  return keys;
+}
+function matchAnyPattern(dictionary) {
+  const joinedTerms = extractTerms(dictionary).sort((a, b) => b.length - a.length).join("|").replace(/\./g, "\\.");
+  return `(?:${joinedTerms})`;
+}
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/calculation/years.js
+function findMostLikelyADYear(yearNumber) {
+  if (yearNumber < 100) {
+    if (yearNumber > 50) {
+      yearNumber = yearNumber + 1900;
+    } else {
+      yearNumber = yearNumber + 2e3;
+    }
+  }
+  return yearNumber;
+}
+function findYearClosestToRef(refDate, day, month) {
+  let date3 = new Date(refDate);
+  date3.setMonth(month - 1);
+  date3.setDate(day);
+  const nextYear = addDuration(date3, { "year": 1 });
+  const lastYear = addDuration(date3, { "year": -1 });
+  if (Math.abs(nextYear.getTime() - refDate.getTime()) < Math.abs(date3.getTime() - refDate.getTime())) {
+    date3 = nextYear;
+  } else if (Math.abs(lastYear.getTime() - refDate.getTime()) < Math.abs(date3.getTime() - refDate.getTime())) {
+    date3 = lastYear;
+  }
+  return date3.getFullYear();
+}
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/locales/en/constants.js
+var WEEKDAY_DICTIONARY = {
+  sunday: 0,
+  sun: 0,
+  "sun.": 0,
+  monday: 1,
+  mon: 1,
+  "mon.": 1,
+  tuesday: 2,
+  tue: 2,
+  "tue.": 2,
+  wednesday: 3,
+  wed: 3,
+  "wed.": 3,
+  thursday: 4,
+  thurs: 4,
+  "thurs.": 4,
+  thur: 4,
+  "thur.": 4,
+  thu: 4,
+  "thu.": 4,
+  friday: 5,
+  fri: 5,
+  "fri.": 5,
+  saturday: 6,
+  sat: 6,
+  "sat.": 6
+};
+var FULL_MONTH_NAME_DICTIONARY = {
+  january: 1,
+  february: 2,
+  march: 3,
+  april: 4,
+  may: 5,
+  june: 6,
+  july: 7,
+  august: 8,
+  september: 9,
+  october: 10,
+  november: 11,
+  december: 12
+};
+var MONTH_DICTIONARY = {
+  ...FULL_MONTH_NAME_DICTIONARY,
+  jan: 1,
+  "jan.": 1,
+  feb: 2,
+  "feb.": 2,
+  mar: 3,
+  "mar.": 3,
+  apr: 4,
+  "apr.": 4,
+  jun: 6,
+  "jun.": 6,
+  jul: 7,
+  "jul.": 7,
+  aug: 8,
+  "aug.": 8,
+  sep: 9,
+  "sep.": 9,
+  sept: 9,
+  "sept.": 9,
+  oct: 10,
+  "oct.": 10,
+  nov: 11,
+  "nov.": 11,
+  dec: 12,
+  "dec.": 12
+};
+var INTEGER_WORD_DICTIONARY = {
+  one: 1,
+  two: 2,
+  three: 3,
+  four: 4,
+  five: 5,
+  six: 6,
+  seven: 7,
+  eight: 8,
+  nine: 9,
+  ten: 10,
+  eleven: 11,
+  twelve: 12
+};
+var ORDINAL_WORD_DICTIONARY = {
+  first: 1,
+  second: 2,
+  third: 3,
+  fourth: 4,
+  fifth: 5,
+  sixth: 6,
+  seventh: 7,
+  eighth: 8,
+  ninth: 9,
+  tenth: 10,
+  eleventh: 11,
+  twelfth: 12,
+  thirteenth: 13,
+  fourteenth: 14,
+  fifteenth: 15,
+  sixteenth: 16,
+  seventeenth: 17,
+  eighteenth: 18,
+  nineteenth: 19,
+  twentieth: 20,
+  "twenty first": 21,
+  "twenty-first": 21,
+  "twenty second": 22,
+  "twenty-second": 22,
+  "twenty third": 23,
+  "twenty-third": 23,
+  "twenty fourth": 24,
+  "twenty-fourth": 24,
+  "twenty fifth": 25,
+  "twenty-fifth": 25,
+  "twenty sixth": 26,
+  "twenty-sixth": 26,
+  "twenty seventh": 27,
+  "twenty-seventh": 27,
+  "twenty eighth": 28,
+  "twenty-eighth": 28,
+  "twenty ninth": 29,
+  "twenty-ninth": 29,
+  "thirtieth": 30,
+  "thirty first": 31,
+  "thirty-first": 31
+};
+var TIME_UNIT_DICTIONARY_NO_ABBR = {
+  second: "second",
+  seconds: "second",
+  minute: "minute",
+  minutes: "minute",
+  hour: "hour",
+  hours: "hour",
+  day: "day",
+  days: "day",
+  week: "week",
+  weeks: "week",
+  month: "month",
+  months: "month",
+  quarter: "quarter",
+  quarters: "quarter",
+  year: "year",
+  years: "year"
+};
+var TIME_UNIT_DICTIONARY = {
+  s: "second",
+  sec: "second",
+  second: "second",
+  seconds: "second",
+  m: "minute",
+  min: "minute",
+  mins: "minute",
+  minute: "minute",
+  minutes: "minute",
+  h: "hour",
+  hr: "hour",
+  hrs: "hour",
+  hour: "hour",
+  hours: "hour",
+  d: "day",
+  day: "day",
+  days: "day",
+  w: "week",
+  week: "week",
+  weeks: "week",
+  mo: "month",
+  mon: "month",
+  mos: "month",
+  month: "month",
+  months: "month",
+  qtr: "quarter",
+  quarter: "quarter",
+  quarters: "quarter",
+  y: "year",
+  yr: "year",
+  year: "year",
+  years: "year",
+  ...TIME_UNIT_DICTIONARY_NO_ABBR
+};
+var NUMBER_PATTERN = `(?:${matchAnyPattern(INTEGER_WORD_DICTIONARY)}|[0-9]+|[0-9]+\\.[0-9]+|half(?:\\s{0,2}an?)?|an?\\b(?:\\s{0,2}few)?|few|several|the|a?\\s{0,2}couple\\s{0,2}(?:of)?)`;
+function parseNumberPattern(match) {
+  const num = match.toLowerCase();
+  if (INTEGER_WORD_DICTIONARY[num] !== void 0) {
+    return INTEGER_WORD_DICTIONARY[num];
+  } else if (num === "a" || num === "an" || num == "the") {
+    return 1;
+  } else if (num.match(/few/)) {
+    return 3;
+  } else if (num.match(/half/)) {
+    return 0.5;
+  } else if (num.match(/couple/)) {
+    return 2;
+  } else if (num.match(/several/)) {
+    return 7;
+  }
+  return parseFloat(num);
+}
+var ORDINAL_NUMBER_PATTERN = `(?:${matchAnyPattern(ORDINAL_WORD_DICTIONARY)}|[0-9]{1,2}(?:st|nd|rd|th)?)`;
+function parseOrdinalNumberPattern(match) {
+  let num = match.toLowerCase();
+  if (ORDINAL_WORD_DICTIONARY[num] !== void 0) {
+    return ORDINAL_WORD_DICTIONARY[num];
+  }
+  num = num.replace(/(?:st|nd|rd|th)$/i, "");
+  return parseInt(num);
+}
+var YEAR_PATTERN = `(?:[1-9][0-9]{0,3}\\s{0,2}(?:BE|AD|BC|BCE|CE)|[1-9][0-9]{3}|[0-9]{2}(?!\\w|:\\d|\\s+(?:am|pm|o\\s*clock|jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)))`;
+function parseYear(match) {
+  if (/BE/i.test(match)) {
+    match = match.replace(/BE/i, "");
+    return parseInt(match) - 543;
+  }
+  if (/BCE?/i.test(match)) {
+    match = match.replace(/BCE?/i, "");
+    return -parseInt(match);
+  }
+  if (/(AD|CE)/i.test(match)) {
+    match = match.replace(/(AD|CE)/i, "");
+    return parseInt(match);
+  }
+  const rawYearNumber = parseInt(match);
+  return findMostLikelyADYear(rawYearNumber);
+}
+var SINGLE_TIME_UNIT_PATTERN = `(${NUMBER_PATTERN})\\s{0,3}(${matchAnyPattern(TIME_UNIT_DICTIONARY)})`;
+var SINGLE_TIME_UNIT_REGEX = new RegExp(SINGLE_TIME_UNIT_PATTERN, "i");
+var SINGLE_TIME_UNIT_NO_ABBR_PATTERN = `(${NUMBER_PATTERN})\\s{0,3}(${matchAnyPattern(TIME_UNIT_DICTIONARY_NO_ABBR)})`;
+var TIME_UNIT_CONNECTOR_PATTERN = `\\s{0,5},?(?:\\s*and)?\\s{0,5}`;
+var TIME_UNITS_PATTERN = repeatedTimeunitPattern(`(?:(?:about|around)\\s{0,3})?`, SINGLE_TIME_UNIT_PATTERN, TIME_UNIT_CONNECTOR_PATTERN);
+var TIME_UNITS_NO_ABBR_PATTERN = repeatedTimeunitPattern(`(?:(?:about|around)\\s{0,3})?`, SINGLE_TIME_UNIT_NO_ABBR_PATTERN, TIME_UNIT_CONNECTOR_PATTERN);
+function parseDuration(timeunitText) {
+  const fragments = {};
+  let remainingText = timeunitText;
+  let match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);
+  while (match) {
+    collectDateTimeFragment(fragments, match);
+    remainingText = remainingText.substring(match[0].length).trim();
+    match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);
+  }
+  if (Object.keys(fragments).length == 0) {
+    return null;
+  }
+  return fragments;
+}
+function collectDateTimeFragment(fragments, match) {
+  if (match[0].match(/^[a-zA-Z]+$/)) {
+    return;
+  }
+  const num = parseNumberPattern(match[1]);
+  const unit = TIME_UNIT_DICTIONARY[match[2].toLowerCase()];
+  fragments[unit] = num;
+}
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/common/parsers/AbstractParserWithWordBoundary.js
+var AbstractParserWithWordBoundaryChecking = class {
+  innerPatternHasChange(context, currentInnerPattern) {
+    return this.innerPattern(context) !== currentInnerPattern;
+  }
+  patternLeftBoundary() {
+    return `(\\W|^)`;
+  }
+  cachedInnerPattern = null;
+  cachedPattern = null;
+  pattern(context) {
+    if (this.cachedInnerPattern) {
+      if (!this.innerPatternHasChange(context, this.cachedInnerPattern)) {
+        return this.cachedPattern;
+      }
+    }
+    this.cachedInnerPattern = this.innerPattern(context);
+    this.cachedPattern = new RegExp(`${this.patternLeftBoundary()}${this.cachedInnerPattern.source}`, this.cachedInnerPattern.flags);
+    return this.cachedPattern;
+  }
+  extract(context, match) {
+    const header = match[1] ?? "";
+    match.index = match.index + header.length;
+    match[0] = match[0].substring(header.length);
+    for (let i = 2; i < match.length; i++) {
+      match[i - 1] = match[i];
+    }
+    return this.innerExtract(context, match);
+  }
+};
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/locales/en/parsers/ENTimeUnitWithinFormatParser.js
+var PATTERN_WITH_OPTIONAL_PREFIX = new RegExp(`(?:(?:within|in|for)\\s*)?(?:(?:about|around|roughly|approximately|just)\\s*(?:~\\s*)?)?(${TIME_UNITS_PATTERN})(?=\\W|$)`, "i");
+var PATTERN_WITH_PREFIX = new RegExp(`(?:within|in|for)\\s*(?:(?:about|around|roughly|approximately|just)\\s*(?:~\\s*)?)?(${TIME_UNITS_PATTERN})(?=\\W|$)`, "i");
+var PATTERN_WITH_PREFIX_STRICT = new RegExp(`(?:within|in|for)\\s*(?:(?:about|around|roughly|approximately|just)\\s*(?:~\\s*)?)?(${TIME_UNITS_NO_ABBR_PATTERN})(?=\\W|$)`, "i");
+var ENTimeUnitWithinFormatParser = class extends AbstractParserWithWordBoundaryChecking {
+  strictMode;
+  constructor(strictMode) {
+    super();
+    this.strictMode = strictMode;
+  }
+  innerPattern(context) {
+    if (this.strictMode) {
+      return PATTERN_WITH_PREFIX_STRICT;
+    }
+    return context.option.forwardDate ? PATTERN_WITH_OPTIONAL_PREFIX : PATTERN_WITH_PREFIX;
+  }
+  innerExtract(context, match) {
+    if (match[0].match(/^for\s*the\s*\w+/)) {
+      return null;
+    }
+    const timeUnits = parseDuration(match[1]);
+    if (!timeUnits) {
+      return null;
+    }
+    return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+  }
+};
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/locales/en/parsers/ENMonthNameLittleEndianParser.js
+var PATTERN = new RegExp(`(?:on\\s{0,3})?(${ORDINAL_NUMBER_PATTERN})(?:\\s{0,3}(?:to|\\-|\\\u2013|until|through|till)\\s{0,3}(${ORDINAL_NUMBER_PATTERN}))?(?:-|/|\\s{0,3}(?:of)?\\s{0,3})(${matchAnyPattern(MONTH_DICTIONARY)})(?:(?:-|/|,?\\s{0,3})(${YEAR_PATTERN}(?!\\w)))?(?=\\W|$)`, "i");
+var DATE_GROUP = 1;
+var DATE_TO_GROUP = 2;
+var MONTH_NAME_GROUP = 3;
+var YEAR_GROUP = 4;
+var ENMonthNameLittleEndianParser = class extends AbstractParserWithWordBoundaryChecking {
+  innerPattern() {
+    return PATTERN;
+  }
+  innerExtract(context, match) {
+    const result = context.createParsingResult(match.index, match[0]);
+    const month = MONTH_DICTIONARY[match[MONTH_NAME_GROUP].toLowerCase()];
+    const day = parseOrdinalNumberPattern(match[DATE_GROUP]);
+    if (day > 31) {
+      match.index = match.index + match[DATE_GROUP].length;
+      return null;
+    }
+    result.start.assign("month", month);
+    result.start.assign("day", day);
+    if (match[YEAR_GROUP]) {
+      const yearNumber = parseYear(match[YEAR_GROUP]);
+      result.start.assign("year", yearNumber);
+    } else {
+      const year = findYearClosestToRef(context.refDate, day, month);
+      result.start.imply("year", year);
+    }
+    if (match[DATE_TO_GROUP]) {
+      const endDate = parseOrdinalNumberPattern(match[DATE_TO_GROUP]);
+      result.end = result.start.clone();
+      result.end.assign("day", endDate);
+    }
+    return result;
+  }
+};
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/locales/en/parsers/ENMonthNameMiddleEndianParser.js
+var PATTERN2 = new RegExp(`(${matchAnyPattern(MONTH_DICTIONARY)})(?:-|/|\\s*,?\\s*)(${ORDINAL_NUMBER_PATTERN})(?!\\s*(?:am|pm))\\s*(?:(?:to|\\-)\\s*(${ORDINAL_NUMBER_PATTERN})\\s*)?(?:(?:-|/|\\s*,\\s*|\\s+)(${YEAR_PATTERN}))?(?=\\W|$)(?!\\:\\d)`, "i");
+var MONTH_NAME_GROUP2 = 1;
+var DATE_GROUP2 = 2;
+var DATE_TO_GROUP2 = 3;
+var YEAR_GROUP2 = 4;
+var ENMonthNameMiddleEndianParser = class extends AbstractParserWithWordBoundaryChecking {
+  shouldSkipYearLikeDate;
+  constructor(shouldSkipYearLikeDate) {
+    super();
+    this.shouldSkipYearLikeDate = shouldSkipYearLikeDate;
+  }
+  innerPattern() {
+    return PATTERN2;
+  }
+  innerExtract(context, match) {
+    const month = MONTH_DICTIONARY[match[MONTH_NAME_GROUP2].toLowerCase()];
+    const day = parseOrdinalNumberPattern(match[DATE_GROUP2]);
+    if (day > 31) {
+      return null;
+    }
+    if (this.shouldSkipYearLikeDate) {
+      if (!match[DATE_TO_GROUP2] && !match[YEAR_GROUP2] && match[DATE_GROUP2].match(/^\d{2}$/)) {
+        return null;
+      }
+    }
+    const components = context.createParsingComponents({
+      day,
+      month
+    }).addTag("parser/ENMonthNameMiddleEndianParser");
+    if (match[YEAR_GROUP2]) {
+      const year = parseYear(match[YEAR_GROUP2]);
+      components.assign("year", year);
+    } else {
+      const year = findYearClosestToRef(context.refDate, day, month);
+      components.imply("year", year);
+    }
+    if (!match[DATE_TO_GROUP2]) {
+      return components;
+    }
+    const endDate = parseOrdinalNumberPattern(match[DATE_TO_GROUP2]);
+    const result = context.createParsingResult(match.index, match[0]);
+    result.start = components;
+    result.end = components.clone();
+    result.end.assign("day", endDate);
+    return result;
+  }
+};
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/locales/en/parsers/ENMonthNameParser.js
+var PATTERN3 = new RegExp(`((?:in)\\s*)?(${matchAnyPattern(MONTH_DICTIONARY)})\\s*(?:(?:,|-|of)?\\s*(${YEAR_PATTERN})?)?(?=[^\\s\\w]|\\s+[^0-9]|\\s+$|$)`, "i");
+var PREFIX_GROUP = 1;
+var MONTH_NAME_GROUP3 = 2;
+var YEAR_GROUP3 = 3;
+var ENMonthNameParser = class extends AbstractParserWithWordBoundaryChecking {
+  innerPattern() {
+    return PATTERN3;
+  }
+  innerExtract(context, match) {
+    const monthName = match[MONTH_NAME_GROUP3].toLowerCase();
+    if (match[0].length <= 3 && !FULL_MONTH_NAME_DICTIONARY[monthName]) {
+      return null;
+    }
+    const result = context.createParsingResult(match.index + (match[PREFIX_GROUP] || "").length, match.index + match[0].length);
+    result.start.imply("day", 1);
+    result.start.addTag("parser/ENMonthNameParser");
+    const month = MONTH_DICTIONARY[monthName];
+    result.start.assign("month", month);
+    if (match[YEAR_GROUP3]) {
+      const year = parseYear(match[YEAR_GROUP3]);
+      result.start.assign("year", year);
+    } else {
+      const year = findYearClosestToRef(context.refDate, 1, month);
+      result.start.imply("year", year);
+    }
+    return result;
+  }
+};
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/locales/en/parsers/ENYearMonthDayParser.js
+var PATTERN4 = new RegExp(`([0-9]{4})[-\\.\\/\\s](?:(${matchAnyPattern(MONTH_DICTIONARY)})|([0-9]{1,2}))[-\\.\\/\\s]([0-9]{1,2})(?=\\W|$)`, "i");
+var YEAR_NUMBER_GROUP = 1;
+var MONTH_NAME_GROUP4 = 2;
+var MONTH_NUMBER_GROUP = 3;
+var DATE_NUMBER_GROUP = 4;
+var ENYearMonthDayParser = class extends AbstractParserWithWordBoundaryChecking {
+  strictMonthDateOrder;
+  constructor(strictMonthDateOrder) {
+    super();
+    this.strictMonthDateOrder = strictMonthDateOrder;
+  }
+  innerPattern() {
+    return PATTERN4;
+  }
+  innerExtract(context, match) {
+    const year = parseInt(match[YEAR_NUMBER_GROUP]);
+    let day = parseInt(match[DATE_NUMBER_GROUP]);
+    let month = match[MONTH_NUMBER_GROUP] ? parseInt(match[MONTH_NUMBER_GROUP]) : MONTH_DICTIONARY[match[MONTH_NAME_GROUP4].toLowerCase()];
+    if (month < 1 || month > 12) {
+      if (this.strictMonthDateOrder) {
+        return null;
+      }
+      if (day >= 1 && day <= 12) {
+        [month, day] = [day, month];
+      }
+    }
+    if (day < 1 || day > 31) {
+      return null;
+    }
+    return {
+      day,
+      month,
+      year
+    };
+  }
+};
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/locales/en/parsers/ENYearMonthNameParser.js
+var YEAR_PATTERN2 = `(?:[1-9][0-9]{0,3}\\s{0,2}(?:BE|AD|BC|BCE|CE)|[1-9][0-9]{3})`;
+var PATTERN5 = new RegExp(`(${YEAR_PATTERN2})(?:\\s*[-.\\/,]?\\s*|\\s+of\\s+)(${matchAnyPattern(MONTH_DICTIONARY)})(?=[^\\s\\w]|\\s+[^0-9]|\\s+$|$)`, "i");
+var YEAR_GROUP4 = 1;
+var MONTH_NAME_GROUP5 = 2;
+var ENYearMonthNameParser = class extends AbstractParserWithWordBoundaryChecking {
+  innerPattern() {
+    return PATTERN5;
+  }
+  innerExtract(context, match) {
+    const year = parseYear(match[YEAR_GROUP4]);
+    const monthName = match[MONTH_NAME_GROUP5].toLowerCase();
+    const month = MONTH_DICTIONARY[monthName];
+    const result = context.createParsingResult(match.index, match[0]);
+    result.start.imply("day", 1);
+    result.start.assign("month", month);
+    result.start.assign("year", year);
+    result.start.addTag("parser/ENYearMonthNameParser");
+    return result;
+  }
+};
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/locales/en/parsers/ENSlashMonthFormatParser.js
+var PATTERN6 = new RegExp("([0-9]|0[1-9]|1[012])/([0-9]{4})", "i");
+var MONTH_GROUP = 1;
+var YEAR_GROUP5 = 2;
+var ENSlashMonthFormatParser = class extends AbstractParserWithWordBoundaryChecking {
+  innerPattern() {
+    return PATTERN6;
+  }
+  innerExtract(context, match) {
+    const year = parseInt(match[YEAR_GROUP5]);
+    const month = parseInt(match[MONTH_GROUP]);
+    return context.createParsingComponents().imply("day", 1).assign("month", month).assign("year", year);
+  }
+};
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/common/parsers/AbstractTimeExpressionParser.js
+function primaryTimePattern(leftBoundary, primaryPrefix, primarySuffix, flags) {
+  return new RegExp(`${leftBoundary}${primaryPrefix}(\\d{1,4})(?:(?:\\.|:|\uFF1A)(\\d{1,2})(?:(?::|\uFF1A)(\\d{2})(?:\\.(\\d{1,6}))?)?)?(?:\\s*(a\\.m\\.|p\\.m\\.|am?|pm?))?${primarySuffix}`, flags);
+}
+function followingTimePatten(followingPhase, followingSuffix) {
+  return new RegExp(`^(${followingPhase})(\\d{1,4})(?:(?:\\.|\\:|\\\uFF1A)(\\d{1,2})(?:(?:\\.|\\:|\\\uFF1A)(\\d{1,2})(?:\\.(\\d{1,6}))?)?)?(?:\\s*(a\\.m\\.|p\\.m\\.|am?|pm?))?${followingSuffix}`, "i");
+}
+var HOUR_GROUP = 2;
+var MINUTE_GROUP = 3;
+var SECOND_GROUP = 4;
+var MILLI_SECOND_GROUP = 5;
+var AM_PM_HOUR_GROUP = 6;
+var AbstractTimeExpressionParser = class {
+  strictMode;
+  constructor(strictMode = false) {
+    this.strictMode = strictMode;
+  }
+  patternFlags() {
+    return "i";
+  }
+  primaryPatternLeftBoundary() {
+    return `(^|\\s|T|\\b)`;
+  }
+  primarySuffix() {
+    return `(?!/)(?=\\W|$)`;
+  }
+  followingSuffix() {
+    return `(?!/)(?=\\W|$)`;
+  }
+  pattern(context) {
+    return this.getPrimaryTimePatternThroughCache();
+  }
+  extract(context, match) {
+    const startComponents = this.extractPrimaryTimeComponents(context, match);
+    if (!startComponents) {
+      if (match[0].match(/^\d{4}/)) {
+        match.index += 4;
+        return null;
+      }
+      match.index += match[0].length;
+      return null;
+    }
+    const index = match.index + match[1].length;
+    const text2 = match[0].substring(match[1].length);
+    const result = context.createParsingResult(index, text2, startComponents);
+    match.index += match[0].length;
+    const remainingText = context.text.substring(match.index);
+    const followingPattern = this.getFollowingTimePatternThroughCache();
+    const followingMatch = followingPattern.exec(remainingText);
+    if (text2.match(/^\d{3,4}/) && followingMatch) {
+      if (followingMatch[0].match(/^\s*([+-])\s*\d{2,4}$/)) {
+        return null;
+      }
+      if (followingMatch[0].match(/^\s*([+-])\s*\d{2}\W\d{2}/)) {
+        return null;
+      }
+    }
+    if (!followingMatch || followingMatch[0].match(/^\s*([+-])\s*\d{3,4}$/)) {
+      return this.checkAndReturnWithoutFollowingPattern(result);
+    }
+    result.end = this.extractFollowingTimeComponents(context, followingMatch, result);
+    if (result.end) {
+      result.text += followingMatch[0];
+    }
+    return this.checkAndReturnWithFollowingPattern(result);
+  }
+  extractPrimaryTimeComponents(context, match, strict2 = false) {
+    const components = context.createParsingComponents();
+    let minute = 0;
+    let meridiem = null;
+    let hour = parseInt(match[HOUR_GROUP]);
+    if (hour > 100) {
+      if (match[HOUR_GROUP].length == 4 && match[MINUTE_GROUP] == null && !match[AM_PM_HOUR_GROUP]) {
+        return null;
+      }
+      if (this.strictMode || match[MINUTE_GROUP] != null) {
+        return null;
+      }
+      minute = hour % 100;
+      hour = Math.floor(hour / 100);
+    }
+    if (hour > 24) {
+      return null;
+    }
+    if (match[MINUTE_GROUP] != null) {
+      if (match[MINUTE_GROUP].length == 1 && !match[AM_PM_HOUR_GROUP]) {
+        return null;
+      }
+      minute = parseInt(match[MINUTE_GROUP]);
+    }
+    if (minute >= 60) {
+      return null;
+    }
+    if (hour > 12) {
+      meridiem = Meridiem.PM;
+    }
+    if (match[AM_PM_HOUR_GROUP] != null) {
+      if (hour > 12)
+        return null;
+      const ampm = match[AM_PM_HOUR_GROUP][0].toLowerCase();
+      if (ampm == "a") {
+        meridiem = Meridiem.AM;
+        if (hour == 12) {
+          hour = 0;
+        }
+      }
+      if (ampm == "p") {
+        meridiem = Meridiem.PM;
+        if (hour != 12) {
+          hour += 12;
+        }
+      }
+    }
+    components.assign("hour", hour);
+    components.assign("minute", minute);
+    if (meridiem !== null) {
+      components.assign("meridiem", meridiem);
+    } else {
+      if (hour < 12) {
+        components.imply("meridiem", Meridiem.AM);
+      } else {
+        components.imply("meridiem", Meridiem.PM);
+      }
+    }
+    if (match[MILLI_SECOND_GROUP] != null) {
+      const millisecond = parseInt(match[MILLI_SECOND_GROUP].substring(0, 3));
+      if (millisecond >= 1e3)
+        return null;
+      components.assign("millisecond", millisecond);
+    }
+    if (match[SECOND_GROUP] != null) {
+      const second = parseInt(match[SECOND_GROUP]);
+      if (second >= 60)
+        return null;
+      components.assign("second", second);
+    }
+    return components;
+  }
+  extractFollowingTimeComponents(context, match, result) {
+    const components = context.createParsingComponents();
+    if (match[MILLI_SECOND_GROUP] != null) {
+      const millisecond = parseInt(match[MILLI_SECOND_GROUP].substring(0, 3));
+      if (millisecond >= 1e3)
+        return null;
+      components.assign("millisecond", millisecond);
+    }
+    if (match[SECOND_GROUP] != null) {
+      const second = parseInt(match[SECOND_GROUP]);
+      if (second >= 60)
+        return null;
+      components.assign("second", second);
+    }
+    let hour = parseInt(match[HOUR_GROUP]);
+    let minute = 0;
+    let meridiem = -1;
+    if (match[MINUTE_GROUP] != null) {
+      minute = parseInt(match[MINUTE_GROUP]);
+    } else if (hour > 100) {
+      minute = hour % 100;
+      hour = Math.floor(hour / 100);
+    }
+    if (minute >= 60 || hour > 24) {
+      return null;
+    }
+    if (hour >= 12) {
+      meridiem = Meridiem.PM;
+    }
+    if (match[AM_PM_HOUR_GROUP] != null) {
+      if (hour > 12) {
+        return null;
+      }
+      const ampm = match[AM_PM_HOUR_GROUP][0].toLowerCase();
+      if (ampm == "a") {
+        meridiem = Meridiem.AM;
+        if (hour == 12) {
+          hour = 0;
+          if (!components.isCertain("day")) {
+            components.imply("day", components.get("day") + 1);
+          }
+        }
+      }
+      if (ampm == "p") {
+        meridiem = Meridiem.PM;
+        if (hour != 12)
+          hour += 12;
+      }
+      if (!result.start.isCertain("meridiem")) {
+        if (meridiem == Meridiem.AM) {
+          result.start.imply("meridiem", Meridiem.AM);
+          if (result.start.get("hour") == 12) {
+            result.start.assign("hour", 0);
+          }
+        } else {
+          result.start.imply("meridiem", Meridiem.PM);
+          if (result.start.get("hour") != 12) {
+            result.start.assign("hour", result.start.get("hour") + 12);
+          }
+        }
+      }
+    }
+    components.assign("hour", hour);
+    components.assign("minute", minute);
+    if (meridiem >= 0) {
+      components.assign("meridiem", meridiem);
+    } else {
+      const startAtPM = result.start.isCertain("meridiem") && result.start.get("hour") > 12;
+      if (startAtPM) {
+        if (result.start.get("hour") - 12 > hour) {
+          components.imply("meridiem", Meridiem.AM);
+        } else if (hour <= 12) {
+          components.assign("hour", hour + 12);
+          components.assign("meridiem", Meridiem.PM);
+        }
+      } else if (hour > 12) {
+        components.imply("meridiem", Meridiem.PM);
+      } else if (hour <= 12) {
+        components.imply("meridiem", Meridiem.AM);
+      }
+    }
+    if (components.date().getTime() < result.start.date().getTime()) {
+      components.imply("day", components.get("day") + 1);
+    }
+    return components;
+  }
+  checkAndReturnWithoutFollowingPattern(result) {
+    if (result.text.match(/^\d$/)) {
+      return null;
+    }
+    if (result.text.match(/^\d\d\d+$/)) {
+      return null;
+    }
+    if (result.text.match(/\d[apAP]$/)) {
+      return null;
+    }
+    const endingWithNumbers = result.text.match(/[^\d:.](\d[\d.]+)$/);
+    if (endingWithNumbers) {
+      const endingNumbers = endingWithNumbers[1];
+      if (this.strictMode) {
+        return null;
+      }
+      if (endingNumbers.includes(".") && !endingNumbers.match(/\d(\.\d{2})+$/)) {
+        return null;
+      }
+      const endingNumberVal = parseInt(endingNumbers);
+      if (endingNumberVal > 24) {
+        return null;
+      }
+    }
+    return result;
+  }
+  checkAndReturnWithFollowingPattern(result) {
+    if (result.text.match(/^\d+-\d+$/)) {
+      return null;
+    }
+    const endingWithNumbers = result.text.match(/[^\d:.](\d[\d.]+)\s*-\s*(\d[\d.]+)$/);
+    if (endingWithNumbers) {
+      if (this.strictMode) {
+        return null;
+      }
+      const startingNumbers = endingWithNumbers[1];
+      const endingNumbers = endingWithNumbers[2];
+      if (endingNumbers.includes(".") && !endingNumbers.match(/\d(\.\d{2})+$/)) {
+        return null;
+      }
+      const endingNumberVal = parseInt(endingNumbers);
+      const startingNumberVal = parseInt(startingNumbers);
+      if (endingNumberVal > 24 || startingNumberVal > 24) {
+        return null;
+      }
+    }
+    return result;
+  }
+  cachedPrimaryPrefix = null;
+  cachedPrimarySuffix = null;
+  cachedPrimaryTimePattern = null;
+  getPrimaryTimePatternThroughCache() {
+    const primaryPrefix = this.primaryPrefix();
+    const primarySuffix = this.primarySuffix();
+    if (this.cachedPrimaryPrefix === primaryPrefix && this.cachedPrimarySuffix === primarySuffix) {
+      return this.cachedPrimaryTimePattern;
+    }
+    this.cachedPrimaryTimePattern = primaryTimePattern(this.primaryPatternLeftBoundary(), primaryPrefix, primarySuffix, this.patternFlags());
+    this.cachedPrimaryPrefix = primaryPrefix;
+    this.cachedPrimarySuffix = primarySuffix;
+    return this.cachedPrimaryTimePattern;
+  }
+  cachedFollowingPhase = null;
+  cachedFollowingSuffix = null;
+  cachedFollowingTimePatten = null;
+  getFollowingTimePatternThroughCache() {
+    const followingPhase = this.followingPhase();
+    const followingSuffix = this.followingSuffix();
+    if (this.cachedFollowingPhase === followingPhase && this.cachedFollowingSuffix === followingSuffix) {
+      return this.cachedFollowingTimePatten;
+    }
+    this.cachedFollowingTimePatten = followingTimePatten(followingPhase, followingSuffix);
+    this.cachedFollowingPhase = followingPhase;
+    this.cachedFollowingSuffix = followingSuffix;
+    return this.cachedFollowingTimePatten;
+  }
+};
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/locales/en/parsers/ENTimeExpressionParser.js
+var ENTimeExpressionParser = class extends AbstractTimeExpressionParser {
+  constructor(strictMode) {
+    super(strictMode);
+  }
+  followingPhase() {
+    return "\\s*(?:\\-|\\\u2013|\\~|\\\u301C|to|until|through|till|\\?)\\s*";
+  }
+  primaryPrefix() {
+    return "(?:(?:at|from)\\s*)??";
+  }
+  primarySuffix() {
+    return "(?:\\s*(?:o\\W*clock|at\\s*night|in\\s*the\\s*(?:morning|afternoon)))?(?!/)(?=\\W|$)";
+  }
+  extractPrimaryTimeComponents(context, match) {
+    const components = super.extractPrimaryTimeComponents(context, match);
+    if (!components) {
+      return components;
+    }
+    if (match[0].endsWith("night")) {
+      const hour = components.get("hour");
+      if (hour >= 6 && hour < 12) {
+        components.assign("hour", components.get("hour") + 12);
+        components.assign("meridiem", Meridiem.PM);
+      } else if (hour < 6) {
+        components.assign("meridiem", Meridiem.AM);
+      }
+    }
+    if (match[0].endsWith("afternoon")) {
+      components.assign("meridiem", Meridiem.PM);
+      const hour = components.get("hour");
+      if (hour >= 0 && hour <= 6) {
+        components.assign("hour", components.get("hour") + 12);
+      }
+    }
+    if (match[0].endsWith("morning")) {
+      components.assign("meridiem", Meridiem.AM);
+      const hour = components.get("hour");
+      if (hour < 12) {
+        components.assign("hour", components.get("hour"));
+      }
+    }
+    return components.addTag("parser/ENTimeExpressionParser");
+  }
+  extractFollowingTimeComponents(context, match, result) {
+    const followingComponents = super.extractFollowingTimeComponents(context, match, result);
+    if (followingComponents) {
+      followingComponents.addTag("parser/ENTimeExpressionParser");
+    }
+    return followingComponents;
+  }
+};
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/locales/en/parsers/ENTimeUnitAgoFormatParser.js
+var PATTERN7 = new RegExp(`(${TIME_UNITS_PATTERN})\\s{0,5}(?:ago|before|earlier)(?=\\W|$)`, "i");
+var STRICT_PATTERN = new RegExp(`(${TIME_UNITS_NO_ABBR_PATTERN})\\s{0,5}(?:ago|before|earlier)(?=\\W|$)`, "i");
+var ENTimeUnitAgoFormatParser = class extends AbstractParserWithWordBoundaryChecking {
+  strictMode;
+  constructor(strictMode) {
+    super();
+    this.strictMode = strictMode;
+  }
+  innerPattern() {
+    return this.strictMode ? STRICT_PATTERN : PATTERN7;
+  }
+  innerExtract(context, match) {
+    const duration3 = parseDuration(match[1]);
+    if (!duration3) {
+      return null;
+    }
+    return ParsingComponents.createRelativeFromReference(context.reference, reverseDuration(duration3));
+  }
+};
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/locales/en/parsers/ENTimeUnitLaterFormatParser.js
+var PATTERN8 = new RegExp(`(${TIME_UNITS_PATTERN})\\s{0,5}(?:later|after|from now|henceforth|forward|out)(?=(?:\\W|$))`, "i");
+var STRICT_PATTERN2 = new RegExp(`(${TIME_UNITS_NO_ABBR_PATTERN})\\s{0,5}(later|after|from now)(?=\\W|$)`, "i");
+var GROUP_NUM_TIMEUNITS = 1;
+var ENTimeUnitLaterFormatParser = class extends AbstractParserWithWordBoundaryChecking {
+  strictMode;
+  constructor(strictMode) {
+    super();
+    this.strictMode = strictMode;
+  }
+  innerPattern() {
+    return this.strictMode ? STRICT_PATTERN2 : PATTERN8;
+  }
+  innerExtract(context, match) {
+    const timeUnits = parseDuration(match[GROUP_NUM_TIMEUNITS]);
+    if (!timeUnits) {
+      return null;
+    }
+    return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+  }
+};
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/common/abstractRefiners.js
+var Filter = class {
+  refine(context, results) {
+    return results.filter((r) => this.isValid(context, r));
+  }
+};
+var MergingRefiner = class {
+  refine(context, results) {
+    if (results.length < 2) {
+      return results;
+    }
+    const mergedResults = [];
+    let curResult = results[0];
+    let nextResult = null;
+    for (let i = 1; i < results.length; i++) {
+      nextResult = results[i];
+      const textBetween = context.text.substring(curResult.index + curResult.text.length, nextResult.index);
+      if (!this.shouldMergeResults(textBetween, curResult, nextResult, context)) {
+        mergedResults.push(curResult);
+        curResult = nextResult;
+      } else {
+        const left = curResult;
+        const right = nextResult;
+        const mergedResult = this.mergeResults(textBetween, left, right, context);
+        context.debug(() => {
+          console.log(`${this.constructor.name} merged ${left} and ${right} into ${mergedResult}`);
+        });
+        curResult = mergedResult;
+      }
+    }
+    if (curResult != null) {
+      mergedResults.push(curResult);
+    }
+    return mergedResults;
+  }
+};
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/common/refiners/AbstractMergeDateRangeRefiner.js
+var AbstractMergeDateRangeRefiner = class extends MergingRefiner {
+  shouldMergeResults(textBetween, currentResult, nextResult) {
+    return !currentResult.end && !nextResult.end && textBetween.match(this.patternBetween()) != null;
+  }
+  mergeResults(textBetween, fromResult, toResult) {
+    if (!fromResult.start.isOnlyWeekdayComponent() && !toResult.start.isOnlyWeekdayComponent()) {
+      toResult.start.getCertainComponents().forEach((key) => {
+        if (!fromResult.start.isCertain(key)) {
+          fromResult.start.imply(key, toResult.start.get(key));
+        }
+      });
+      fromResult.start.getCertainComponents().forEach((key) => {
+        if (!toResult.start.isCertain(key)) {
+          toResult.start.imply(key, fromResult.start.get(key));
+        }
+      });
+    }
+    if (fromResult.start.date() > toResult.start.date()) {
+      let fromDate = fromResult.start.date();
+      let toDate = toResult.start.date();
+      if (toResult.start.isOnlyWeekdayComponent() && addDuration(toDate, { day: 7 }) > fromDate) {
+        toDate = addDuration(toDate, { day: 7 });
+        toResult.start.imply("day", toDate.getDate());
+        toResult.start.imply("month", toDate.getMonth() + 1);
+        toResult.start.imply("year", toDate.getFullYear());
+      } else if (fromResult.start.isOnlyWeekdayComponent() && addDuration(fromDate, { day: -7 }) < toDate) {
+        fromDate = addDuration(fromDate, { day: -7 });
+        fromResult.start.imply("day", fromDate.getDate());
+        fromResult.start.imply("month", fromDate.getMonth() + 1);
+        fromResult.start.imply("year", fromDate.getFullYear());
+      } else if (toResult.start.isDateWithUnknownYear() && addDuration(toDate, { year: 1 }) > fromDate) {
+        toDate = addDuration(toDate, { year: 1 });
+        toResult.start.imply("year", toDate.getFullYear());
+      } else if (fromResult.start.isDateWithUnknownYear() && addDuration(fromDate, { year: -1 }) < toDate) {
+        fromDate = addDuration(fromDate, { year: -1 });
+        fromResult.start.imply("year", fromDate.getFullYear());
+      } else {
+        [toResult, fromResult] = [fromResult, toResult];
+      }
+    }
+    const result = fromResult.clone();
+    result.start = fromResult.start;
+    result.end = toResult.start;
+    result.index = Math.min(fromResult.index, toResult.index);
+    if (fromResult.index < toResult.index) {
+      result.text = fromResult.text + textBetween + toResult.text;
+    } else {
+      result.text = toResult.text + textBetween + fromResult.text;
+    }
+    return result;
+  }
+};
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/locales/en/refiners/ENMergeDateRangeRefiner.js
+var ENMergeDateRangeRefiner = class extends AbstractMergeDateRangeRefiner {
+  patternBetween() {
+    return /^\s*(to|-|–|until|through|till)\s*$/i;
+  }
+};
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/calculation/mergingCalculation.js
+function mergeDateTimeResult(dateResult, timeResult) {
+  const result = dateResult.clone();
+  const beginDate = dateResult.start;
+  const beginTime = timeResult.start;
+  result.start = mergeDateTimeComponent(beginDate, beginTime);
+  if (dateResult.end != null || timeResult.end != null) {
+    const endDate = dateResult.end == null ? dateResult.start : dateResult.end;
+    const endTime = timeResult.end == null ? timeResult.start : timeResult.end;
+    const endDateTime = mergeDateTimeComponent(endDate, endTime);
+    if (dateResult.end == null && endDateTime.date().getTime() < result.start.date().getTime()) {
+      const nextDay = new Date(endDateTime.date().getTime());
+      nextDay.setDate(nextDay.getDate() + 1);
+      if (endDateTime.isCertain("day")) {
+        assignSimilarDate(endDateTime, nextDay);
+      } else {
+        implySimilarDate(endDateTime, nextDay);
+      }
+    }
+    result.end = endDateTime;
+  }
+  return result;
+}
+function mergeDateTimeComponent(dateComponent, timeComponent) {
+  const dateTimeComponent = dateComponent.clone();
+  if (timeComponent.isCertain("hour")) {
+    dateTimeComponent.assign("hour", timeComponent.get("hour"));
+    dateTimeComponent.assign("minute", timeComponent.get("minute"));
+    if (timeComponent.isCertain("second")) {
+      dateTimeComponent.assign("second", timeComponent.get("second"));
+      if (timeComponent.isCertain("millisecond")) {
+        dateTimeComponent.assign("millisecond", timeComponent.get("millisecond"));
+      } else {
+        dateTimeComponent.imply("millisecond", timeComponent.get("millisecond"));
+      }
+    } else {
+      dateTimeComponent.imply("second", timeComponent.get("second"));
+      dateTimeComponent.imply("millisecond", timeComponent.get("millisecond"));
+    }
+  } else {
+    dateTimeComponent.imply("hour", timeComponent.get("hour"));
+    dateTimeComponent.imply("minute", timeComponent.get("minute"));
+    dateTimeComponent.imply("second", timeComponent.get("second"));
+    dateTimeComponent.imply("millisecond", timeComponent.get("millisecond"));
+  }
+  if (timeComponent.isCertain("timezoneOffset")) {
+    dateTimeComponent.assign("timezoneOffset", timeComponent.get("timezoneOffset"));
+  }
+  const dateHasMeaningfulMeridiem = dateComponent.get("meridiem") != null && (dateComponent.isCertain("meridiem") || Array.from(dateComponent.tags()).some((t) => t.startsWith("casualReference/")));
+  if (timeComponent.isCertain("meridiem")) {
+    dateTimeComponent.assign("meridiem", timeComponent.get("meridiem"));
+  } else if (timeComponent.get("meridiem") != null && !dateHasMeaningfulMeridiem) {
+    dateTimeComponent.imply("meridiem", timeComponent.get("meridiem"));
+  }
+  if (dateTimeComponent.get("meridiem") == Meridiem.PM && dateTimeComponent.get("hour") < 12) {
+    if (timeComponent.isCertain("hour")) {
+      dateTimeComponent.assign("hour", dateTimeComponent.get("hour") + 12);
+    } else {
+      dateTimeComponent.imply("hour", dateTimeComponent.get("hour") + 12);
+    }
+  }
+  dateTimeComponent.addTags(dateComponent.tags());
+  dateTimeComponent.addTags(timeComponent.tags());
+  return dateTimeComponent;
+}
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/common/refiners/AbstractMergeDateTimeRefiner.js
+var AbstractMergeDateTimeRefiner = class extends MergingRefiner {
+  shouldMergeResults(textBetween, currentResult, nextResult) {
+    return (currentResult.start.isOnlyDate() && nextResult.start.isOnlyTime() || nextResult.start.isOnlyDate() && currentResult.start.isOnlyTime()) && textBetween.match(this.patternBetween()) != null;
+  }
+  mergeResults(textBetween, currentResult, nextResult) {
+    const result = currentResult.start.isOnlyDate() ? mergeDateTimeResult(currentResult, nextResult) : mergeDateTimeResult(nextResult, currentResult);
+    result.index = currentResult.index;
+    result.text = currentResult.text + textBetween + nextResult.text;
+    return result;
+  }
+};
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/locales/en/refiners/ENMergeDateTimeRefiner.js
+var ENMergeDateTimeRefiner = class extends AbstractMergeDateTimeRefiner {
+  patternBetween() {
+    return new RegExp("^\\s*(T|at|after|before|on|of|,|-|\\.|\u2219|:)?\\s*$");
+  }
+};
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/common/refiners/ExtractTimezoneAbbrRefiner.js
+var TIMEZONE_NAME_PATTERN = new RegExp("^\\s*,?\\s*\\(?([A-Z]{2,4})\\)?(?=\\W|$)", "i");
+var ExtractTimezoneAbbrRefiner = class {
+  timezoneOverrides;
+  constructor(timezoneOverrides) {
+    this.timezoneOverrides = timezoneOverrides;
+  }
+  refine(context, results) {
+    const timezoneOverrides = context.option.timezones ?? {};
+    results.forEach((result) => {
+      const suffix = context.text.substring(result.index + result.text.length);
+      const match = TIMEZONE_NAME_PATTERN.exec(suffix);
+      if (!match) {
+        return;
+      }
+      const timezoneAbbr = match[1].toUpperCase();
+      const refDate = result.start.date() ?? result.refDate ?? /* @__PURE__ */ new Date();
+      const tzOverrides = { ...this.timezoneOverrides, ...timezoneOverrides };
+      const extractedTimezoneOffset = toTimezoneOffset(timezoneAbbr, refDate, tzOverrides);
+      if (extractedTimezoneOffset == null) {
+        return;
+      }
+      context.debug(() => {
+        console.log(`Extracting timezone: '${timezoneAbbr}' into: ${extractedTimezoneOffset} for: ${result.start}`);
+      });
+      const currentTimezoneOffset = result.start.get("timezoneOffset");
+      if (currentTimezoneOffset !== null && extractedTimezoneOffset != currentTimezoneOffset) {
+        if (result.start.isCertain("timezoneOffset")) {
+          return;
+        }
+        if (timezoneAbbr != match[1]) {
+          return;
+        }
+      }
+      if (result.start.isOnlyDate()) {
+        if (timezoneAbbr != match[1]) {
+          return;
+        }
+      }
+      result.text += match[0];
+      if (!result.start.isCertain("timezoneOffset")) {
+        result.start.assign("timezoneOffset", extractedTimezoneOffset);
+      }
+      if (result.end != null && !result.end.isCertain("timezoneOffset")) {
+        result.end.assign("timezoneOffset", extractedTimezoneOffset);
+      }
+    });
+    return results;
+  }
+};
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/common/refiners/ExtractTimezoneOffsetRefiner.js
+var TIMEZONE_OFFSET_PATTERN = new RegExp("^\\s*(?:\\(?(?:GMT|UTC)\\s?)?([+-])(\\d{1,2})(?::?(\\d{2}))?\\)?", "i");
+var TIMEZONE_OFFSET_SIGN_GROUP = 1;
+var TIMEZONE_OFFSET_HOUR_OFFSET_GROUP = 2;
+var TIMEZONE_OFFSET_MINUTE_OFFSET_GROUP = 3;
+var ExtractTimezoneOffsetRefiner = class {
+  refine(context, results) {
+    results.forEach(function(result) {
+      if (result.start.isCertain("timezoneOffset")) {
+        return;
+      }
+      const suffix = context.text.substring(result.index + result.text.length);
+      const match = TIMEZONE_OFFSET_PATTERN.exec(suffix);
+      if (!match) {
+        return;
+      }
+      context.debug(() => {
+        console.log(`Extracting timezone: '${match[0]}' into : ${result}`);
+      });
+      const hourOffset = parseInt(match[TIMEZONE_OFFSET_HOUR_OFFSET_GROUP]);
+      const minuteOffset = parseInt(match[TIMEZONE_OFFSET_MINUTE_OFFSET_GROUP] || "0");
+      let timezoneOffset = hourOffset * 60 + minuteOffset;
+      if (timezoneOffset > 14 * 60) {
+        return;
+      }
+      if (match[TIMEZONE_OFFSET_SIGN_GROUP] === "-") {
+        timezoneOffset = -timezoneOffset;
+      }
+      if (result.end != null) {
+        result.end.assign("timezoneOffset", timezoneOffset);
+      }
+      result.start.assign("timezoneOffset", timezoneOffset);
+      result.text += match[0];
+    });
+    return results;
+  }
+};
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/common/refiners/OverlapRemovalRefiner.js
+var OverlapRemovalRefiner = class {
+  refine(context, results) {
+    if (results.length < 2) {
+      return results;
+    }
+    const filteredResults = [];
+    let prevResult = results[0];
+    for (let i = 1; i < results.length; i++) {
+      const result = results[i];
+      if (result.index >= prevResult.index + prevResult.text.length) {
+        filteredResults.push(prevResult);
+        prevResult = result;
+        continue;
+      }
+      let kept = null;
+      let removed = null;
+      if (result.text.length > prevResult.text.length) {
+        kept = result;
+        removed = prevResult;
+      } else {
+        kept = prevResult;
+        removed = result;
+      }
+      context.debug(() => {
+        console.log(`${this.constructor.name} remove ${removed} by ${kept}`);
+      });
+      prevResult = kept;
+    }
+    if (prevResult != null) {
+      filteredResults.push(prevResult);
+    }
+    return filteredResults;
+  }
+};
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/calculation/weekdays.js
+function createParsingComponentsAtWeekday(reference, weekday, modifier) {
+  const refDate = reference.getDateWithAdjustedTimezone();
+  const daysToWeekday = getDaysToWeekday(refDate, weekday, modifier);
+  let components = new ParsingComponents(reference);
+  components = components.addDurationAsImplied({ day: daysToWeekday });
+  components.assign("weekday", weekday);
+  return components;
+}
+function getDaysToWeekday(refDate, weekday, modifier) {
+  const refWeekday = refDate.getDay();
+  switch (modifier) {
+    case "this":
+      return getDaysForwardToWeekday(refDate, weekday);
+    case "last":
+      return getBackwardDaysToWeekday(refDate, weekday);
+    case "next":
+      if (refWeekday == Weekday.SUNDAY) {
+        return weekday == Weekday.SUNDAY ? 7 : weekday;
+      }
+      if (refWeekday == Weekday.SATURDAY) {
+        if (weekday == Weekday.SATURDAY)
+          return 7;
+        if (weekday == Weekday.SUNDAY)
+          return 8;
+        return 1 + weekday;
+      }
+      if (weekday < refWeekday && weekday != Weekday.SUNDAY) {
+        return getDaysForwardToWeekday(refDate, weekday);
+      } else {
+        return getDaysForwardToWeekday(refDate, weekday) + 7;
+      }
+  }
+  return getDaysToWeekdayClosest(refDate, weekday);
+}
+function getDaysToWeekdayClosest(refDate, weekday) {
+  const backward = getBackwardDaysToWeekday(refDate, weekday);
+  const forward = getDaysForwardToWeekday(refDate, weekday);
+  return forward < -backward ? forward : backward;
+}
+function getDaysForwardToWeekday(refDate, weekday) {
+  const refWeekday = refDate.getDay();
+  let forwardCount = weekday - refWeekday;
+  if (forwardCount < 0) {
+    forwardCount += 7;
+  }
+  return forwardCount;
+}
+function getBackwardDaysToWeekday(refDate, weekday) {
+  const refWeekday = refDate.getDay();
+  let backwardCount = weekday - refWeekday;
+  if (backwardCount >= 0) {
+    backwardCount -= 7;
+  }
+  return backwardCount;
+}
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/common/refiners/ForwardDateRefiner.js
+var ForwardDateRefiner = class {
+  refine(context, results) {
+    if (!context.option.forwardDate) {
+      return results;
+    }
+    results.forEach((result) => {
+      let refDate = context.reference.getDateWithAdjustedTimezone();
+      if (result.start.isOnlyTime() && context.reference.instant > result.start.date()) {
+        const refDate2 = context.reference.getDateWithAdjustedTimezone();
+        const refFollowingDay = new Date(refDate2);
+        refFollowingDay.setDate(refFollowingDay.getDate() + 1);
+        implySimilarDate(result.start, refFollowingDay);
+        context.debug(() => {
+          console.log(`${this.constructor.name} adjusted ${result} time from the ref date (${refDate2}) to the following day (${refFollowingDay})`);
+        });
+        if (result.end && result.end.isOnlyTime()) {
+          implySimilarDate(result.end, refFollowingDay);
+          if (result.start.date() > result.end.date()) {
+            refFollowingDay.setDate(refFollowingDay.getDate() + 1);
+            implySimilarDate(result.end, refFollowingDay);
+          }
+        }
+      }
+      if (result.start.isOnlyWeekdayComponent() && refDate > result.start.date()) {
+        let daysToAdd = getDaysForwardToWeekday(refDate, result.start.get("weekday")) || 7;
+        const forwardedWeekday = addDuration(refDate, { day: daysToAdd });
+        implySimilarDate(result.start, forwardedWeekday);
+        context.debug(() => {
+          console.log(`${this.constructor.name} adjusted ${result} weekday (${result.start})`);
+        });
+        if (result.end && result.start.date() > result.end.date()) {
+          let daysToAdd2 = getDaysForwardToWeekday(refDate, result.start.get("weekday")) || 7;
+          const forwardedWeekday2 = addDuration(refDate, { day: daysToAdd2 });
+          implySimilarDate(result.end, forwardedWeekday2);
+          context.debug(() => {
+            console.log(`${this.constructor.name} adjusted ${result} weekday (${result.end})`);
+          });
+        }
+      }
+      if (result.start.isDateWithUnknownYear() && refDate > result.start.date()) {
+        for (let i = 0; i < 3 && refDate > result.start.date(); i++) {
+          result.start.imply("year", result.start.get("year") + 1);
+          context.debug(() => {
+            console.log(`${this.constructor.name} adjusted ${result} year (${result.start})`);
+          });
+          if (result.end && !result.end.isCertain("year")) {
+            result.end.imply("year", result.end.get("year") + 1);
+            context.debug(() => {
+              console.log(`${this.constructor.name} adjusted ${result} month (${result.start})`);
+            });
+          }
+        }
+      }
+    });
+    return results;
+  }
+};
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/common/refiners/UnlikelyFormatFilter.js
+var UnlikelyFormatFilter = class extends Filter {
+  strictMode;
+  constructor(strictMode) {
+    super();
+    this.strictMode = strictMode;
+  }
+  isValid(context, result) {
+    if (result.text.replace(" ", "").match(/^\d*(\.\d*)?$/)) {
+      context.debug(() => {
+        console.log(`Removing unlikely result '${result.text}'`);
+      });
+      return false;
+    }
+    if (!result.start.isValidDate()) {
+      context.debug(() => {
+        console.log(`Removing invalid result: ${result} (${result.start})`);
+      });
+      return false;
+    }
+    if (result.end && !result.end.isValidDate()) {
+      context.debug(() => {
+        console.log(`Removing invalid result: ${result} (${result.end})`);
+      });
+      return false;
+    }
+    if (this.strictMode) {
+      return this.isStrictModeValid(context, result);
+    }
+    return true;
+  }
+  isStrictModeValid(context, result) {
+    if (result.start.isOnlyWeekdayComponent()) {
+      context.debug(() => {
+        console.log(`(Strict) Removing weekday only component: ${result} (${result.end})`);
+      });
+      return false;
+    }
+    return true;
+  }
+};
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/common/parsers/ISOFormatParser.js
+var PATTERN9 = new RegExp("([0-9]{4})\\-([0-9]{1,2})\\-([0-9]{1,2})(?:T([0-9]{1,2}):([0-9]{1,2})(?::([0-9]{1,2})(?:\\.(\\d{1,4}))?)?(Z|([+-]\\d{2}):?(\\d{2})?)?)?(?=\\W|$)", "i");
+var YEAR_NUMBER_GROUP2 = 1;
+var MONTH_NUMBER_GROUP2 = 2;
+var DATE_NUMBER_GROUP2 = 3;
+var HOUR_NUMBER_GROUP = 4;
+var MINUTE_NUMBER_GROUP = 5;
+var SECOND_NUMBER_GROUP = 6;
+var MILLISECOND_NUMBER_GROUP = 7;
+var TZD_GROUP = 8;
+var TZD_HOUR_OFFSET_GROUP = 9;
+var TZD_MINUTE_OFFSET_GROUP = 10;
+var ISOFormatParser = class extends AbstractParserWithWordBoundaryChecking {
+  innerPattern() {
+    return PATTERN9;
+  }
+  innerExtract(context, match) {
+    const components = context.createParsingComponents({
+      "year": parseInt(match[YEAR_NUMBER_GROUP2]),
+      "month": parseInt(match[MONTH_NUMBER_GROUP2]),
+      "day": parseInt(match[DATE_NUMBER_GROUP2])
+    });
+    if (match[HOUR_NUMBER_GROUP] != null) {
+      components.assign("hour", parseInt(match[HOUR_NUMBER_GROUP]));
+      components.assign("minute", parseInt(match[MINUTE_NUMBER_GROUP]));
+      if (match[SECOND_NUMBER_GROUP] != null) {
+        components.assign("second", parseInt(match[SECOND_NUMBER_GROUP]));
+      }
+      if (match[MILLISECOND_NUMBER_GROUP] != null) {
+        components.assign("millisecond", parseInt(match[MILLISECOND_NUMBER_GROUP]));
+      }
+      if (match[TZD_GROUP] != null) {
+        let offset = 0;
+        if (match[TZD_HOUR_OFFSET_GROUP]) {
+          const hourOffset = parseInt(match[TZD_HOUR_OFFSET_GROUP]);
+          let minuteOffset = 0;
+          if (match[TZD_MINUTE_OFFSET_GROUP] != null) {
+            minuteOffset = parseInt(match[TZD_MINUTE_OFFSET_GROUP]);
+          }
+          offset = hourOffset * 60;
+          if (offset < 0) {
+            offset -= minuteOffset;
+          } else {
+            offset += minuteOffset;
+          }
+        }
+        components.assign("timezoneOffset", offset);
+      }
+    }
+    return components.addTag("parser/ISOFormatParser");
+  }
+};
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/common/refiners/MergeWeekdayComponentRefiner.js
+var MergeWeekdayComponentRefiner = class extends MergingRefiner {
+  mergeResults(textBetween, currentResult, nextResult) {
+    const newResult = nextResult.clone();
+    newResult.index = currentResult.index;
+    newResult.text = currentResult.text + textBetween + newResult.text;
+    newResult.start.assign("weekday", currentResult.start.get("weekday"));
+    if (newResult.end) {
+      newResult.end.assign("weekday", currentResult.start.get("weekday"));
+    }
+    return newResult;
+  }
+  shouldMergeResults(textBetween, currentResult, nextResult) {
+    const weekdayThenNormalDate = currentResult.start.isOnlyWeekdayComponent() && !currentResult.start.isCertain("hour") && nextResult.start.isCertain("day");
+    return weekdayThenNormalDate && textBetween.match(/^,?\s*$/) != null;
+  }
+};
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/configurations.js
+function includeCommonConfiguration(configuration2, strictMode = false) {
+  configuration2.parsers.unshift(new ISOFormatParser());
+  configuration2.refiners.unshift(new MergeWeekdayComponentRefiner());
+  configuration2.refiners.unshift(new ExtractTimezoneOffsetRefiner());
+  configuration2.refiners.unshift(new OverlapRemovalRefiner());
+  configuration2.refiners.push(new ExtractTimezoneAbbrRefiner());
+  configuration2.refiners.push(new OverlapRemovalRefiner());
+  configuration2.refiners.push(new ForwardDateRefiner());
+  configuration2.refiners.push(new UnlikelyFormatFilter(strictMode));
+  return configuration2;
+}
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/common/casualReferences.js
+function now(reference) {
+  const targetDate = reference.getDateWithAdjustedTimezone();
+  const component = new ParsingComponents(reference, {});
+  assignSimilarDate(component, targetDate);
+  assignSimilarTime(component, targetDate);
+  component.assign("timezoneOffset", reference.getTimezoneOffset());
+  component.addTag("casualReference/now");
+  return component;
+}
+function today(reference) {
+  const targetDate = reference.getDateWithAdjustedTimezone();
+  const component = new ParsingComponents(reference, {});
+  assignSimilarDate(component, targetDate);
+  implySimilarTime(component, targetDate);
+  component.delete("meridiem");
+  component.addTag("casualReference/today");
+  return component;
+}
+function yesterday(reference) {
+  return theDayBefore(reference, 1).addTag("casualReference/yesterday");
+}
+function tomorrow(reference) {
+  return theDayAfter(reference, 1).addTag("casualReference/tomorrow");
+}
+function theDayBefore(reference, numDay) {
+  return theDayAfter(reference, -numDay);
+}
+function theDayAfter(reference, nDays) {
+  const targetDate = reference.getDateWithAdjustedTimezone();
+  const component = new ParsingComponents(reference, {});
+  const newDate = new Date(targetDate.getTime());
+  newDate.setDate(newDate.getDate() + nDays);
+  assignSimilarDate(component, newDate);
+  implySimilarTime(component, newDate);
+  component.delete("meridiem");
+  return component;
+}
+function tonight(reference, implyHour = 22) {
+  const targetDate = reference.getDateWithAdjustedTimezone();
+  const component = new ParsingComponents(reference, {});
+  assignSimilarDate(component, targetDate);
+  component.imply("hour", implyHour);
+  component.imply("meridiem", Meridiem.PM);
+  component.addTag("casualReference/tonight");
+  return component;
+}
+function evening(reference, implyHour = 20) {
+  const component = new ParsingComponents(reference, {});
+  component.imply("meridiem", Meridiem.PM);
+  component.imply("hour", implyHour);
+  component.addTag("casualReference/evening");
+  return component;
+}
+function midnight(reference) {
+  const component = new ParsingComponents(reference, {});
+  if (reference.getDateWithAdjustedTimezone().getHours() > 2) {
+    component.addDurationAsImplied({ day: 1 });
+  }
+  component.assign("hour", 0);
+  component.imply("minute", 0);
+  component.imply("second", 0);
+  component.imply("millisecond", 0);
+  component.addTag("casualReference/midnight");
+  return component;
+}
+function morning(reference, implyHour = 6) {
+  const component = new ParsingComponents(reference, {});
+  component.imply("meridiem", Meridiem.AM);
+  component.imply("hour", implyHour);
+  component.imply("minute", 0);
+  component.imply("second", 0);
+  component.imply("millisecond", 0);
+  component.addTag("casualReference/morning");
+  return component;
+}
+function afternoon(reference, implyHour = 15) {
+  const component = new ParsingComponents(reference, {});
+  component.imply("meridiem", Meridiem.PM);
+  component.imply("hour", implyHour);
+  component.imply("minute", 0);
+  component.imply("second", 0);
+  component.imply("millisecond", 0);
+  component.addTag("casualReference/afternoon");
+  return component;
+}
+function noon(reference) {
+  const component = new ParsingComponents(reference, {});
+  component.imply("meridiem", Meridiem.AM);
+  component.assign("hour", 12);
+  component.imply("minute", 0);
+  component.imply("second", 0);
+  component.imply("millisecond", 0);
+  component.addTag("casualReference/noon");
+  return component;
+}
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/locales/en/parsers/ENCasualDateParser.js
+var PATTERN10 = /(now|today|tonight|tomorrow|overmorrow|tmr|tmrw|yesterday|last\s*night)(?=\W|$)/i;
+var ENCasualDateParser = class extends AbstractParserWithWordBoundaryChecking {
+  innerPattern(context) {
+    return PATTERN10;
+  }
+  innerExtract(context, match) {
+    let targetDate = context.refDate;
+    const lowerText = match[0].toLowerCase();
+    let component = context.createParsingComponents();
+    switch (lowerText) {
+      case "now":
+        component = now(context.reference);
+        break;
+      case "today":
+        component = today(context.reference);
+        break;
+      case "yesterday":
+        component = yesterday(context.reference);
+        break;
+      case "tomorrow":
+      case "tmr":
+      case "tmrw":
+        component = tomorrow(context.reference);
+        break;
+      case "tonight":
+        component = tonight(context.reference);
+        break;
+      case "overmorrow":
+        component = theDayAfter(context.reference, 2);
+        break;
+      default:
+        if (lowerText.match(/last\s*night/)) {
+          if (targetDate.getHours() > 6) {
+            const previousDay = new Date(targetDate.getTime());
+            previousDay.setDate(previousDay.getDate() - 1);
+            targetDate = previousDay;
+          }
+          assignSimilarDate(component, targetDate);
+          component.imply("hour", 0);
+        }
+        break;
+    }
+    component.addTag("parser/ENCasualDateParser");
+    return component;
+  }
+};
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/locales/en/parsers/ENCasualTimeParser.js
+var PATTERN11 = /(?:this)?\s{0,3}(morning|afternoon|evening|night|midnight|midday|noon)(?=\W|$)/i;
+var ENCasualTimeParser = class extends AbstractParserWithWordBoundaryChecking {
+  innerPattern() {
+    return PATTERN11;
+  }
+  innerExtract(context, match) {
+    let component = null;
+    switch (match[1].toLowerCase()) {
+      case "afternoon":
+        component = afternoon(context.reference);
+        break;
+      case "evening":
+      case "night":
+        component = evening(context.reference);
+        break;
+      case "midnight":
+        component = midnight(context.reference);
+        break;
+      case "morning":
+        component = morning(context.reference);
+        break;
+      case "noon":
+      case "midday":
+        component = noon(context.reference);
+        break;
+    }
+    if (component) {
+      component.addTag("parser/ENCasualTimeParser");
+    }
+    return component;
+  }
+};
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/locales/en/parsers/ENWeekdayParser.js
+var PATTERN12 = new RegExp(`(?:(?:\\,|\\(|\\\uFF08)\\s*)?(?:on\\s*?)?(?:(this|last|past|next)\\s*)?(${matchAnyPattern(WEEKDAY_DICTIONARY)}|weekend|weekday)(?:\\s*(?:\\,|\\)|\\\uFF09))?(?:\\s*(?:of\\s*)?(this|last|past|next)\\s*week)?(?=\\W|$)`, "i");
+var PREFIX_GROUP2 = 1;
+var WEEKDAY_GROUP = 2;
+var POSTFIX_GROUP = 3;
+var ENWeekdayParser = class extends AbstractParserWithWordBoundaryChecking {
+  innerPattern() {
+    return PATTERN12;
+  }
+  innerExtract(context, match) {
+    const prefix = match[PREFIX_GROUP2];
+    const postfix = match[POSTFIX_GROUP];
+    let modifierWord = prefix || postfix;
+    modifierWord = modifierWord || "";
+    modifierWord = modifierWord.toLowerCase();
+    let modifier = null;
+    if (modifierWord == "last" || modifierWord == "past") {
+      modifier = "last";
+    } else if (modifierWord == "next") {
+      modifier = "next";
+    } else if (modifierWord == "this") {
+      modifier = "this";
+    }
+    const weekday_word = match[WEEKDAY_GROUP].toLowerCase();
+    let weekday;
+    if (WEEKDAY_DICTIONARY[weekday_word] !== void 0) {
+      weekday = WEEKDAY_DICTIONARY[weekday_word];
+    } else if (weekday_word == "weekend") {
+      weekday = modifier == "last" ? Weekday.SUNDAY : Weekday.SATURDAY;
+    } else if (weekday_word == "weekday") {
+      const refWeekday = context.reference.getDateWithAdjustedTimezone().getDay();
+      if (refWeekday == Weekday.SUNDAY || refWeekday == Weekday.SATURDAY) {
+        weekday = modifier == "last" ? Weekday.FRIDAY : Weekday.MONDAY;
+      } else {
+        weekday = refWeekday - 1;
+        weekday = modifier == "last" ? weekday - 1 : weekday + 1;
+        weekday = weekday % 5 + 1;
+      }
+    } else {
+      return null;
+    }
+    return createParsingComponentsAtWeekday(context.reference, weekday, modifier);
+  }
+};
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/locales/en/parsers/ENRelativeDateFormatParser.js
+var PATTERN13 = new RegExp(`(this|last|past|next|after\\s*this)\\s*(${matchAnyPattern(TIME_UNIT_DICTIONARY)})(?=\\s*)(?=\\W|$)`, "i");
+var MODIFIER_WORD_GROUP = 1;
+var RELATIVE_WORD_GROUP = 2;
+var ENRelativeDateFormatParser = class extends AbstractParserWithWordBoundaryChecking {
+  innerPattern() {
+    return PATTERN13;
+  }
+  innerExtract(context, match) {
+    const modifier = match[MODIFIER_WORD_GROUP].toLowerCase();
+    const unitWord = match[RELATIVE_WORD_GROUP].toLowerCase();
+    const timeunit = TIME_UNIT_DICTIONARY[unitWord];
+    if (modifier == "next" || modifier.startsWith("after")) {
+      const timeUnits = {};
+      timeUnits[timeunit] = 1;
+      return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+    }
+    if (modifier == "last" || modifier == "past") {
+      const timeUnits = {};
+      timeUnits[timeunit] = -1;
+      return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+    }
+    const components = context.createParsingComponents();
+    let date3 = new Date(context.reference.instant.getTime());
+    if (unitWord.match(/week/i)) {
+      date3.setDate(date3.getDate() - date3.getDay());
+      components.imply("day", date3.getDate());
+      components.imply("month", date3.getMonth() + 1);
+      components.imply("year", date3.getFullYear());
+    } else if (unitWord.match(/month/i)) {
+      date3.setDate(1);
+      components.imply("day", date3.getDate());
+      components.assign("year", date3.getFullYear());
+      components.assign("month", date3.getMonth() + 1);
+    } else if (unitWord.match(/year/i)) {
+      date3.setDate(1);
+      date3.setMonth(0);
+      components.imply("day", date3.getDate());
+      components.imply("month", date3.getMonth() + 1);
+      components.assign("year", date3.getFullYear());
+    }
+    return components;
+  }
+};
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/common/parsers/SlashDateFormatParser.js
+var PATTERN14 = new RegExp("([^\\d]|^)([0-3]{0,1}[0-9]{1})[\\/\\.\\-]([0-3]{0,1}[0-9]{1})(?:[\\/\\.\\-]([0-9]{4}|[0-9]{2}))?(\\W|$)", "i");
+var OPENING_GROUP = 1;
+var ENDING_GROUP = 5;
+var FIRST_NUMBERS_GROUP = 2;
+var SECOND_NUMBERS_GROUP = 3;
+var YEAR_GROUP6 = 4;
+var SlashDateFormatParser = class {
+  groupNumberMonth;
+  groupNumberDay;
+  constructor(littleEndian) {
+    this.groupNumberMonth = littleEndian ? SECOND_NUMBERS_GROUP : FIRST_NUMBERS_GROUP;
+    this.groupNumberDay = littleEndian ? FIRST_NUMBERS_GROUP : SECOND_NUMBERS_GROUP;
+  }
+  pattern() {
+    return PATTERN14;
+  }
+  extract(context, match) {
+    const index = match.index + match[OPENING_GROUP].length;
+    const indexEnd = match.index + match[0].length - match[ENDING_GROUP].length;
+    if (index > 0) {
+      const textBefore = context.text.substring(0, index);
+      if (textBefore.match("\\d/?$")) {
+        return;
+      }
+    }
+    if (indexEnd < context.text.length) {
+      const textAfter = context.text.substring(indexEnd);
+      if (textAfter.match("^/?\\d")) {
+        return;
+      }
+    }
+    const text2 = context.text.substring(index, indexEnd);
+    if (text2.match(/^\d\.\d$/) || text2.match(/^\d\.\d{1,2}\.\d{1,2}\s*$/)) {
+      return;
+    }
+    if (!match[YEAR_GROUP6] && text2.indexOf("/") < 0) {
+      return;
+    }
+    const result = context.createParsingResult(index, text2);
+    let month = parseInt(match[this.groupNumberMonth]);
+    let day = parseInt(match[this.groupNumberDay]);
+    if (month < 1 || month > 12) {
+      if (month > 12) {
+        if (day >= 1 && day <= 12 && month <= 31) {
+          [day, month] = [month, day];
+        } else {
+          return null;
+        }
+      }
+    }
+    if (day < 1 || day > 31) {
+      return null;
+    }
+    result.start.assign("day", day);
+    result.start.assign("month", month);
+    if (match[YEAR_GROUP6]) {
+      const rawYearNumber = parseInt(match[YEAR_GROUP6]);
+      const year = findMostLikelyADYear(rawYearNumber);
+      result.start.assign("year", year);
+    } else {
+      const year = findYearClosestToRef(context.refDate, day, month);
+      result.start.imply("year", year);
+    }
+    return result.addTag("parser/SlashDateFormatParser");
+  }
+};
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/locales/en/parsers/ENTimeUnitCasualRelativeFormatParser.js
+var PATTERN15 = new RegExp(`(this|last|past|next|after|\\+|-)\\s*(${TIME_UNITS_PATTERN})(?=\\W|$)`, "i");
+var PATTERN_NO_ABBR = new RegExp(`(this|last|past|next|after|\\+|-)\\s*(${TIME_UNITS_NO_ABBR_PATTERN})(?=\\W|$)`, "i");
+var ENTimeUnitCasualRelativeFormatParser = class extends AbstractParserWithWordBoundaryChecking {
+  allowAbbreviations;
+  constructor(allowAbbreviations = true) {
+    super();
+    this.allowAbbreviations = allowAbbreviations;
+  }
+  innerPattern() {
+    return this.allowAbbreviations ? PATTERN15 : PATTERN_NO_ABBR;
+  }
+  innerExtract(context, match) {
+    const prefix = match[1].toLowerCase();
+    let duration3 = parseDuration(match[2]);
+    if (!duration3) {
+      return null;
+    }
+    switch (prefix) {
+      case "last":
+      case "past":
+      case "-":
+        duration3 = reverseDuration(duration3);
+        break;
+    }
+    return ParsingComponents.createRelativeFromReference(context.reference, duration3);
+  }
+};
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/locales/en/refiners/ENMergeRelativeAfterDateRefiner.js
+function IsPositiveFollowingReference(result) {
+  return result.text.match(/^[+-]/i) != null;
+}
+function IsNegativeFollowingReference(result) {
+  return result.text.match(/^-/i) != null;
+}
+var ENMergeRelativeAfterDateRefiner = class extends MergingRefiner {
+  shouldMergeResults(textBetween, currentResult, nextResult) {
+    if (!textBetween.match(/^\s*$/i)) {
+      return false;
+    }
+    return IsPositiveFollowingReference(nextResult) || IsNegativeFollowingReference(nextResult);
+  }
+  mergeResults(textBetween, currentResult, nextResult, context) {
+    let timeUnits = parseDuration(nextResult.text);
+    if (IsNegativeFollowingReference(nextResult)) {
+      timeUnits = reverseDuration(timeUnits);
+    }
+    const components = ParsingComponents.createRelativeFromReference(ReferenceWithTimezone.fromDate(currentResult.start.date()), timeUnits);
+    return new ParsingResult(currentResult.reference, currentResult.index, `${currentResult.text}${textBetween}${nextResult.text}`, components);
+  }
+};
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/locales/en/refiners/ENMergeRelativeFollowByDateRefiner.js
+function hasImpliedEarlierReferenceDate(result) {
+  return result.text.match(/\s+(before|from)$/i) != null;
+}
+function hasImpliedLaterReferenceDate(result) {
+  return result.text.match(/\s+(after|since)$/i) != null;
+}
+var ENMergeRelativeFollowByDateRefiner = class extends MergingRefiner {
+  patternBetween() {
+    return /^\s*$/i;
+  }
+  shouldMergeResults(textBetween, currentResult, nextResult) {
+    if (!textBetween.match(this.patternBetween())) {
+      return false;
+    }
+    if (!hasImpliedEarlierReferenceDate(currentResult) && !hasImpliedLaterReferenceDate(currentResult)) {
+      return false;
+    }
+    return !!nextResult.start.get("day") && !!nextResult.start.get("month") && !!nextResult.start.get("year");
+  }
+  mergeResults(textBetween, currentResult, nextResult) {
+    let duration3 = parseDuration(currentResult.text);
+    if (hasImpliedEarlierReferenceDate(currentResult)) {
+      duration3 = reverseDuration(duration3);
+    }
+    const components = ParsingComponents.createRelativeFromReference(ReferenceWithTimezone.fromDate(nextResult.start.date()), duration3);
+    return new ParsingResult(nextResult.reference, currentResult.index, `${currentResult.text}${textBetween}${nextResult.text}`, components);
+  }
+};
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/locales/en/refiners/ENExtractYearSuffixRefiner.js
+var YEAR_SUFFIX_PATTERN = new RegExp(`^\\s*(${YEAR_PATTERN})`, "i");
+var YEAR_GROUP7 = 1;
+var ENExtractYearSuffixRefiner = class {
+  refine(context, results) {
+    results.forEach(function(result) {
+      if (!result.start.isDateWithUnknownYear()) {
+        return;
+      }
+      const suffix = context.text.substring(result.index + result.text.length);
+      const match = YEAR_SUFFIX_PATTERN.exec(suffix);
+      if (!match) {
+        return;
+      }
+      if (match[0].trim().length <= 3) {
+        return;
+      }
+      context.debug(() => {
+        console.log(`Extracting year: '${match[0]}' into : ${result}`);
+      });
+      const year = parseYear(match[YEAR_GROUP7]);
+      if (result.end != null) {
+        result.end.assign("year", year);
+      }
+      result.start.assign("year", year);
+      result.text += match[0];
+    });
+    return results;
+  }
+};
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/locales/en/refiners/ENUnlikelyFormatFilter.js
+var ENUnlikelyFormatFilter = class extends Filter {
+  constructor() {
+    super();
+  }
+  isValid(context, result) {
+    const text2 = result.text.trim();
+    if (text2 === context.text.trim()) {
+      return true;
+    }
+    if (text2.toLowerCase() === "may") {
+      const textBefore = context.text.substring(0, result.index).trim();
+      if (!textBefore.match(/\b(in)$/i)) {
+        context.debug(() => {
+          console.log(`Removing unlikely result: ${result}`);
+        });
+        return false;
+      }
+    }
+    if (text2.toLowerCase().endsWith("the second")) {
+      const textAfter = context.text.substring(result.index + result.text.length).trim();
+      if (textAfter.length > 0) {
+        context.debug(() => {
+          console.log(`Removing unlikely result: ${result}`);
+        });
+      }
+      return false;
+    }
+    return true;
+  }
+};
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/locales/en/configuration.js
+var ENDefaultConfiguration = class {
+  createCasualConfiguration(littleEndian = false) {
+    const option = this.createConfiguration(false, littleEndian);
+    option.parsers.push(new ENCasualDateParser());
+    option.parsers.push(new ENCasualTimeParser());
+    option.parsers.push(new ENMonthNameParser());
+    option.parsers.push(new ENRelativeDateFormatParser());
+    option.parsers.push(new ENTimeUnitCasualRelativeFormatParser());
+    option.refiners.push(new ENUnlikelyFormatFilter());
+    return option;
+  }
+  createConfiguration(strictMode = true, littleEndian = false) {
+    const options = includeCommonConfiguration({
+      parsers: [
+        new SlashDateFormatParser(littleEndian),
+        new ENTimeUnitWithinFormatParser(strictMode),
+        new ENMonthNameLittleEndianParser(),
+        new ENMonthNameMiddleEndianParser(littleEndian),
+        new ENWeekdayParser(),
+        new ENSlashMonthFormatParser(),
+        new ENTimeExpressionParser(strictMode),
+        new ENTimeUnitAgoFormatParser(strictMode),
+        new ENTimeUnitLaterFormatParser(strictMode),
+        new ENYearMonthNameParser()
+      ],
+      refiners: [new ENMergeDateTimeRefiner()]
+    }, strictMode);
+    options.parsers.unshift(new ENYearMonthDayParser(strictMode));
+    options.refiners.unshift(new ENMergeRelativeFollowByDateRefiner());
+    options.refiners.unshift(new ENMergeRelativeAfterDateRefiner());
+    options.refiners.unshift(new OverlapRemovalRefiner());
+    options.refiners.push(new ENMergeDateTimeRefiner());
+    options.refiners.push(new ENExtractYearSuffixRefiner());
+    options.refiners.push(new ENMergeDateRangeRefiner());
+    return options;
+  }
+};
 
-  CREATE TABLE IF NOT EXISTS task_events (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    event_uuid TEXT NOT NULL UNIQUE,
-    task_uuid TEXT NOT NULL,
-    op TEXT NOT NULL CHECK (op IN ('create','complete','uncomplete','edit','delete')),
-    payload TEXT,
-    device_id TEXT NOT NULL,
-    ts TEXT NOT NULL DEFAULT (datetime('now')),
-    lamport INTEGER NOT NULL DEFAULT 0
-  );
-  CREATE INDEX IF NOT EXISTS idx_task_events_task ON task_events(task_uuid);
-  CREATE INDEX IF NOT EXISTS idx_task_events_lamport ON task_events(device_id, lamport);
-`);
-{
-  const cols = db.prepare(`PRAGMA table_info(tasks)`).all();
-  if (!cols.some((c) => c.name === "fingerprint")) {
-    db.exec(`ALTER TABLE tasks ADD COLUMN fingerprint TEXT`);
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/chrono.js
+var Chrono = class _Chrono {
+  parsers;
+  refiners;
+  defaultConfig = new ENDefaultConfiguration();
+  constructor(configuration2) {
+    configuration2 = configuration2 || this.defaultConfig.createCasualConfiguration();
+    this.parsers = [...configuration2.parsers];
+    this.refiners = [...configuration2.refiners];
+  }
+  clone() {
+    return new _Chrono({
+      parsers: [...this.parsers],
+      refiners: [...this.refiners]
+    });
   }
-  if (!cols.some((c) => c.name === "uuid")) {
-    db.exec(`ALTER TABLE tasks ADD COLUMN uuid TEXT`);
+  parseDate(text2, referenceDate, option) {
+    const results = this.parse(text2, referenceDate, option);
+    return results.length > 0 ? results[0].start.date() : null;
   }
-  const pending = db.prepare(`SELECT id FROM tasks WHERE uuid IS NULL`).all();
-  if (pending.length > 0) {
-    const setUuid = db.prepare(`UPDATE tasks SET uuid = ? WHERE id = ?`);
-    inTransaction(() => {
-      for (const row of pending) setUuid.run(randomUUID(), row.id);
+  parse(text2, referenceDate, option) {
+    const context = new ParsingContext(text2, referenceDate, option);
+    let results = [];
+    this.parsers.forEach((parser) => {
+      const parsedResults = _Chrono.executeParser(context, parser);
+      results = results.concat(parsedResults);
+    });
+    results.sort((a, b) => {
+      return a.index - b.index;
     });
+    this.refiners.forEach(function(refiner) {
+      results = refiner.refine(context, results);
+    });
+    return results;
   }
-}
-db.exec(`
-  CREATE INDEX IF NOT EXISTS idx_tasks_fingerprint ON tasks(fingerprint);
-  CREATE UNIQUE INDEX IF NOT EXISTS idx_tasks_uuid ON tasks(uuid);
-`);
-function ensureDeviceId() {
-  const row = db.prepare(`SELECT value FROM meta WHERE key = 'device_id'`).get();
-  if (row) return row.value;
-  const id = randomUUID();
-  db.prepare(
-    `INSERT OR IGNORE INTO meta (key, value) VALUES ('device_id', ?)`
-  ).run(id);
-  const final = db.prepare(`SELECT value FROM meta WHERE key = 'device_id'`).get();
-  return final.value;
-}
-var DEVICE_ID = ensureDeviceId();
-function nextLamport() {
-  const row = db.prepare(`SELECT MAX(lamport) as m FROM task_events WHERE device_id = ?`).get(DEVICE_ID);
-  return (row.m ?? 0) + 1;
-}
-var insertEventStmt = db.prepare(
-  `INSERT INTO task_events (event_uuid, task_uuid, op, payload, device_id, lamport)
-   VALUES (?, ?, ?, ?, ?, ?)`
-);
-function recordEvent(op, taskUuid, payload) {
-  insertEventStmt.run(
-    randomUUID(),
-    taskUuid,
-    op,
-    payload === null ? null : JSON.stringify(payload),
-    DEVICE_ID,
-    nextLamport()
-  );
-}
-var insertTaskStmt = db.prepare(
-  `INSERT INTO tasks (uuid, text, due_at, source, fingerprint) VALUES (?, ?, ?, ?, ?) RETURNING *`
-);
-var findOpenByFingerprintStmt = db.prepare(
-  `SELECT * FROM tasks WHERE fingerprint = ? AND completed_at IS NULL LIMIT 1`
-);
-var countDoneTodayStmt = db.prepare(
-  `SELECT COUNT(*) as n FROM tasks WHERE completed_at IS NOT NULL
-     AND date(completed_at, 'localtime') = date('now', 'localtime')`
-);
-var selectOpenStmt = db.prepare(
-  `SELECT * FROM tasks WHERE completed_at IS NULL ORDER BY
-     CASE WHEN due_at IS NULL THEN 1 ELSE 0 END, due_at ASC, created_at ASC`
-);
-var selectAllStmt = db.prepare(
-  `SELECT * FROM tasks ORDER BY created_at DESC LIMIT ?`
-);
-var selectRecentDoneStmt = db.prepare(
-  `SELECT * FROM tasks
-   WHERE completed_at IS NOT NULL
-     AND completed_at >= datetime('now', ?)
-   ORDER BY completed_at DESC`
-);
-var selectArchivedStmt = db.prepare(
-  `SELECT * FROM tasks
-   WHERE completed_at IS NOT NULL
-     AND completed_at < datetime('now', ?)
-   ORDER BY completed_at DESC
-   LIMIT ?`
-);
-var completeTaskFindStmt = db.prepare(
-  `SELECT uuid, completed_at FROM tasks WHERE id = ?`
-);
-var completeTaskUpdateStmt = db.prepare(
-  `UPDATE tasks SET completed_at = datetime('now') WHERE id = ? AND completed_at IS NULL`
-);
-var getTaskStmt = db.prepare(`SELECT * FROM tasks WHERE id = ?`);
-function fingerprint(text) {
-  return createHash("sha256").update(text.toLowerCase().replace(/\s+/g, " ").trim()).digest("hex").slice(0, 16);
-}
-function addTask(text, dueAt = null, source = "claude") {
-  const taskUuid = randomUUID();
-  const fp = fingerprint(text);
-  return inTransaction(() => {
-    const task = insertTaskStmt.get(taskUuid, text, dueAt, source, fp);
-    recordEvent("create", taskUuid, { text, due_at: dueAt, source });
-    return task;
-  });
-}
-function countDoneToday() {
-  return countDoneTodayStmt.get().n;
-}
-function listOpenTasks() {
-  return selectOpenStmt.all();
-}
-function listAllTasks(limit = 50) {
-  return selectAllStmt.all(limit);
-}
-function listRecentlyCompleted(hoursAgo = 24) {
-  return selectRecentDoneStmt.all(`-${hoursAgo} hours`);
-}
-function listArchived(hoursAgo = 24, limit = 100) {
-  return selectArchivedStmt.all(`-${hoursAgo} hours`, limit);
-}
-function completeTask(id) {
-  return inTransaction(() => {
-    const prior = completeTaskFindStmt.get(id);
-    if (!prior) return null;
-    const completed = prior.completed_at === null;
-    if (completed) {
-      completeTaskUpdateStmt.run(id);
-      recordEvent("complete", prior.uuid, null);
+  static executeParser(context, parser) {
+    const results = [];
+    const pattern = parser.pattern(context);
+    const originalText = context.text;
+    let remainingText = context.text;
+    let match = pattern.exec(remainingText);
+    while (match) {
+      const index = match.index + originalText.length - remainingText.length;
+      match.index = index;
+      const result = parser.extract(context, match);
+      if (!result) {
+        remainingText = originalText.substring(match.index + 1);
+        match = pattern.exec(remainingText);
+        continue;
+      }
+      let parsedResult = null;
+      if (result instanceof ParsingResult) {
+        parsedResult = result;
+      } else if (result instanceof ParsingComponents) {
+        parsedResult = context.createParsingResult(match.index, match[0]);
+        parsedResult.start = result;
+      } else {
+        parsedResult = context.createParsingResult(match.index, match[0], result);
+      }
+      const parsedIndex = parsedResult.index;
+      const parsedText = parsedResult.text;
+      context.debug(() => console.log(`${parser.constructor.name} extracted (at index=${parsedIndex}) '${parsedText}'`));
+      results.push(parsedResult);
+      remainingText = originalText.substring(parsedIndex + parsedText.length);
+      match = pattern.exec(remainingText);
     }
-    return { task: getTaskStmt.get(id), completed };
-  });
+    return results;
+  }
+};
+var ParsingContext = class {
+  text;
+  option;
+  reference;
+  refDate;
+  constructor(text2, refDate, option) {
+    this.text = text2;
+    this.option = option ?? {};
+    this.reference = ReferenceWithTimezone.fromInput(refDate, this.option.timezones);
+    this.refDate = this.reference.instant;
+  }
+  createParsingComponents(components) {
+    if (components instanceof ParsingComponents) {
+      return components;
+    }
+    return new ParsingComponents(this.reference, components);
+  }
+  createParsingResult(index, textOrEndIndex, startComponents, endComponents) {
+    const text2 = typeof textOrEndIndex === "string" ? textOrEndIndex : this.text.substring(index, textOrEndIndex);
+    const start = startComponents ? this.createParsingComponents(startComponents) : null;
+    const end = endComponents ? this.createParsingComponents(endComponents) : null;
+    return new ParsingResult(this.reference, index, text2, start, end);
+  }
+  debug(block) {
+    if (this.option.debug) {
+      if (this.option.debug instanceof Function) {
+        this.option.debug(block);
+      } else {
+        const handler = this.option.debug;
+        handler.debug(block);
+      }
+    }
+  }
+};
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/locales/en/index.js
+var configuration = new ENDefaultConfiguration();
+var casual = new Chrono(configuration.createCasualConfiguration(false));
+var strict = new Chrono(configuration.createConfiguration(true, false));
+var GB = new Chrono(configuration.createCasualConfiguration(true));
+
+// node_modules/.pnpm/chrono-node@2.10.1/node_modules/chrono-node/dist/esm/index.js
+var casual2 = casual;
+function parse3(text2, ref, option) {
+  return casual2.parse(text2, ref, option);
 }
 
 // src/dates.ts
+var ISO_DATE = /^\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2})?)?$/i;
+var PART_OF_DAY = /\b(?:morning|afternoon|evening|night|tonight|noon|midday|midnight)\b/i;
+function stamp(d) {
+  return d.toISOString().replace(/\.\d{3}Z$/, "Z");
+}
 function toStoredDue(input) {
   const s = input.trim();
   const d = /^\d{4}-\d{2}-\d{2}$/.test(s) ? /* @__PURE__ */ new Date(`${s}T09:00:00`) : new Date(s);
   if (Number.isNaN(d.getTime())) return null;
-  return d.toISOString().replace(/\.\d{3}Z$/, "Z");
-}
-function timeContext(now = /* @__PURE__ */ new Date()) {
-  const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
-  const weekday = (d) => d.toLocaleDateString("en-US", { weekday: "long" });
-  const ymd = (d) => `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
-  const hm = `${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}`;
-  const week = Array.from({ length: 7 }, (_, i) => {
-    const d = new Date(now.getFullYear(), now.getMonth(), now.getDate() + i + 1, 12);
-    return `${weekday(d)} ${ymd(d)}`;
+  return stamp(d);
+}
+function resolveDue(phrase, ref = /* @__PURE__ */ new Date()) {
+  const s = phrase.trim();
+  const base = { phrase: s, ref: stamp(ref) };
+  if (ISO_DATE.test(s)) return { ...base, at: toStoredDue(s) };
+  const [result] = parse3(s, ref, { forwardDate: true });
+  if (!result) return { ...base, at: null };
+  let d = result.start.date();
+  if (!result.start.isCertain("hour") && !PART_OF_DAY.test(result.text)) {
+    d = new Date(d.getFullYear(), d.getMonth(), d.getDate(), 9);
+    if (d < ref && d.toDateString() === ref.toDateString()) d.setHours(23, 59);
+  }
+  return { ...base, at: stamp(d) };
+}
+function resolveSince(phrase, ref = /* @__PURE__ */ new Date()) {
+  const s = phrase.trim();
+  if (ISO_DATE.test(s)) {
+    const d2 = /^\d{4}-\d{2}-\d{2}$/.test(s) ? /* @__PURE__ */ new Date(`${s}T00:00:00`) : new Date(s);
+    return Number.isNaN(d2.getTime()) ? null : stamp(d2);
+  }
+  const [result] = parse3(s, ref);
+  if (!result) return null;
+  const start = result.start;
+  const d = start.date();
+  if (!start.isCertain("hour")) d.setHours(0, 0, 0, 0);
+  if (d > ref && start.isCertain("weekday") && !start.isCertain("day")) d.setDate(d.getDate() - 7);
+  else if (d > ref && !start.isCertain("year")) d.setFullYear(d.getFullYear() - 1);
+  return stamp(d);
+}
+function describeDue(due2) {
+  if (!due2.at) return `couldn't read "${due2.phrase}" as a date, so no due date`;
+  const local = new Date(due2.at).toLocaleString("en-US", {
+    weekday: "short",
+    month: "short",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit",
+    hourCycle: "h23",
+    timeZoneName: "short"
   });
-  return `Now (user's local time, ${tz}): ${weekday(now)} ${ymd(now)} ${hm}.
-The next 7 days: ${week.join(", ")}.`;
+  return `due ${local} (${due2.at})` + (due2.phrase === due2.at ? "" : ` from "${due2.phrase}"`);
+}
+
+// src/provenance.ts
+var EXCERPT_MAX = 200;
+var REF_MAX = 500;
+var contextSchema = external_exports.object({
+  excerpt: external_exports.string().optional().describe(
+    `The user's words this task came from, quoted exactly as they said them, e.g. 'I really need to call the dentist before Friday'. The pane shows it when they hover over the task, so they can see why it's there. Kept to ${EXCERPT_MAX} characters.`
+  ),
+  ref: external_exports.string().optional().describe("Where it came from, if there's a pointer to it: a file path, URL, ticket, or email subject.")
+}).optional().describe("Where this task came from. Include it whenever you can: tasks nobody recognizes get deleted.");
+function cap(s, max) {
+  const flat = (s ?? "").replace(/\s+/g, " ").trim();
+  if (!flat) return null;
+  const chars = Array.from(flat);
+  return chars.length <= max ? flat : chars.slice(0, max - 1).join("").trimEnd() + "\u2026";
+}
+var CLIENT_NAMES = {
+  "claude-ai": "Claude Desktop",
+  "cursor-vscode": "Cursor"
+};
+function clientLabel(info) {
+  if (!info) return null;
+  return info.title || CLIENT_NAMES[info.name] || info.name;
+}
+function fromTool(client2, context) {
+  return {
+    client: client2,
+    ref: cap(context?.ref, REF_MAX),
+    excerpt: cap(context?.excerpt, EXCERPT_MAX)
+  };
+}
+
+// src/tools/duplicate.ts
+function alreadyListed(task) {
+  const due2 = task.due_at ? `, ${describeDue({ at: task.due_at, phrase: task.due_phrase ?? task.due_at, ref: "" })}` : "";
+  return `Already on the list as #${task.id}: ${task.text}${due2}. Not added again.`;
 }
 
 // src/tools/add_task.ts
 var addTaskSchema = {
   text: external_exports.string().min(1).describe("The task text, e.g. 'Call the dentist'"),
   due_at: external_exports.string().optional().describe(
-    "Optional due date/time, ISO 8601. With Z or an offset it's exact ('2026-04-24T15:00:00Z'); without one it's the user's local time ('2026-04-24T15:00'); a date alone means 09:00 local."
-  )
+    "Optional: when it's due, in the user's own words ('tomorrow', 'Friday 3pm', 'in 2 hours', 'next week'). Don't work out the date yourself; StickyInc does, in the user's time zone. Add am/pm to a bare hour. ISO 8601 works too: with Z or an offset it's exact, without one it's local time. No time of day means 09:00 local."
+  ),
+  context: contextSchema
 };
-async function handleAddTask(args) {
-  const dueAt = args.due_at ? toStoredDue(args.due_at) : null;
-  if (args.due_at && !dueAt) {
+async function handleAddTask(args, client2) {
+  const due2 = args.due_at ? resolveDue(args.due_at) : null;
+  if (due2 && !due2.at) {
     return {
       content: [
         {
           type: "text",
-          text: `due_at "${args.due_at}" isn't a date/time. Use ISO 8601, e.g. 2026-04-24T15:00:00Z.`
+          text: `due_at "${args.due_at}" isn't a date StickyInc can read. Try words like "Friday 5pm" or "in 3 days", or ISO 8601 (2026-04-24T17:00).`
         }
       ],
       isError: true
     };
   }
-  const task = addTask(args.text, dueAt);
-  const due = task.due_at ? ` (due ${task.due_at})` : "";
+  const { task, inserted } = addTaskUnique({ text: args.text, due: due2, from: fromTool(client2, args.context) });
+  if (!inserted) return { content: [{ type: "text", text: alreadyListed(task) }] };
+  const dueText = due2 ? `, ${describeDue(due2)}` : "";
   return {
     content: [
       {
         type: "text",
-        text: `Added task #${task.id}: ${task.text}${due}`
+        text: `Added task #${task.id}: ${task.text}${dueText}`
       }
     ]
   };
@@ -21287,9 +24355,9 @@ var AnthropicProvider = class {
       throw new Error(`Anthropic API error: ${res.status} ${await res.text()}`);
     }
     const data = await res.json();
-    const text = data.content.filter((b) => b.type === "text").map((b) => b.text ?? "").join("");
+    const text2 = data.content.filter((b) => b.type === "text").map((b) => b.text ?? "").join("");
     return {
-      content: text,
+      content: text2,
       model: data.model,
       provider: this.name,
       usage: { input: data.usage.input_tokens, output: data.usage.output_tokens }
@@ -21819,22 +24887,21 @@ async function resolveInternal() {
 var addTaskNaturalSchema = {
   input: external_exports.string().min(1).describe(
     "Free-text phrase like 'call dentist Friday 3pm' or 'buy bread'. Will be parsed by the configured LLM."
-  )
+  ),
+  context: contextSchema
 };
 var SYSTEM_PROMPT = `You convert a user phrase into a JSON task description.
 
 Output ONLY a single JSON object, no prose, no code fences. Schema:
 {
   "text": "<the thing to do, concise, no date>",
-  "due_at": "<local date-time YYYY-MM-DDTHH:MM, or null>"
+  "due": "<the words that say when, copied from the phrase, or null>"
 }
 
 Rules:
 - "text" is the action, cleaned of date/time phrasing.
-- "due_at" is the user's local time, with no offset or Z, or null if no time is implied. Take weekdays and "tomorrow" from the dates listed below.
-- A weekday means its next occurrence; if that is today and the time has already passed, the one a week later.
-- If a date is given without a time, use 09:00.
-- If only a time is given, use today (or tomorrow if that time has passed).`;
+- "due" copies the date/time words as written ("Friday 3pm", "tomorrow", "in 2 hours", "next week"), or null if the phrase doesn't say when.
+- Don't work out a date; copy the words. If an hour has no am/pm, add the one the user means.`;
 function stripFences(s) {
   return s.replace(/^\s*```(?:json)?\s*/i, "").replace(/\s*```\s*$/, "").trim();
 }
@@ -21858,9 +24925,7 @@ async function parseTask(input) {
   const res = await provider.chat({
     system: SYSTEM_PROMPT,
     messages: [
-      { role: "user", content: `${timeContext()}
-
-Phrase: ${input}` }
+      { role: "user", content: `Phrase: ${input}` }
     ],
     response_format: "json",
     max_tokens: 200,
@@ -21872,19 +24937,24 @@ Phrase: ${input}` }
   }
   return {
     text: parsed.text,
-    due_at: typeof parsed.due_at === "string" ? toStoredDue(parsed.due_at) : null
+    due: typeof parsed.due === "string" && parsed.due.trim() ? resolveDue(parsed.due) : null
   };
 }
-async function handleAddTaskNatural(args) {
+async function handleAddTaskNatural(args, client2) {
   try {
     const parsed = await parseTask(args.input);
-    const task = addTask(parsed.text, parsed.due_at);
-    const due = task.due_at ? ` (due ${task.due_at})` : "";
+    const { task, inserted } = addTaskUnique({
+      text: parsed.text,
+      due: parsed.due,
+      from: fromTool(client2, args.context)
+    });
+    if (!inserted) return { content: [{ type: "text", text: alreadyListed(task) }] };
+    const due2 = parsed.due ? `, ${describeDue(parsed.due)}` : "";
     return {
       content: [
         {
           type: "text",
-          text: `Parsed & added task #${task.id}: ${task.text}${due}`
+          text: `Parsed & added task #${task.id}: ${task.text}${due2}`
         }
       ]
     };
@@ -21911,8 +24981,8 @@ async function handleListTasks(args) {
   }
   const lines = tasks.map((t) => {
     const mark = t.completed_at ? "[x]" : "[ ]";
-    const due = t.due_at ? ` \u2014 due ${t.due_at}` : "";
-    return `${mark} #${t.id} ${t.text}${due}`;
+    const due2 = t.due_at ? ` \u2014 due ${t.due_at}` : "";
+    return `${mark} #${t.id} ${t.text}${due2}`;
   });
   const doneToday = countDoneToday();
   if (doneToday > 0) {
@@ -21949,31 +25019,38 @@ async function handleCompleteTask(args) {
 var scheduleEventSchema = {
   title: external_exports.string().min(1).describe("Event title"),
   start: external_exports.string().describe(
-    "Start, ISO 8601. With Z or an offset it's exact ('2026-04-24T15:00:00Z'); without one it's the user's local time."
+    "When it starts, in the user's own words ('Friday 3pm', 'tomorrow at 10am'); StickyInc works out the date in their time zone. Or ISO 8601: with Z or an offset it's exact, without one local."
   ),
   end: external_exports.string().optional().describe("Optional end, ISO 8601. Echoed back, not stored."),
-  notes: external_exports.string().optional().describe("Optional notes/description")
+  notes: external_exports.string().optional().describe("Optional notes/description"),
+  context: contextSchema
 };
-async function handleScheduleEvent(args) {
-  const start = toStoredDue(args.start);
-  if (!start) {
+async function handleScheduleEvent(args, client2) {
+  const start = resolveDue(args.start);
+  if (!start.at) {
     return {
       content: [
         {
           type: "text",
-          text: `start "${args.start}" isn't a date/time. Use ISO 8601, e.g. 2026-04-24T15:00:00Z.`
+          text: `start "${args.start}" isn't a date StickyInc can read. Try words like "Friday 3pm", or ISO 8601 (2026-04-24T15:00).`
         }
       ],
       isError: true
     };
   }
-  const text = args.notes ? `${args.title} \u2014 ${args.notes}` : args.title;
-  const task = addTask(text, start, "calendar");
+  const text2 = args.notes ? `${args.title} \u2014 ${args.notes}` : args.title;
+  const { task, inserted } = addTaskUnique({
+    text: text2,
+    due: start,
+    source: "calendar",
+    from: fromTool(client2, args.context)
+  });
+  if (!inserted) return { content: [{ type: "text", text: alreadyListed(task) }] };
   return {
     content: [
       {
         type: "text",
-        text: `Scheduled task #${task.id}: ${args.title} @ ${start}` + (args.end ? ` \u2192 ${args.end}` : "") + `
+        text: `Scheduled task #${task.id}: ${args.title}, ${describeDue(start)}` + (args.end ? ` \u2192 ${args.end}` : "") + `
 (If you want this on your Google Calendar too, ask me in the same turn \u2014 I'll use my Google Calendar connector. StickyInc only stores it locally.)`
       }
     ]
@@ -22009,19 +25086,285 @@ async function handleListDone(args) {
   return { content: [{ type: "text", text: lines.join("\n") }] };
 }
 
+// src/format.ts
+function sqliteUtcMs(s) {
+  return Date.parse(s.replace(" ", "T") + "Z");
+}
+function addedOn(sqliteUtc) {
+  return new Date(sqliteUtcMs(sqliteUtc)).toLocaleDateString("en-US", {
+    weekday: "short",
+    month: "short",
+    day: "numeric"
+  });
+}
+function ago(sqliteUtc, now2 = Date.now()) {
+  const days = Math.floor((now2 - sqliteUtcMs(sqliteUtc)) / 864e5);
+  if (days < 1) return "today";
+  if (days === 1) return "yesterday";
+  if (days < 14) return `${days} days ago`;
+  if (days < 60) return `${Math.round(days / 7)} weeks ago`;
+  return `${Math.round(days / 30)} months ago`;
+}
+function describeTask(t, now2 = Date.now()) {
+  const mark = t.completed_at ? "[x]" : "[ ]";
+  const from = t.source_client ? ` from ${t.source_client}` : "";
+  const due2 = t.due_at ? ` \u2014 ${describeDue({ at: t.due_at, phrase: t.due_phrase ?? t.due_at, ref: "" })}` : "";
+  const page = t.source_ref?.startsWith("http") ? ` \u2014 ${t.source_ref}` : "";
+  const line = `${mark} #${t.id} ${t.text} \u2014 added ${addedOn(t.created_at)} (${ago(t.created_at, now2)})${from}${due2}${page}`;
+  return t.source_excerpt ? `${line}
+    \u201C${t.source_excerpt}\u201D` : line;
+}
+
+// src/tools/sticky_search.ts
+var MAX_RESULTS = 20;
+var stickySearchSchema = {
+  query: external_exports.string().optional().describe(
+    "Words to look for in the task or in what the user said when it was added, e.g. 'dentist'. Leave out to list by status and date alone."
+  ),
+  status: external_exports.enum(["open", "done", "all"]).optional().describe("open (not done yet), done, or all. Default: all."),
+  since: external_exports.string().optional().describe(
+    "Only tasks added since then: the user's words ('3 weeks ago', 'last month', 'September 1') or ISO 8601."
+  )
+};
+async function handleStickySearch(args) {
+  const since = args.since ? resolveSince(args.since) : void 0;
+  if (args.since && !since) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `since "${args.since}" isn't a date StickyInc can read. Try "3 weeks ago", "last month", or 2026-09-01.`
+        }
+      ],
+      isError: true
+    };
+  }
+  const rows = searchTasks({ query: args.query, status: args.status, since: since ?? void 0, limit: MAX_RESULTS + 1 });
+  const what = [
+    args.query ? `matching "${args.query}"` : null,
+    args.status && args.status !== "all" ? `${args.status}` : null,
+    args.since ? `added since ${args.since}` : null
+  ].filter(Boolean).join(", ");
+  if (rows.length === 0) {
+    return { content: [{ type: "text", text: `No tasks${what ? ` ${what}` : ""}.` }] };
+  }
+  const shown = rows.slice(0, MAX_RESULTS);
+  const more = rows.length > MAX_RESULTS ? `
+
+(More than ${MAX_RESULTS} match; narrow the search to see the rest.)` : "";
+  return {
+    content: [
+      {
+        type: "text",
+        text: `${shown.length} task${shown.length === 1 ? "" : "s"}${what ? ` ${what}` : ""}:
+
+${shown.map((t) => describeTask(t)).join("\n")}${more}`
+      }
+    ]
+  };
+}
+
+// src/prompts.ts
+var DAY = 864e5;
+function actionList(scope, max) {
+  return `End with an **Action list**: at most ${max} concrete next steps ${scope}, most important first, numbered, each naming its task number, e.g. "1. Call the dentist (#12) before 10am". If I agree something is done or should be dropped, mark it with complete_task.`;
+}
+function section(title, tasks, now2) {
+  if (tasks.length === 0) return "";
+  return `## ${title} (${tasks.length})
+${tasks.map((t) => describeTask(t, now2)).join("\n")}
+`;
+}
+var due = (t) => t.due_at ? Date.parse(t.due_at) : Infinity;
+var byDue = (a, b) => due(a) - due(b);
+var byAdded = (a, b) => sqliteUtcMs(a.created_at) - sqliteUtcMs(b.created_at);
+function endOfDay(now2) {
+  return new Date(now2.getFullYear(), now2.getMonth(), now2.getDate() + 1).getTime();
+}
+function today2(now2) {
+  return now2.toLocaleDateString("en-US", { weekday: "long", month: "long", day: "numeric" });
+}
+function morningReview(open, now2 = /* @__PURE__ */ new Date()) {
+  const t = now2.getTime();
+  const eod = endOfDay(now2);
+  const dated = open.filter((x) => x.due_at).sort(byDue);
+  const overdue = dated.filter((x) => due(x) < t);
+  const dueToday = dated.filter((x) => due(x) >= t && due(x) < eod);
+  const thisWeek = dated.filter((x) => due(x) >= eod && due(x) < t + 7 * DAY);
+  const undated = open.filter((x) => !x.due_at).sort(byAdded).slice(0, 10);
+  const body = section("Overdue", overdue, t) + section("Due today", dueToday, t) + section("Due in the next 7 days", thisWeek, t) + section("No due date (oldest first)", undated, t);
+  return [
+    `Morning review for ${today2(now2)}. Here's what's on my StickyInc list:`,
+    body || "Nothing is open.",
+    "Go through it with me: what matters most today, what's slipping, and what I should reschedule or drop. Point out anything I've been carrying for a long time.",
+    actionList("for today", 5)
+  ].join("\n\n");
+}
+function overdueReview(open, now2 = /* @__PURE__ */ new Date()) {
+  const t = now2.getTime();
+  const overdue = open.filter((x) => x.due_at && due(x) < t).sort(byDue);
+  if (overdue.length === 0) {
+    const upcoming = open.filter((x) => x.due_at && due(x) < t + 7 * DAY).sort(byDue);
+    return [
+      `Nothing on my StickyInc list is overdue as of ${today2(now2)}.`,
+      section("Due in the next 7 days", upcoming, t) || "Nothing is due in the next 7 days either.",
+      "Tell me I'm clear, then suggest what to get ahead on.",
+      actionList("to get ahead", 3)
+    ].join("\n\n");
+  }
+  return [
+    `These StickyInc tasks are overdue as of ${today2(now2)}, with when I added them and the words they came from:`,
+    section("Overdue", overdue, t),
+    "For each one, say whether I should do it now, reschedule it (to when), or drop it, and why, going by what I said when I added it.",
+    actionList("to clear the backlog", 7)
+  ].join("\n\n");
+}
+function weeklyCloseout(open, doneThisWeek, now2 = /* @__PURE__ */ new Date()) {
+  const t = now2.getTime();
+  const weekAgo = t - 7 * DAY;
+  const addedThisWeek = open.filter((x) => sqliteUtcMs(x.created_at) >= weekAgo).sort(byAdded);
+  const dated = open.filter((x) => x.due_at).sort(byDue);
+  const overdue = dated.filter((x) => due(x) < t);
+  const nextWeek = dated.filter((x) => due(x) >= t && due(x) < t + 7 * DAY);
+  const body = section("Done in the last 7 days", doneThisWeek, t) + section("Added this week and still open", addedThisWeek, t) + section("Overdue", overdue, t) + section("Due in the next 7 days", nextWeek, t);
+  return [
+    `Weekly close-out, ${today2(now2)}. Here's my week in StickyInc:`,
+    body || "Nothing was done or added this week, and nothing is due.",
+    "Close out the week with me: what got done, what slipped and why it might have, and what to carry into next week versus drop.",
+    actionList("for next week", 7)
+  ].join("\n\n");
+}
+
+// src/routines.ts
+var BUILT_IN_PROMPTS = ["morning_review", "overdue", "weekly_closeout"];
+var PROMPT_MAX = 4e3;
+var SCHEDULE_MAX = 100;
+function routineName(name) {
+  const slug = name.normalize("NFKD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 40).replace(/_+$/, "");
+  return /^[a-z0-9]/.test(slug) ? slug : null;
+}
+function checkRoutine(input) {
+  if (!input || typeof input !== "object") return { error: "a routine is an object with a name and a prompt" };
+  const { name, prompt, schedule } = input;
+  if (typeof name !== "string" || !routineName(name)) return { error: "it needs a name with letters or digits in it" };
+  const slug = routineName(name);
+  if (BUILT_IN_PROMPTS.includes(slug)) return { error: `"${slug}" is a built-in prompt; pick another name` };
+  if (typeof prompt !== "string" || !prompt.trim()) return { error: `"${slug}" needs a prompt` };
+  if (prompt.length > PROMPT_MAX) return { error: `"${slug}": the prompt is over ${PROMPT_MAX} characters` };
+  if (schedule != null && (typeof schedule !== "string" || schedule.length > SCHEDULE_MAX)) {
+    return { error: `"${slug}": the schedule should be a short phrase like "weekdays at 8:30"` };
+  }
+  return { routine: { name: slug, prompt: prompt.trim(), schedule: schedule ? String(schedule).trim() : null } };
+}
+function parseRoutines(json) {
+  let data;
+  try {
+    data = JSON.parse(json);
+  } catch (e) {
+    return { error: `that isn't JSON (${e instanceof Error ? e.message : e})` };
+  }
+  const items = Array.isArray(data) ? data : [data];
+  if (items.length === 0) return { error: "there are no routines in it" };
+  const routines = [];
+  for (const [i, item] of items.entries()) {
+    const checked = checkRoutine(item);
+    if ("error" in checked) return { error: items.length > 1 ? `routine ${i + 1}: ${checked.error}` : checked.error };
+    routines.push(checked.routine);
+  }
+  const names = routines.map((r) => r.name);
+  const dup = names.find((n, i) => names.indexOf(n) !== i);
+  if (dup) return { error: `"${dup}" appears twice` };
+  return { routines };
+}
+function exportRoutines(routines) {
+  return JSON.stringify(
+    routines.map(({ name, prompt, schedule }) => ({ name, prompt, schedule: schedule ?? null })),
+    null,
+    2
+  );
+}
+function routinePromptText(r) {
+  return `${r.prompt}
+
+(This is my StickyInc routine "${r.name}". Look up what it needs with sticky_search.)`;
+}
+
+// src/tools/routines.ts
+var text = (t, isError = false) => ({
+  content: [{ type: "text", text: t }],
+  ...isError && { isError: true }
+});
+var howToRun = (name) => `Run it from the prompt menu, or in Claude Code as /mcp__stickyinc__${name}.`;
+var routineListSchema = {
+  format: external_exports.enum(["text", "json"]).optional().describe("text (default) to read them, or json to export them for sharing or backup.")
+};
+async function handleRoutineList(args) {
+  const routines = listRoutines();
+  if (args.format === "json") return text(exportRoutines(routines));
+  if (routines.length === 0) {
+    return text("No routines yet. Save one with sticky_routine_save, or import some with sticky_routine_import.");
+  }
+  const lines = routines.map(
+    (r) => `\u2022 ${r.name}${r.schedule ? ` (${r.schedule})` : ""}
+  ${r.prompt.replace(/\s+/g, " ").slice(0, 160)}`
+  );
+  return text(`${routines.length} routine${routines.length === 1 ? "" : "s"}:
+
+${lines.join("\n")}
+
+${howToRun("<name>")}`);
+}
+var routineSaveSchema = {
+  name: external_exports.string().min(1).describe("Short name, e.g. 'waiting on others'; stored as waiting_on_others."),
+  prompt: external_exports.string().min(1).max(PROMPT_MAX).describe("What to ask when it runs, e.g. 'What am I waiting on from other people? Who should I chase?'"),
+  schedule: external_exports.string().optional().describe("When it's meant to run, in words ('weekdays at 8:30', 'Fridays at 4pm'). A hint for whatever runs it.")
+};
+async function handleRoutineSave(args, onChange) {
+  const checked = checkRoutine(args);
+  if ("error" in checked) return text(`Can't save that routine: ${checked.error}.`, true);
+  const isNew = saveRoutine(checked.routine);
+  onChange();
+  return text(`${isNew ? "Saved" : "Updated"} routine "${checked.routine.name}". ${howToRun(checked.routine.name)}`);
+}
+var routineDeleteSchema = {
+  name: external_exports.string().min(1).describe("The routine's name.")
+};
+async function handleRoutineDelete(args, onChange) {
+  const name = routineName(args.name) ?? args.name;
+  if (!deleteRoutine(name)) return text(`There's no routine called "${name}".`, true);
+  onChange();
+  return text(`Deleted routine "${name}".`);
+}
+var routineImportSchema = {
+  json: external_exports.string().min(1).describe(
+    'Routines as JSON: one {"name", "prompt", "schedule"} object or an array of them, as sticky_routine_list exports. Routines with the same name are replaced.'
+  )
+};
+async function handleRoutineImport(args, onChange) {
+  const parsed = parseRoutines(args.json);
+  if ("error" in parsed) return text(`Nothing imported: ${parsed.error}.`, true);
+  const added = parsed.routines.filter((r) => saveRoutine(r)).length;
+  onChange();
+  const replaced = parsed.routines.length - added;
+  return text(
+    `Imported ${parsed.routines.map((r) => r.name).join(", ")} (${added} new${replaced ? `, ${replaced} replaced` : ""}). ${howToRun("<name>")}`
+  );
+}
+
 // src/index.ts
 var server = new McpServer({
   name: "stickyinc",
-  version: "0.5.2"
+  version: "0.6.0"
 });
+var client = () => clientLabel(server.server.getClientVersion());
 server.registerTool(
   "add_task",
   {
     title: "Add Task",
-    description: "Add a todo to StickyInc. The user sees it appear in their floating pane.",
+    description: "Add a todo to StickyInc. The user sees it appear in their floating pane, and hovering over it shows context.excerpt: quote their words so they can tell where it came from.",
     inputSchema: addTaskSchema
   },
-  handleAddTask
+  (args) => handleAddTask(args, client())
 );
 server.registerTool(
   "add_task_natural",
@@ -22030,7 +25373,7 @@ server.registerTool(
     description: "Parse a free-text phrase like 'call dentist Friday 3pm' into a task with optional due date, using the configured LLM (Anthropic/OpenRouter/OpenAI).",
     inputSchema: addTaskNaturalSchema
   },
-  handleAddTaskNatural
+  (args) => handleAddTaskNatural(args, client())
 );
 server.registerTool(
   "list_tasks",
@@ -22066,7 +25409,113 @@ server.registerTool(
     description: "Save an event as a StickyInc task due at its start time. StickyInc doesn't sync calendars; use a calendar connector for that.",
     inputSchema: scheduleEventSchema
   },
-  handleScheduleEvent
+  (args) => handleScheduleEvent(args, client())
+);
+server.registerTool(
+  "sticky_search",
+  {
+    title: "Search Tasks",
+    description: `Search everything the user has put in StickyInc, open and done, by words in the task or in what they said when it was added, optionally only since a date. Use it to remind them what they committed to and when, e.g. "you said you'd call the dentist three weeks ago". Returns up to 20 tasks, best match first.`,
+    inputSchema: stickySearchSchema
+  },
+  handleStickySearch
+);
+var openTasks = () => searchTasks({ status: "open", limit: 500 });
+var asPrompt = (text2) => ({
+  messages: [{ role: "user", content: { type: "text", text: text2 } }]
+});
+server.registerPrompt(
+  "morning_review",
+  {
+    title: "Morning review",
+    description: "Go through today's StickyInc list (overdue, due today, this week) and end with an action list for today."
+  },
+  () => asPrompt(morningReview(openTasks()))
+);
+server.registerPrompt(
+  "overdue",
+  {
+    title: "Overdue",
+    description: "Decide what to do about each overdue StickyInc task (do now, reschedule, or drop), ending with an action list."
+  },
+  () => asPrompt(overdueReview(openTasks()))
+);
+server.registerPrompt(
+  "weekly_closeout",
+  {
+    title: "Weekly close-out",
+    description: "Review the week in StickyInc (done, slipped, due next) and end with an action list for next week."
+  },
+  () => {
+    const weekAgo = new Date(Date.now() - 7 * 864e5).toISOString();
+    const done = searchTasks({ status: "done", completedSince: weekAgo, limit: 200 });
+    return asPrompt(weeklyCloseout(openTasks(), done));
+  }
+);
+var routinePrompts = /* @__PURE__ */ new Map();
+var describeRoutine = (prompt, schedule) => `Your routine${schedule ? ` (${schedule})` : ""}: ${prompt.replace(/\s+/g, " ").slice(0, 120)}`;
+function syncRoutinePrompts() {
+  const routines = listRoutines();
+  const names = new Set(routines.map((r) => r.name));
+  for (const [name, registered] of routinePrompts) {
+    if (!names.has(name)) {
+      registered.remove();
+      routinePrompts.delete(name);
+    }
+  }
+  for (const r of routines) {
+    const description = describeRoutine(r.prompt, r.schedule);
+    const registered = routinePrompts.get(r.name);
+    if (!registered) {
+      routinePrompts.set(
+        r.name,
+        server.registerPrompt(r.name, { title: r.name.replace(/_/g, " "), description }, () => {
+          const current = listRoutines().find((x) => x.name === r.name) ?? r;
+          return asPrompt(routinePromptText(current));
+        })
+      );
+    } else if (registered.description !== description) {
+      registered.update({ description });
+    }
+  }
+}
+server.registerTool(
+  "sticky_routine_list",
+  {
+    title: "List Routines",
+    description: "List the user's StickyInc routines (saved prompts they run on a schedule or by hand), or export them as JSON.",
+    inputSchema: routineListSchema
+  },
+  handleRoutineList
+);
+server.registerTool(
+  "sticky_routine_save",
+  {
+    title: "Save Routine",
+    description: "Save a routine: a named prompt the user wants to run regularly, like a Friday check on what they're waiting on from others. Replaces one with the same name. It shows up as a prompt they can run.",
+    inputSchema: routineSaveSchema
+  },
+  (args) => handleRoutineSave(args, syncRoutinePrompts)
+);
+server.registerTool(
+  "sticky_routine_delete",
+  {
+    title: "Delete Routine",
+    description: "Delete one of the user's StickyInc routines by name.",
+    inputSchema: routineDeleteSchema
+  },
+  (args) => handleRoutineDelete(args, syncRoutinePrompts)
+);
+server.registerTool(
+  "sticky_routine_import",
+  {
+    title: "Import Routines",
+    description: "Import routines from JSON (one routine or an array, as sticky_routine_list exports), e.g. ones someone shared.",
+    inputSchema: routineImportSchema
+  },
+  (args) => handleRoutineImport(args, syncRoutinePrompts)
 );
+syncRoutinePrompts();
+setInterval(syncRoutinePrompts, 3e4).unref();
 var transport = new StdioServerTransport();
 await server.connect(transport);