@ghostpaw/questlog 0.9.2 → 0.11.0

package/dist/chunk-RBGQK5WP.js

@@ -0,0 +1,949 @@
+#!/usr/bin/env node
+import { listDeliveries } from './chunk-D6EGZCT7.js';
+import { listHooks } from './chunk-NBCCA6AX.js';
+import { randomBytes, createHmac } from 'node:crypto';
+import { basename, extname } from 'node:path';
+
+// src/with_transaction.ts
+var transactionDepth = /* @__PURE__ */ new WeakMap();
+function withTransaction(db, fn) {
+  const depth = transactionDepth.get(db) ?? 0;
+  const savepoint = `questlog_${depth}`;
+  if (depth === 0) {
+    db.exec("BEGIN IMMEDIATE");
+  } else {
+    db.exec(`SAVEPOINT ${savepoint}`);
+  }
+  transactionDepth.set(db, depth + 1);
+  try {
+    const result = fn();
+    if (depth === 0) {
+      db.exec("COMMIT");
+    } else {
+      db.exec(`RELEASE SAVEPOINT ${savepoint}`);
+    }
+    transactionDepth.set(db, depth);
+    return result;
+  } catch (error) {
+    try {
+      if (depth === 0) {
+        db.exec("ROLLBACK");
+      } else {
+        db.exec(`ROLLBACK TO SAVEPOINT ${savepoint}`);
+        db.exec(`RELEASE SAVEPOINT ${savepoint}`);
+      }
+    } catch {
+    }
+    transactionDepth.set(db, depth);
+    throw error;
+  }
+}
+
+// src/tags/normalize_tag_name.ts
+function normalizeTagName(name) {
+  return name.trim().toLowerCase().replace(/\s+/g, " ");
+}
+
+// src/hooks/types.ts
+var hookEventTypes = [
+  "quest.due",
+  "quest.overdue",
+  "quest.unblocked",
+  "repeatable.spawned",
+  "rumor.captured"
+];
+
+// src/hooks/add_hook.ts
+function addHook(db, input) {
+  let url;
+  try {
+    url = new URL(input.url);
+  } catch {
+    throw new Error("Expected an HTTP or HTTPS URL");
+  }
+  if (!["http:", "https:"].includes(url.protocol))
+    throw new Error(`unsupported scheme ${url.protocol}; use http or https`);
+  if (url.username || url.password)
+    throw new Error(
+      "URL userinfo is not supported; use a custom header (--header or --header-stdin) or a query key instead"
+    );
+  const minGap = input.minGap ?? 60;
+  if (!Number.isSafeInteger(minGap) || minGap < 0)
+    throw new Error("Min gap must be a nonnegative integer");
+  const events = input.events ?? [...hookEventTypes];
+  if (!events.length || events.some((e) => !hookEventTypes.includes(e)))
+    throw new Error(
+      `unknown event ${events.find((e) => !hookEventTypes.includes(e)) ?? "(empty)"}; valid: ${hookEventTypes.join(", ")}`
+    );
+  if (input.tag !== void 0 && !normalizeTagName(input.tag))
+    throw new Error("Expected a tag name");
+  const secret = input.secret ?? randomBytes(32).toString("hex");
+  if (!secret.trim()) throw new Error("Expected a nonempty signing secret");
+  const result = db.prepare(
+    "INSERT INTO hook_targets(url, secret, tag, events, min_gap, created_at) VALUES (?, ?, ?, ?, ?, ?)"
+  ).run(
+    url.href,
+    secret,
+    input.tag === void 0 ? null : normalizeTagName(input.tag),
+    JSON.stringify(events),
+    minGap,
+    input.now ?? Date.now()
+  );
+  return { id: Number(result.lastInsertRowid), secret };
+}
+function hookLabel(db, name) {
+  if (name !== void 0) {
+    if (!name.trim()) throw new Error("Expected a nonempty database label");
+    db.prepare(
+      "INSERT INTO hook_settings(id, label) VALUES (1, ?) ON CONFLICT(id) DO UPDATE SET label = excluded.label"
+    ).run(name);
+  }
+  const saved = db.prepare("SELECT label FROM hook_settings WHERE id = 1").get();
+  if (saved) return String(saved.label);
+  const path = String(
+    db.prepare("PRAGMA database_list").all().find((row) => row.name === "main")?.file ?? ""
+  );
+  return path ? basename(path, extname(path)) : "questlog";
+}
+
+// src/hooks/remove_hook.ts
+function removeHook(db, id) {
+  withTransaction(db, () => {
+    db.prepare("DELETE FROM hook_assignments WHERE target_id = ?").run(id);
+    db.prepare("DELETE FROM hook_deliveries WHERE target_id = ?").run(id);
+    db.prepare("DELETE FROM hook_targets WHERE id = ?").run(id);
+  });
+}
+
+// src/version.ts
+var questlogVersion = "0.11.0";
+
+// src/hooks/send_hook_delivery.ts
+async function sendHookDelivery(db, delivery, target, options) {
+  const now = options.now ?? options.clock?.() ?? Date.now();
+  const timestamp = String(Math.floor(now / 1e3));
+  const body = JSON.stringify({
+    type: "questlog.events",
+    db: hookLabel(db),
+    deliveryId: delivery.id,
+    sentAt: new Date(now).toISOString(),
+    events: delivery.events
+  });
+  const signature = createHmac("sha256", target.secret).update(`${timestamp}.${body}`).digest("hex");
+  let status = null;
+  let errorClass = null;
+  try {
+    const response = await (options.fetch ?? globalThis.fetch)(target.url, {
+      method: "POST",
+      redirect: "error",
+      headers: {
+        "user-agent": `questlog/${questlogVersion}`,
+        ...JSON.parse(
+          String(
+            db.prepare("SELECT headers FROM hook_targets WHERE id = ?").get(target.id)?.headers ?? "{}"
+          )
+        ),
+        "content-type": "application/json",
+        "x-questlog-delivery": delivery.id,
+        "x-questlog-timestamp": timestamp,
+        "x-questlog-signature": `sha256=${signature}`
+      },
+      body,
+      signal: AbortSignal.timeout(Math.max(1, Math.min(options.timeoutMs ?? 5e3, 5e3)))
+    });
+    status = response.status;
+    await response.body?.cancel();
+  } catch (error) {
+    errorClass = error instanceof Error && ["TimeoutError", "AbortError"].includes(error.name) ? error.name : "NetworkError";
+  }
+  const delivered = status != null && status >= 200 && status < 300;
+  const completedAt = options.now ?? options.clock?.() ?? Date.now();
+  withTransaction(db, () => {
+    if (!db.prepare("SELECT id FROM hook_targets WHERE id = ? AND claim = ?").get(target.id, target.claim))
+      return;
+    const delay = Math.min(36e5, 3e4 * 2 ** (delivery.attempts - 1));
+    const jitter = Number.parseInt(randomBytes(2).toString("hex"), 16) % 1e3;
+    db.prepare(
+      "UPDATE hook_deliveries SET status = ?, http_status = ?, error_class = ?, next_attempt_at = ? WHERE id = ?"
+    ).run(
+      delivered ? "delivered" : delivery.attempts >= 8 ? "failed" : "pending",
+      status,
+      errorClass,
+      completedAt + delay + jitter,
+      delivery.id
+    );
+    db.prepare(
+      "UPDATE hook_targets SET claim = NULL, lease_until = NULL WHERE id = ? AND claim = ?"
+    ).run(target.id, target.claim);
+    db.prepare(
+      "DELETE FROM hook_deliveries WHERE target_id = ? AND status = 'delivered' AND id NOT IN (SELECT id FROM hook_deliveries WHERE target_id = ? AND status = 'delivered' ORDER BY last_attempt_at DESC, id DESC LIMIT 500)"
+    ).run(target.id, target.id);
+  });
+  return delivered;
+}
+
+// src/hooks/test_hook.ts
+async function testHook(db, id, options = {}) {
+  const now = options.now ?? options.clock?.() ?? Date.now();
+  const claim = randomBytes(16).toString("hex");
+  const delivery = {
+    id: `d_${randomBytes(16).toString("hex")}`,
+    targetId: id,
+    events: [
+      {
+        id: `e_test_${randomBytes(16).toString("hex")}`,
+        type: "hook.test",
+        occurredAt: new Date(now).toISOString()
+      }
+    ],
+    status: "pending",
+    attempts: 1,
+    lastAttemptAt: now,
+    httpStatus: null,
+    errorClass: null,
+    nextAttemptAt: now
+  };
+  const target = withTransaction(db, () => {
+    const row = db.prepare("SELECT url, secret, lease_until FROM hook_targets WHERE id = ?").get(id);
+    if (!row) throw new Error("Hook not found");
+    if (row.lease_until != null && Number(row.lease_until) > now)
+      throw new Error("Hook delivery is in progress");
+    db.prepare(
+      "INSERT INTO hook_deliveries(id, target_id, events, status, attempts, last_attempt_at, next_attempt_at) VALUES (?, ?, ?, ?, ?, ?, ?)"
+    ).run(delivery.id, id, JSON.stringify(delivery.events), "pending", 1, now, now);
+    db.prepare(
+      "UPDATE hook_targets SET claim = ?, lease_until = ?, last_wake = ? WHERE id = ?"
+    ).run(claim, now + 12e4, now, id);
+    return { id, url: String(row.url), secret: String(row.secret), claim };
+  });
+  return { id: delivery.id, delivered: await sendHookDelivery(db, delivery, target, options) };
+}
+
+// src/quests/map_quest_row.ts
+function asBoolean(value) {
+  return Number(value) === 1;
+}
+function mapQuestRow(row) {
+  return {
+    id: Number(row.id),
+    questlineId: row.questline_id == null ? null : Number(row.questline_id),
+    sourceRumorId: row.source_rumor_id == null ? null : Number(row.source_rumor_id),
+    spawnedByQuestId: row.spawned_by_quest_id == null ? null : Number(row.spawned_by_quest_id),
+    spawnedFromRepeatableId: row.spawned_from_repeatable_id == null ? null : Number(row.spawned_from_repeatable_id),
+    spawnedForAt: row.spawned_for_at == null ? null : Number(row.spawned_for_at),
+    title: String(row.title),
+    objective: String(row.objective),
+    outcome: row.outcome == null ? null : String(row.outcome),
+    createdAt: Number(row.created_at),
+    updatedAt: Number(row.updated_at),
+    startedAt: row.started_at == null ? null : Number(row.started_at),
+    resolvedAt: row.resolved_at == null ? null : Number(row.resolved_at),
+    success: row.success == null ? null : asBoolean(row.success),
+    effortSeconds: Number(row.effort_seconds),
+    estimateSeconds: row.estimate_seconds == null ? null : Number(row.estimate_seconds),
+    notBeforeAt: row.not_before_at == null ? null : Number(row.not_before_at),
+    dueAt: row.due_at == null ? null : Number(row.due_at),
+    scheduledStartAt: row.scheduled_start_at == null ? null : Number(row.scheduled_start_at),
+    scheduledEndAt: row.scheduled_end_at == null ? null : Number(row.scheduled_end_at),
+    allDay: asBoolean(row.all_day),
+    deletedAt: row.deleted_at == null ? null : Number(row.deleted_at)
+  };
+}
+
+// src/quests/get_quest_or_throw.ts
+function getQuestOrThrow(db, questId) {
+  const row = db.prepare("SELECT * FROM quests WHERE id = ? AND deleted_at IS NULL").get(questId);
+  if (!row) {
+    throw new Error(`Quest ${questId} was not found.`);
+  }
+  return mapQuestRow(row);
+}
+
+// src/resolve_now.ts
+function resolveNow(now) {
+  return now ?? Date.now();
+}
+
+// src/rewards/copy_repeatable_quest_rewards_to_quest.ts
+function copyRepeatableQuestRewardsToQuest(db, repeatableQuestId, questId, now) {
+  const effectiveNow = resolveNow(now);
+  const rows = db.prepare(
+    `SELECT kind, name, description, quantity
+       FROM repeatable_quest_rewards
+       WHERE repeatable_quest_id = ? AND deleted_at IS NULL`
+  ).all(repeatableQuestId);
+  for (const row of rows) {
+    db.prepare(
+      `INSERT INTO quest_rewards (quest_id, kind, name, description, quantity, created_at)
+       VALUES (?, ?, ?, ?, ?, ?)`
+    ).run(
+      questId,
+      String(row.kind),
+      String(row.name),
+      row.description == null ? null : String(row.description),
+      row.quantity == null ? null : Number(row.quantity),
+      effectiveNow
+    );
+  }
+}
+
+// src/tags/copy_repeatable_quest_tags_to_quest.ts
+function copyRepeatableQuestTagsToQuest(db, repeatableQuestId, questId, now) {
+  const effectiveNow = resolveNow(now);
+  const rows = db.prepare(
+    `SELECT tag_id
+       FROM repeatable_quest_tags
+       WHERE repeatable_quest_id = ? AND deleted_at IS NULL`
+  ).all(repeatableQuestId);
+  for (const row of rows) {
+    db.prepare(
+      `INSERT INTO quest_tags (quest_id, tag_id, created_at)
+       VALUES (?, ?, ?)`
+    ).run(questId, Number(row.tag_id), effectiveNow);
+  }
+}
+
+// src/repeatable_quests/map_repeatable_quest_row.ts
+function asBoolean2(value) {
+  return Number(value) === 1;
+}
+function mapRepeatableQuestRow(row) {
+  return {
+    id: Number(row.id),
+    questlineId: row.questline_id == null ? null : Number(row.questline_id),
+    title: String(row.title),
+    objective: String(row.objective),
+    rrule: String(row.rrule),
+    anchorAt: Number(row.anchor_at),
+    notBeforeOffsetSeconds: row.not_before_offset_seconds == null ? null : Number(row.not_before_offset_seconds),
+    dueOffsetSeconds: row.due_offset_seconds == null ? null : Number(row.due_offset_seconds),
+    scheduledStartOffsetSeconds: row.scheduled_start_offset_seconds == null ? null : Number(row.scheduled_start_offset_seconds),
+    scheduledEndOffsetSeconds: row.scheduled_end_offset_seconds == null ? null : Number(row.scheduled_end_offset_seconds),
+    allDay: asBoolean2(row.all_day),
+    estimateSeconds: row.estimate_seconds == null ? null : Number(row.estimate_seconds),
+    createdAt: Number(row.created_at),
+    updatedAt: Number(row.updated_at),
+    archivedAt: row.archived_at == null ? null : Number(row.archived_at),
+    deletedAt: row.deleted_at == null ? null : Number(row.deleted_at)
+  };
+}
+
+// src/repeatable_quests/get_repeatable_quest_or_throw.ts
+function getRepeatableQuestOrThrow(db, repeatableQuestId) {
+  const row = db.prepare("SELECT * FROM repeatable_quests WHERE id = ? AND deleted_at IS NULL").get(repeatableQuestId);
+  if (!row) {
+    throw new Error(`Repeatable quest ${repeatableQuestId} was not found.`);
+  }
+  return mapRepeatableQuestRow(row);
+}
+
+// src/repeatable_quests/advance_anchor.ts
+var WEEK_MS = 7 * 864e5;
+function advanceAnchor(anchorAt, freq, interval) {
+  const date = new Date(anchorAt);
+  if (freq === "MONTHLY") {
+    date.setUTCMonth(date.getUTCMonth() + interval);
+    return date.getTime();
+  }
+  if (freq === "YEARLY") {
+    date.setUTCFullYear(date.getUTCFullYear() + interval);
+    return date.getTime();
+  }
+  return anchorAt + interval * WEEK_MS;
+}
+
+// src/repeatable_quests/parse_rrule.ts
+var WEEKDAY = {
+  SU: 0,
+  MO: 1,
+  TU: 2,
+  WE: 3,
+  TH: 4,
+  FR: 5,
+  SA: 6
+};
+function parseRRule(rrule) {
+  const parts = Object.fromEntries(
+    rrule.split(";").map((part) => part.trim()).filter(Boolean).map((part) => {
+      const [key, value] = part.split("=");
+      return [key, value];
+    })
+  );
+  const freq = parts.FREQ;
+  if (freq !== "DAILY" && freq !== "WEEKLY" && freq !== "MONTHLY" && freq !== "YEARLY") {
+    throw new Error(`Unsupported RRULE FREQ: ${freq ?? "missing"}`);
+  }
+  const interval = parts.INTERVAL == null ? 1 : Number(parts.INTERVAL);
+  if (!Number.isFinite(interval) || interval < 1) {
+    throw new Error("RRULE INTERVAL must be a positive integer.");
+  }
+  const count = parts.COUNT == null ? null : Number(parts.COUNT);
+  if (count != null && (!Number.isFinite(count) || count < 1)) {
+    throw new Error("RRULE COUNT must be a positive integer.");
+  }
+  const until = parts.UNTIL == null ? null : Date.parse(parts.UNTIL);
+  if (parts.UNTIL != null && Number.isNaN(until)) {
+    throw new Error("RRULE UNTIL must be parseable as a date.");
+  }
+  const byDay = parts.BYDAY == null ? null : parts.BYDAY.split(",").map((token) => {
+    const value = WEEKDAY[token];
+    if (value == null) {
+      throw new Error(`Unsupported RRULE BYDAY token: ${token}`);
+    }
+    return value;
+  });
+  return { freq, interval, count, until, byDay };
+}
+
+// src/repeatable_quests/start_of_utc_day.ts
+function startOfUtcDay(timestamp) {
+  const date = new Date(timestamp);
+  return Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());
+}
+
+// src/repeatable_quests/start_of_utc_week.ts
+var DAY_MS = 864e5;
+function startOfUtcWeek(dayStart) {
+  const date = new Date(dayStart);
+  return dayStart - date.getUTCDay() * DAY_MS;
+}
+
+// src/repeatable_quests/generate_anchors_until.ts
+var DAY_MS2 = 864e5;
+var WEEK_MS2 = 7 * DAY_MS2;
+function generateAnchorsUntil(repeatable, now) {
+  const rule = parseRRule(repeatable.rrule);
+  const anchors = [];
+  const until = rule.until == null ? now : Math.min(now, rule.until);
+  if (repeatable.anchorAt > until) {
+    return anchors;
+  }
+  if (rule.freq === "DAILY") {
+    let occurrence2 = 0;
+    for (let current2 = repeatable.anchorAt; current2 <= until; current2 += rule.interval * DAY_MS2) {
+      occurrence2 += 1;
+      if (rule.count != null && occurrence2 > rule.count) {
+        break;
+      }
+      anchors.push(current2);
+    }
+    return anchors;
+  }
+  if (rule.freq === "WEEKLY" && rule.byDay && rule.byDay.length > 0) {
+    const anchorDayStart = startOfUtcDay(repeatable.anchorAt);
+    const anchorWeekStart = startOfUtcWeek(anchorDayStart);
+    const timeOffset = repeatable.anchorAt - anchorDayStart;
+    let occurrence2 = 0;
+    for (let day = anchorDayStart; day <= until; day += DAY_MS2) {
+      const weeksSince = Math.floor((startOfUtcWeek(day) - anchorWeekStart) / WEEK_MS2);
+      if (weeksSince < 0 || weeksSince % rule.interval !== 0) {
+        continue;
+      }
+      if (!rule.byDay.includes(new Date(day).getUTCDay())) {
+        continue;
+      }
+      const anchor = day + timeOffset;
+      if (anchor < repeatable.anchorAt || anchor > until) {
+        continue;
+      }
+      occurrence2 += 1;
+      if (rule.count != null && occurrence2 > rule.count) {
+        break;
+      }
+      anchors.push(anchor);
+    }
+    return anchors;
+  }
+  let occurrence = 0;
+  let current = repeatable.anchorAt;
+  while (current <= until) {
+    occurrence += 1;
+    if (rule.count != null && occurrence > rule.count) {
+      break;
+    }
+    anchors.push(current);
+    current = advanceAnchor(current, rule.freq, rule.interval);
+  }
+  return anchors;
+}
+
+// src/repeatable_quests/list_due_repeatable_quest_anchors.ts
+function listDueRepeatableQuestAnchors(db, now) {
+  const repeatables = db.prepare(
+    `SELECT *
+       FROM repeatable_quests
+       WHERE deleted_at IS NULL
+         AND archived_at IS NULL`
+  ).all().map(mapRepeatableQuestRow);
+  const anchors = [];
+  if (repeatables.length === 0) {
+    return anchors;
+  }
+  const repeatableIds = repeatables.map((repeatable) => repeatable.id);
+  const maxAnchorAt = Math.max(
+    ...repeatables.map((repeatable) => Math.max(repeatable.anchorAt, now))
+  );
+  const existingRows = db.prepare(
+    `SELECT spawned_from_repeatable_id, spawned_for_at
+       FROM quests
+       WHERE spawned_from_repeatable_id IN (${repeatableIds.map(() => "?").join(", ")})
+         AND spawned_for_at IS NOT NULL
+         AND spawned_for_at <= ?`
+  ).all(...repeatableIds, maxAnchorAt);
+  const existingAnchors = new Set(
+    existingRows.map(
+      (row) => `${Number(row.spawned_from_repeatable_id)}:${Number(row.spawned_for_at)}`
+    )
+  );
+  for (const repeatable of repeatables) {
+    const dueAnchors = generateAnchorsUntil(repeatable, now);
+    for (const anchorAt of dueAnchors) {
+      if (!existingAnchors.has(`${repeatable.id}:${anchorAt}`)) {
+        anchors.push({
+          repeatableQuestId: repeatable.id,
+          anchorAt,
+          markerId: "attention.available.repeatable"
+        });
+      }
+    }
+  }
+  return anchors.sort(
+    (a, b) => a.anchorAt - b.anchorAt || a.repeatableQuestId - b.repeatableQuestId
+  );
+}
+
+// src/repeatable_quests/spawn_due_repeatable_quests.ts
+function spawnDueRepeatableQuests(db, now) {
+  return withTransaction(db, () => {
+    const anchors = listDueRepeatableQuestAnchors(db, now);
+    const quests = [];
+    for (const anchor of anchors) {
+      const repeatable = getRepeatableQuestOrThrow(db, anchor.repeatableQuestId);
+      const created = db.prepare(
+        `INSERT INTO quests (
+             questline_id,
+             source_rumor_id,
+             spawned_by_quest_id,
+             spawned_from_repeatable_id,
+             spawned_for_at,
+             title,
+             objective,
+             created_at,
+             updated_at,
+             effort_seconds,
+             estimate_seconds,
+             not_before_at,
+             due_at,
+             scheduled_start_at,
+             scheduled_end_at,
+             all_day
+           ) VALUES (?, NULL, NULL, ?, ?, ?, ?, ?, ?, 0, ?, ?, ?, ?, ?, ?)`
+      ).run(
+        repeatable.questlineId ?? null,
+        repeatable.id,
+        anchor.anchorAt,
+        repeatable.title,
+        repeatable.objective,
+        now,
+        now,
+        repeatable.estimateSeconds ?? null,
+        repeatable.notBeforeOffsetSeconds == null ? null : anchor.anchorAt + repeatable.notBeforeOffsetSeconds * 1e3,
+        repeatable.dueOffsetSeconds == null ? null : anchor.anchorAt + repeatable.dueOffsetSeconds * 1e3,
+        repeatable.scheduledStartOffsetSeconds == null ? null : anchor.anchorAt + repeatable.scheduledStartOffsetSeconds * 1e3,
+        repeatable.scheduledEndOffsetSeconds == null ? null : anchor.anchorAt + repeatable.scheduledEndOffsetSeconds * 1e3,
+        repeatable.allDay ? 1 : 0
+      );
+      const questId = Number(created.lastInsertRowid);
+      copyRepeatableQuestTagsToQuest(db, repeatable.id, questId, now);
+      copyRepeatableQuestRewardsToQuest(db, repeatable.id, questId, now);
+      quests.push(getQuestOrThrow(db, questId));
+    }
+    return quests;
+  });
+}
+
+// src/markers/derive_quest_marker_id.ts
+function deriveQuestMarkerId({
+  state,
+  available,
+  hasUnclaimedReward,
+  notBeforeAt,
+  blockerCount,
+  now
+}) {
+  if (state === "done") {
+    return hasUnclaimedReward ? "progress.complete" : null;
+  }
+  if (state === "abandoned") {
+    return null;
+  }
+  if (state === "in_progress") {
+    return "progress.incomplete";
+  }
+  if (available) {
+    return "attention.available";
+  }
+  if (notBeforeAt != null && notBeforeAt > now) {
+    return "attention.available.future";
+  }
+  if (blockerCount > 0) {
+    return "progress.incomplete";
+  }
+  return null;
+}
+
+// src/rewards/map_quest_reward_row.ts
+function mapQuestRewardRow(row) {
+  return {
+    id: Number(row.id),
+    questId: Number(row.quest_id),
+    kind: String(row.kind),
+    name: String(row.name),
+    description: row.description == null ? null : String(row.description),
+    quantity: row.quantity == null ? null : Number(row.quantity),
+    createdAt: Number(row.created_at),
+    claimedAt: row.claimed_at == null ? null : Number(row.claimed_at),
+    deletedAt: row.deleted_at == null ? null : Number(row.deleted_at)
+  };
+}
+
+// src/quests/derive_quest_state.ts
+function deriveQuestState(quest) {
+  if (quest.resolvedAt != null && quest.success === true) {
+    return "done";
+  }
+  if (quest.resolvedAt != null && quest.success === false) {
+    return "abandoned";
+  }
+  if (quest.startedAt != null) {
+    return "in_progress";
+  }
+  return "open";
+}
+
+// src/quests/query_quest_detail_records.ts
+function queryQuestDetailRecords(db, filters = {}, now = Date.now(), questIds) {
+  if (questIds && questIds.length === 0) {
+    return [];
+  }
+  const clauses = [];
+  const params = [];
+  if (!filters.includeDeleted) {
+    clauses.push("q.deleted_at IS NULL");
+  }
+  if (questIds && questIds.length > 0) {
+    clauses.push(`q.id IN (${questIds.map(() => "?").join(", ")})`);
+    params.push(...questIds);
+  }
+  if (filters.questlineId != null) {
+    clauses.push("q.questline_id = ?");
+    params.push(filters.questlineId);
+  }
+  if (filters.tagNames && filters.tagNames.length > 0) {
+    const normalized = [...new Set(filters.tagNames.map(normalizeTagName).filter(Boolean))];
+    for (const tag of normalized) {
+      clauses.push(
+        `EXISTS (
+           SELECT 1
+           FROM quest_tags qt
+           JOIN tags t ON t.id = qt.tag_id
+           WHERE qt.quest_id = q.id
+             AND qt.deleted_at IS NULL
+             AND t.deleted_at IS NULL
+             AND t.normalized_name = ?
+         )`
+      );
+      params.push(tag);
+    }
+  }
+  const where = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
+  const rows = db.prepare(
+    `SELECT q.*,
+              COALESCE(q.due_at, ql.due_at) AS effective_due_at,
+              (
+                SELECT COUNT(*)
+                FROM quest_unlocks qu
+                JOIN quests blocker ON blocker.id = qu.from_quest_id
+                WHERE qu.to_quest_id = q.id
+                  AND qu.deleted_at IS NULL
+                  AND blocker.deleted_at IS NULL
+                  AND NOT (blocker.resolved_at IS NOT NULL AND blocker.success = 1)
+              ) AS blocker_count
+       FROM quests q
+       LEFT JOIN questlines ql ON ql.id = q.questline_id AND ql.deleted_at IS NULL
+       ${where}
+       ORDER BY q.created_at DESC, q.id DESC`
+  ).all(...params);
+  if (rows.length === 0) {
+    return [];
+  }
+  const ids = rows.map((row) => Number(row.id));
+  const placeholders = ids.map(() => "?").join(", ");
+  const tagNamesByQuestId = /* @__PURE__ */ new Map();
+  const rewardsByQuestId = /* @__PURE__ */ new Map();
+  const unlocksByQuestId = /* @__PURE__ */ new Map();
+  const unlockedByQuestId = /* @__PURE__ */ new Map();
+  for (const row of db.prepare(
+    `SELECT qt.quest_id, t.name
+       FROM quest_tags qt
+       JOIN tags t ON t.id = qt.tag_id
+       WHERE qt.quest_id IN (${placeholders})
+         AND qt.deleted_at IS NULL
+         AND t.deleted_at IS NULL
+       ORDER BY qt.quest_id, t.name`
+  ).all(...ids)) {
+    const questId = Number(row.quest_id);
+    const tagNames = tagNamesByQuestId.get(questId) ?? [];
+    tagNames.push(String(row.name));
+    tagNamesByQuestId.set(questId, tagNames);
+  }
+  for (const row of db.prepare(
+    `SELECT *
+       FROM quest_rewards
+       WHERE quest_id IN (${placeholders})
+         AND deleted_at IS NULL
+       ORDER BY quest_id, created_at, id`
+  ).all(...ids)) {
+    const reward = mapQuestRewardRow(row);
+    const rewards = rewardsByQuestId.get(reward.questId) ?? [];
+    rewards.push(reward);
+    rewardsByQuestId.set(reward.questId, rewards);
+  }
+  for (const row of db.prepare(
+    `SELECT from_quest_id, to_quest_id
+       FROM quest_unlocks
+       WHERE from_quest_id IN (${placeholders})
+         AND deleted_at IS NULL
+       ORDER BY from_quest_id, to_quest_id`
+  ).all(...ids)) {
+    const questId = Number(row.from_quest_id);
+    const unlocks = unlocksByQuestId.get(questId) ?? [];
+    unlocks.push(Number(row.to_quest_id));
+    unlocksByQuestId.set(questId, unlocks);
+  }
+  for (const row of db.prepare(
+    `SELECT from_quest_id, to_quest_id
+       FROM quest_unlocks
+       WHERE to_quest_id IN (${placeholders})
+         AND deleted_at IS NULL
+       ORDER BY to_quest_id, from_quest_id`
+  ).all(...ids)) {
+    const questId = Number(row.to_quest_id);
+    const unlockedBy = unlockedByQuestId.get(questId) ?? [];
+    unlockedBy.push(Number(row.from_quest_id));
+    unlockedByQuestId.set(questId, unlockedBy);
+  }
+  return rows.map((row) => {
+    const quest = mapQuestRow(row);
+    const blockerCount = Number(row.blocker_count ?? 0);
+    const effectiveDueAt = row.effective_due_at == null ? null : Number(row.effective_due_at);
+    const rewards = rewardsByQuestId.get(quest.id) ?? [];
+    const state = deriveQuestState(quest);
+    const available = quest.deletedAt == null && quest.resolvedAt == null && (quest.notBeforeAt == null || quest.notBeforeAt <= now) && blockerCount === 0;
+    const markerId = deriveQuestMarkerId({
+      state,
+      available,
+      hasUnclaimedReward: rewards.some((reward) => reward.claimedAt == null),
+      notBeforeAt: quest.notBeforeAt,
+      blockerCount,
+      now
+    });
+    return {
+      detail: {
+        ...quest,
+        state,
+        markerId,
+        effectiveDueAt,
+        available,
+        tagNames: tagNamesByQuestId.get(quest.id) ?? [],
+        rewards,
+        unlocksQuestIds: unlocksByQuestId.get(quest.id) ?? [],
+        unlockedByQuestIds: unlockedByQuestId.get(quest.id) ?? []
+      },
+      blockerCount
+    };
+  });
+}
+
+// src/hooks/detect_hook_events.ts
+function detectHookEvents(db, now) {
+  const events = [];
+  const add = (type, at, ids) => {
+    events.push({
+      id: `e_${type}_${ids.questId ?? ids.rumorId}_${ids.repeatableId ?? ""}_${at}`,
+      type,
+      ...ids,
+      occurredAt: new Date(at).toISOString()
+    });
+  };
+  for (const { detail: q } of queryQuestDetailRecords(db, {}, now)) {
+    if (q.resolvedAt == null && q.effectiveDueAt != null && q.effectiveDueAt <= now) {
+      add("quest.due", q.effectiveDueAt, { questId: q.id });
+      if (q.effectiveDueAt < now) add("quest.overdue", q.effectiveDueAt, { questId: q.id });
+    }
+    if (q.available) {
+      const prerequisites = db.prepare(
+        `SELECT p.id, p.resolved_at, u.created_at FROM quest_unlocks u JOIN quests p ON p.id = u.from_quest_id WHERE u.to_quest_id = ? AND u.deleted_at IS NULL AND p.deleted_at IS NULL AND p.success = 1 AND p.resolved_at IS NOT NULL`
+      ).all(q.id);
+      if (prerequisites.some((p) => Number(p.resolved_at) >= Number(p.created_at))) {
+        const at = Math.max(q.notBeforeAt ?? 0, ...prerequisites.map((p) => Number(p.resolved_at)));
+        if (at <= now) add("quest.unblocked", at, { questId: q.id });
+      }
+    }
+    if (q.spawnedFromRepeatableId != null && q.createdAt <= now)
+      add("repeatable.spawned", q.createdAt, {
+        questId: q.id,
+        repeatableId: q.spawnedFromRepeatableId
+      });
+  }
+  for (const row of db.prepare("SELECT id, created_at FROM rumors WHERE deleted_at IS NULL AND created_at <= ?").all(now))
+    add("rumor.captured", Number(row.created_at), { rumorId: Number(row.id) });
+  return events.sort(
+    (a, b) => a.occurredAt.localeCompare(b.occurredAt) || a.id.localeCompare(b.id)
+  );
+}
+
+// src/hooks/tick_questlog.ts
+async function tickQuestlog(db, options = {}) {
+  const now = options.now ?? options.clock?.() ?? Date.now();
+  const result = {
+    events: [],
+    batches: [],
+    sent: 0,
+    queued: 0,
+    retrying: 0,
+    failed: 0
+  };
+  const claims = [];
+  const collect = () => {
+    spawnDueRepeatableQuests(db, now);
+    const detected = detectHookEvents(db, now);
+    result.events = detected.filter(
+      (e) => !db.prepare("SELECT id FROM hook_events WHERE id = ?").get(e.id)
+    );
+    for (const event of result.events)
+      db.prepare("INSERT INTO hook_events(id, occurred_at, event) VALUES (?, ?, ?)").run(
+        event.id,
+        Date.parse(event.occurredAt),
+        JSON.stringify(event)
+      );
+    for (const target of listHooks(db)) {
+      const events = db.prepare(
+        "SELECT e.event FROM hook_events e WHERE occurred_at >= ? AND NOT EXISTS (SELECT 1 FROM hook_assignments a WHERE a.target_id = ? AND a.event_id = e.id) ORDER BY occurred_at, id"
+      ).all(target.createdAt, target.id).map((row2) => JSON.parse(String(row2.event))).filter((event) => {
+        if (!target.events.includes(event.type)) return false;
+        if (target.tag == null) return true;
+        return event.questId !== void 0 && db.prepare(
+          "SELECT 1 FROM quest_tags qt JOIN tags t ON t.id = qt.tag_id WHERE qt.quest_id = ? AND qt.deleted_at IS NULL AND t.deleted_at IS NULL AND t.normalized_name = ?"
+        ).get(event.questId, normalizeTagName(target.tag)) !== void 0;
+      });
+      for (const event of events)
+        db.prepare("INSERT INTO hook_assignments(target_id, event_id) VALUES (?, ?)").run(
+          target.id,
+          event.id
+        );
+      const row = db.prepare("SELECT url, secret, lease_until FROM hook_targets WHERE id = ?").get(target.id);
+      if (!row || row.lease_until != null && Number(row.lease_until) > now) continue;
+      let pending = listDeliveries(db).find(
+        (d) => d.targetId === target.id && d.status === "pending"
+      );
+      const queued = db.prepare(
+        "SELECT e.event FROM hook_assignments a JOIN hook_events e ON e.id = a.event_id WHERE a.target_id = ? AND a.delivery_id IS NULL ORDER BY e.occurred_at, e.id"
+      ).all(target.id).map((r) => JSON.parse(String(r.event)));
+      if (!pending && queued.length) {
+        const id = `d_${randomBytes(16).toString("hex")}`;
+        db.prepare(
+          "INSERT INTO hook_deliveries(id, target_id, events, status, next_attempt_at) VALUES (?, ?, ?, 'pending', ?)"
+        ).run(
+          id,
+          target.id,
+          JSON.stringify(queued),
+          Math.max(now, (target.lastWake ?? -Infinity) + target.minGap * 1e3)
+        );
+        db.prepare(
+          "UPDATE hook_assignments SET delivery_id = ? WHERE target_id = ? AND delivery_id IS NULL"
+        ).run(id, target.id);
+        pending = listDeliveries(db).find((d) => d.id === id);
+      }
+      if (!pending) continue;
+      if (pending.attempts === 0 && queued.length && !queued.every((e) => pending?.events.some((p) => p.id === e.id))) {
+        pending.events.push(...queued);
+        db.prepare("UPDATE hook_deliveries SET events = ? WHERE id = ?").run(
+          JSON.stringify(pending.events),
+          pending.id
+        );
+        db.prepare(
+          "UPDATE hook_assignments SET delivery_id = ? WHERE target_id = ? AND delivery_id IS NULL"
+        ).run(pending.id, target.id);
+      }
+      if (pending.nextAttemptAt > now || target.lastWake != null && target.lastWake + target.minGap * 1e3 > now)
+        continue;
+      if (pending.attempts >= 8) {
+        db.prepare("UPDATE hook_deliveries SET status = 'failed' WHERE id = ?").run(pending.id);
+        continue;
+      }
+      const claim = randomBytes(16).toString("hex");
+      db.prepare(
+        "UPDATE hook_targets SET claim = ?, lease_until = ?, last_wake = ? WHERE id = ?"
+      ).run(claim, now + 12e4, now, target.id);
+      db.prepare(
+        "UPDATE hook_deliveries SET attempts = attempts + 1, last_attempt_at = ? WHERE id = ?"
+      ).run(now, pending.id);
+      pending.attempts++;
+      pending.lastAttemptAt = now;
+      result.batches.push({ targetId: target.id, events: pending.events });
+      claims.push({
+        delivery: pending,
+        target: { id: target.id, url: String(row.url), secret: String(row.secret), claim }
+      });
+    }
+  };
+  if (options.dryRun) {
+    const rollback = new Error("preview rollback");
+    try {
+      withTransaction(db, () => {
+        collect();
+        throw rollback;
+      });
+    } catch (error) {
+      if (error !== rollback) throw error;
+    }
+  } else withTransaction(db, collect);
+  if (!options.dryRun) {
+    const sent = await Promise.all(
+      claims.map((claim) => sendHookDelivery(db, claim.delivery, claim.target, options))
+    );
+    result.sent = sent.filter(Boolean).length;
+  }
+  const deliveries = listDeliveries(db);
+  result.queued = deliveries.filter((d) => d.status === "pending" && d.attempts === 0).length + Number(
+    db.prepare(
+      "SELECT COUNT(DISTINCT target_id) AS n FROM hook_assignments WHERE delivery_id IS NULL"
+    ).get()?.n ?? 0
+  );
+  result.retrying = deliveries.filter((d) => d.status === "pending" && d.attempts > 0).length;
+  result.failed = deliveries.filter((d) => d.status === "failed").length;
+  return result;
+}
+
+// src/hooks/watch_questlog.ts
+async function watchQuestlog(db, options) {
+  const interval = options.interval ?? 60;
+  if (!Number.isFinite(interval) || interval < 5)
+    throw new Error("Interval must be at least 5 seconds");
+  while (!options.signal.aborted) {
+    options.onTick?.(await tickQuestlog(db, options));
+    if (options.signal.aborted) break;
+    await new Promise((resolve) => {
+      const finish = () => {
+        clearTimeout(timer);
+        options.signal.removeEventListener("abort", finish);
+        resolve();
+      };
+      const timer = setTimeout(finish, interval * 1e3);
+      options.signal.addEventListener("abort", finish, { once: true });
+    });
+  }
+}
+
+export { addHook, deriveQuestMarkerId, deriveQuestState, getQuestOrThrow, getRepeatableQuestOrThrow, hookLabel, listDueRepeatableQuestAnchors, mapQuestRewardRow, normalizeTagName, parseRRule, queryQuestDetailRecords, questlogVersion, removeHook, resolveNow, spawnDueRepeatableQuests, testHook, tickQuestlog, watchQuestlog, withTransaction };