@stringsync/splates 0.0.61 → 1.13.3

package/vendor/@stringsync/splates-server/index-76t8y8h5.js

@@ -0,0 +1,779 @@
+import {
+  fail2
+} from "./index-t9w5a8ed.js";
+import {
+  body,
+  pickLabel2
+} from "./index-caep3sde.js";
+import {
+  commaList2
+} from "./index-01z7ycdk.js";
+
+// hooks/commands.ts
+import { color } from "../../core/log/index.js";
+
+// hooks/events.ts
+var TASK_EVENTS2 = [
+  "task.created",
+  "task.updated",
+  "task.ready",
+  "task.queued",
+  "task.started",
+  "task.done",
+  "task.dropped"
+];
+function taskEventsOf2(event) {
+  if (event.reason !== null) {
+    return [];
+  }
+  const of = (name, numbers) => ({
+    name,
+    from: event.id,
+    at: event.at,
+    numbers,
+    task: event.task
+  });
+  switch (event.action) {
+    case "task add":
+      return [
+        of("task.created", [event.number]),
+        ...event.ready ? [of("task.ready", [event.number])] : []
+      ];
+    case "task update":
+      return [
+        of("task.updated", [event.number]),
+        ...event.changed.ready ? [of("task.ready", [event.number])] : []
+      ];
+    case "queue add":
+      return [
+        of("task.queued", event.tasks.map(({ id }) => id))
+      ];
+    case "add":
+      return [of("task.started", event.tasks)];
+    case "merge":
+      return [of("task.done", [])];
+    case "remove":
+      return [of("task.dropped", [])];
+    case "task remove":
+      return [
+        of("task.dropped", event.tasks.map(({ id }) => id))
+      ];
+    default:
+      return [];
+  }
+}
+
+// hooks/groomer.ts
+var GROOMER_AUTOMATION2 = "groomer";
+var GROOMER_TRIGGER2 = { event: "task.created" };
+
+// hooks/now.ts
+var BY_HAND2 = "by hand";
+function runsNow2({
+  trigger,
+  hook
+}) {
+  return !("event" in trigger) || hook.kind === "groom";
+}
+
+// hooks/schedule.ts
+function scheduleOf(trigger) {
+  return "every" in trigger ? everyOf(trigger.every) : cronOf(trigger.cron);
+}
+function everyOf(every) {
+  const match = /^(\d+)\s*(m|h|d)$/.exec(every.trim());
+  const count = Number(match?.[1]);
+  if (match === null || count < 1) {
+    fail2("usage", `'${every}' is no interval: give minutes, hours or days, as 30m, 2h or 1d`, { every });
+  }
+  const ms = count * UNIT[match[2]];
+  return { nextAfter: (at) => at + ms };
+}
+var UNIT = { m: 60000, h: 3600000, d: 86400000 };
+var FIELDS = [
+  { name: "minute", min: 0, max: 59 },
+  { name: "hour", min: 0, max: 23 },
+  { name: "day of month", min: 1, max: 31 },
+  { name: "month", min: 1, max: 12 },
+  { name: "day of week", min: 0, max: 7 }
+];
+function cronOf(line) {
+  const parts = line.trim().split(/\s+/);
+  if (parts.length !== FIELDS.length) {
+    fail2("usage", `'${line}' is no cron line: give five fields, minute hour day month weekday, as "0 9 * * 1-5"`, { cron: line });
+  }
+  const [minutes, hours, days, months, weekdays] = parts.map((part, at) => valuesOf(part, FIELDS[at], line));
+  if (weekdays.has(7)) {
+    weekdays.add(0);
+  }
+  const anyDay = parts[2] === "*";
+  const anyWeekday = parts[4] === "*";
+  const dayMatches = (date) => {
+    const day = days.has(date.getDate());
+    const weekday = weekdays.has(date.getDay());
+    if (anyDay || anyWeekday) {
+      return day && weekday;
+    }
+    return day || weekday;
+  };
+  return {
+    nextAfter(at) {
+      const date = new Date(at);
+      date.setSeconds(0, 0);
+      date.setMinutes(date.getMinutes() + 1);
+      const until = at + 5 * 366 * UNIT.d;
+      while (date.getTime() <= until) {
+        if (!months.has(date.getMonth() + 1)) {
+          date.setMonth(date.getMonth() + 1, 1);
+          date.setHours(0, 0);
+        } else if (!dayMatches(date)) {
+          date.setDate(date.getDate() + 1);
+          date.setHours(0, 0);
+        } else if (!hours.has(date.getHours())) {
+          date.setHours(date.getHours() + 1, 0);
+        } else if (!minutes.has(date.getMinutes())) {
+          date.setMinutes(date.getMinutes() + 1);
+        } else {
+          return date.getTime();
+        }
+      }
+      return Number.POSITIVE_INFINITY;
+    }
+  };
+}
+function valuesOf(part, field, line) {
+  const values = new Set;
+  for (const item of part.split(",")) {
+    const match = /^(\*|(\d+)(?:-(\d+))?)(?:\/(\d+))?$/.exec(item);
+    const from = match?.[2] === undefined ? field.min : Number(match[2]);
+    const to = match?.[3] !== undefined ? Number(match[3]) : match?.[2] === undefined || match[4] !== undefined ? field.max : from;
+    const step = match?.[4] === undefined ? 1 : Number(match[4]);
+    if (match === null || from < field.min || to > field.max || from > to || step < 1) {
+      fail2("usage", `'${line}' is no cron line: its ${field.name} '${part}' takes ${field.min} to ${field.max}`, { cron: line });
+    }
+    for (let value = from;value <= to; value += step) {
+      values.add(value);
+    }
+  }
+  return values;
+}
+
+// hooks/store.ts
+class HookStore2 {
+  #file;
+  constructor(storage) {
+    this.#file = storage.document("hooks.json");
+  }
+  async read() {
+    const parsed = await this.#file.read().catch(() => null);
+    if (parsed === null || typeof parsed !== "object") {
+      return [];
+    }
+    if ("automations" in parsed && Array.isArray(parsed.automations)) {
+      return parsed.automations.filter((each) => !["notes-gardener", "notes-audit"].includes(each.id) && each.hook.kind !== "garden").map((each) => each.source === "builtin" && each.id === GROOMER_AUTOMATION2 ? { ...each, trigger: GROOMER_TRIGGER2 } : each);
+    }
+    return fromHooks2(parsed);
+  }
+  async add(trigger, hook) {
+    checked(trigger);
+    const createdAt = new Date().toISOString();
+    let added;
+    await this.change((automations) => {
+      const last = Math.max(0, ...automations.map(({ id }) => Number(id) || 0));
+      added = { id: String(last + 1), trigger, hook, createdAt };
+      return [...automations, added];
+    });
+    return added;
+  }
+  async remove(id) {
+    const event = TASK_EVENTS2.includes(id);
+    let gone = [];
+    await this.change((automations) => {
+      gone = automations.filter((each) => event ? "event" in each.trigger && each.trigger.event === id && each.source !== "builtin" : each.id === id);
+      return automations.filter((each) => !gone.includes(each));
+    });
+    if (gone.length === 0 && !event) {
+      fail2("usage", `no automation ${id}: \`splates hook list\` numbers them`, {
+        id
+      });
+    }
+    return gone;
+  }
+  async groomer(pick) {
+    let set = null;
+    await this.change((automations) => {
+      const was = automations.find(({ id }) => id === GROOMER_AUTOMATION2);
+      const rest = automations.filter((each) => each !== was);
+      if (pick === null) {
+        return rest;
+      }
+      set = {
+        id: GROOMER_AUTOMATION2,
+        trigger: GROOMER_TRIGGER2,
+        hook: { kind: "groom", ...pick },
+        createdAt: was?.createdAt ?? new Date().toISOString(),
+        source: "builtin",
+        ...was?.paused === true ? { paused: true } : {}
+      };
+      return [...rest, set];
+    });
+    return set;
+  }
+  async edit(id, trigger, hook) {
+    checked(trigger);
+    let found;
+    await this.change((automations) => automations.map((each) => {
+      if (each.id !== id || each.source !== undefined) {
+        return each;
+      }
+      const retriggered = JSON.stringify(each.trigger) !== JSON.stringify(trigger);
+      found = {
+        ...each,
+        trigger,
+        hook,
+        ...retriggered ? { editedAt: new Date().toISOString() } : {}
+      };
+      return found;
+    }));
+    if (found === undefined) {
+      fail2("usage", `no automation ${id}: \`splates hook list\` numbers yours`, {
+        id
+      });
+    }
+    return found;
+  }
+  async pause(id, paused) {
+    let found;
+    await this.change((automations) => automations.map((each) => {
+      if (each.id !== id) {
+        return each;
+      }
+      const { paused: _, ...rest } = each;
+      found = paused ? { ...rest, paused } : rest;
+      return found;
+    }));
+    if (found === undefined) {
+      fail2("usage", `no automation ${id}: \`splates hook list\` numbers them`, {
+        id
+      });
+    }
+    return found;
+  }
+  async request(id) {
+    let found;
+    await this.change((automations) => automations.map((each) => {
+      if (each.id !== id || !runsNow2(each)) {
+        return each;
+      }
+      found = { ...each, requestedAt: new Date().toISOString() };
+      return found;
+    }));
+    if (found === undefined) {
+      const set = (await this.read()).find((each) => each.id === id);
+      fail2("usage", set === undefined ? `no automation ${id}: \`splates hook list\` numbers them` : `automation ${id} runs on ${"event" in set.trigger ? set.trigger.event : "its schedule"}, for that event's tasks, so it cannot run now`, { id });
+    }
+    return found;
+  }
+  async change(edit) {
+    const automations = edit(await this.read());
+    await this.#file.write({ automations });
+  }
+}
+function fromHooks2(hooks, source) {
+  return TASK_EVENTS2.flatMap((event) => (hooks[event] ?? []).map((hook) => ({ event, hook }))).map(({ event, hook }, at) => ({
+    id: source === "config" ? `config:${event}` : String(at + 1),
+    trigger: { event },
+    hook,
+    createdAt: new Date(0).toISOString(),
+    ...source === undefined ? {} : { source }
+  }));
+}
+function eventNamed2(name) {
+  if (!TASK_EVENTS2.includes(name)) {
+    fail2("usage", `'${name}' is no task event: use one of ${TASK_EVENTS2.join(", ")}`, { event: name });
+  }
+  return name;
+}
+var STAGES = ["backlog", "ready", "queued", "running"];
+function stagesNamed2(names) {
+  for (const name of names) {
+    if (!STAGES.includes(name)) {
+      fail2("usage", `'${name}' is no stage: use one of ${STAGES.join(", ")}`, {
+        stage: name
+      });
+    }
+  }
+  return names;
+}
+function lanesNamed2(text) {
+  const lanes = commaList2(text).map(Number);
+  if (lanes.some((lane) => !Number.isInteger(lane) || lane <= 0)) {
+    fail2("usage", `'${text}' is no list of lane numbers`, { lane: text });
+  }
+  return lanes;
+}
+function checked(trigger) {
+  if ("event" in trigger) {
+    eventNamed2(trigger.event);
+    stagesNamed2(trigger.filter?.stages ?? []);
+  } else {
+    scheduleOf(trigger);
+  }
+}
+
+// hooks/edit.ts
+function changed(automation, change) {
+  return {
+    trigger: retriggered(automation.trigger, change),
+    hook: rehooked(automation.hook, change)
+  };
+}
+function retriggered(trigger, change) {
+  const { event, every, cron, stage, lane } = change;
+  const given = [event, every, cron].filter((each) => each !== "");
+  if (given.length > 1) {
+    fail2("usage", "say what sets it off: a task event, --every or --cron, one of them", {});
+  }
+  const base = event !== "" ? { event } : every !== "" ? { every } : cron !== "" ? { cron } : trigger;
+  if (stage === "" && lane === "") {
+    return base;
+  }
+  if (!("event" in base)) {
+    fail2("usage", "--stage and --lane narrow a task event, not a schedule", {});
+  }
+  const filter = { ...base.filter };
+  if (stage === "any") {
+    delete filter.stages;
+  } else if (stage !== "") {
+    filter.stages = stagesNamed2(commaList2(stage));
+  }
+  if (lane === "any") {
+    delete filter.lanes;
+  } else if (lane !== "") {
+    filter.lanes = lanesNamed2(lane);
+  }
+  return Object.keys(filter).length === 0 ? { event: base.event } : { event: base.event, filter };
+}
+function rehooked(hook, { run, prompt, pick }) {
+  if (run !== "") {
+    if (pick !== undefined || prompt !== "") {
+      fail2("usage", "--run goes alone: a shell command runs no agent", {});
+    }
+    return { kind: "run", command: run };
+  }
+  if (pick === undefined && prompt === "") {
+    return hook;
+  }
+  if (hook.kind === "agent") {
+    const { kind: _, prompt: was, ...ran } = hook;
+    return {
+      kind: "agent",
+      prompt: prompt === "" ? was : prompt,
+      ...pick ?? ran
+    };
+  }
+  if (pick === undefined || prompt === "") {
+    fail2("usage", "a command becomes an agent with both --agent and --prompt", {});
+  }
+  return { kind: "agent", prompt, ...pick };
+}
+
+// hooks/commands.ts
+async function hookList2({ hooks, log }, { json = false } = {}) {
+  const set = await hooks.read();
+  if (json) {
+    log.info(JSON.stringify(set, null, "\t"));
+    return;
+  }
+  log.info(set.length === 0 ? "no hooks: nothing runs on a task event or a schedule. `splates hook add` sets one" : set.map(described2).join(`
+`));
+}
+async function hookAdd2({ hooks, log }, trigger, hook) {
+  const added = await hooks.add(trigger, hook);
+  log.info(`${color.green("hooked")} ${described2(added)}`);
+}
+async function hookEdit2({ hooks, log }, id, change) {
+  const was = (await hooks.read()).find((each) => each.id === id);
+  if (was === undefined || was.source !== undefined) {
+    fail2("usage", id === GROOMER_AUTOMATION2 ? "the groomer changes through `splates hook groomer --agent`" : `no automation ${id}: \`splates hook list\` numbers yours`, { id });
+  }
+  const { trigger, hook } = changed(was, change);
+  const edited = await hooks.edit(id, trigger, hook);
+  log.info(`${color.green("edited")} ${described2(edited)}`);
+}
+async function hookRemove2({ hooks, log }, id) {
+  const gone = await hooks.remove(id);
+  log.info(gone.length === 0 ? `no hooks on ${id}` : gone.map((each) => `${color.green("unhooked")} ${described2(each)}`).join(`
+`));
+}
+async function hookGroomer2({ hooks, log }, pick) {
+  const set = await hooks.groomer(pick);
+  log.info(set === null ? `${color.green("groomer off")}: \`splates server\` retires its conversation` : `${color.green("groomer on")} ${described2(set)}`);
+}
+async function hookPause2({ hooks, log }, id, paused) {
+  const automation = await hooks.pause(id, paused);
+  log.info(`${color.green(paused ? "paused" : "resumed")} ${described2(automation)}`);
+}
+async function hookRun2({ hooks, log }, id) {
+  const automation = await hooks.request(id);
+  log.info(`${color.green("asked to run")} ${described2(automation)}
+splates server starts it at once, or as it starts when it is not running`);
+}
+function described2(automation) {
+  return `${automation.id}. ${triggerLabel2(automation.trigger)}: ${hookLabel2(automation.hook)}${automation.paused === true ? " (paused)" : ""}`;
+}
+function triggerLabel2(trigger) {
+  if ("every" in trigger) {
+    return `every ${trigger.every}`;
+  }
+  if ("cron" in trigger) {
+    return `cron ${trigger.cron}`;
+  }
+  const { stages, lanes } = trigger.filter ?? {};
+  const narrowed = [
+    ...stages === undefined ? [] : [stages.join(" or ")],
+    ...lanes === undefined ? [] : [`lane ${lanes.join(" or ")}`]
+  ];
+  return narrowed.length === 0 ? trigger.event : `${trigger.event} in ${narrowed.join(", ")}`;
+}
+function hookLabel2(hook) {
+  switch (hook.kind) {
+    case "agent":
+      return `tell ${pickLabel2(hook)}: ${hook.prompt}`;
+    case "run":
+      return `run \`${hook.command}\``;
+    case "groom":
+      return `groom the backlog with ${pickLabel2(hook)}`;
+  }
+}
+// hooks/routes.ts
+class AutomationRoutes2 {
+  #store;
+  #runs;
+  #all;
+  #changed;
+  #run;
+  constructor(store, runs, all, changed = () => {}, run = async () => {}) {
+    this.#store = store;
+    this.#runs = runs;
+    this.#all = all;
+    this.#changed = changed;
+    this.#run = run;
+  }
+  listAutomations = () => this.#list();
+  addAutomation = async (request) => {
+    const { trigger, hook } = await body(request);
+    await this.#store.add(triggerIn(trigger), hookIn(hook));
+    this.#changed();
+    return this.#list();
+  };
+  editAutomation = async (request) => {
+    const { trigger, hook } = await body(request);
+    const id = idIn(request);
+    if (id === GROOMER_AUTOMATION2) {
+      await this.#store.groomer(pickIn(hook));
+    } else {
+      await this.#store.edit(id, triggerIn(trigger), hookIn(hook));
+    }
+    this.#changed();
+    return this.#list();
+  };
+  removeAutomation = async (request) => {
+    await this.#store.remove(idIn(request));
+    this.#changed();
+    return this.#list();
+  };
+  pauseAutomation = async (request) => {
+    await this.#store.pause(idIn(request), true);
+    this.#changed();
+    return this.#list();
+  };
+  resumeAutomation = async (request) => {
+    await this.#store.pause(idIn(request), false);
+    this.#changed();
+    return this.#list();
+  };
+  runAutomation = async (request) => {
+    await this.#store.request(idIn(request));
+    await this.#run();
+    return this.#list();
+  };
+  async#list() {
+    const runs = await this.#runs.read();
+    const rows = (await this.#all()).map((each) => ({
+      ...each,
+      when: triggerLabel2(each.trigger),
+      does: hookLabel2(each.hook),
+      runs: runs[each.id]?.runs ?? []
+    }));
+    return Response.json({ automations: rows });
+  }
+}
+function idIn(request) {
+  const id = new URL(request.url).pathname.split("/")[3] ?? "";
+  if (!/^\d+$/.test(id) && id !== GROOMER_AUTOMATION2) {
+    fail2("usage", `no automation ${id}: only one of yours changes or runs here`, {
+      id
+    });
+  }
+  return id;
+}
+function triggerIn(raw) {
+  const given = raw ?? {};
+  if (typeof given.every === "string") {
+    return { every: given.every };
+  }
+  if (typeof given.cron === "string") {
+    return { cron: given.cron };
+  }
+  if (typeof given.event !== "string") {
+    fail2("usage", "say what sets it off: an event, every or cron", {});
+  }
+  const filter = given.filter ?? {};
+  const stages = Array.isArray(filter.stages) ? stagesNamed2(filter.stages.map(String)) : [];
+  const lanes = Array.isArray(filter.lanes) ? filter.lanes.filter((each) => Number.isInteger(each)) : [];
+  const narrowed = {
+    ...stages.length === 0 ? {} : { stages },
+    ...lanes.length === 0 ? {} : { lanes }
+  };
+  const event = given.event;
+  return Object.keys(narrowed).length === 0 ? { event } : { event, filter: narrowed };
+}
+function pickIn(raw) {
+  const given = raw ?? {};
+  if (typeof given.agent !== "string" || given.agent === "") {
+    fail2("usage", "pick the agent it runs as", {});
+  }
+  return {
+    agent: given.agent,
+    ...typeof given.model === "string" && given.model !== "" ? { model: given.model } : {},
+    ...typeof given.effort === "string" && given.effort !== "" ? { effort: given.effort } : {}
+  };
+}
+function hookIn(raw) {
+  const given = raw ?? {};
+  if (given.kind === "run" && typeof given.command === "string" && given.command.trim() !== "") {
+    return { kind: "run", command: given.command };
+  }
+  if (given.kind === "agent" && typeof given.agent === "string" && typeof given.prompt === "string" && given.prompt.trim() !== "") {
+    return {
+      kind: "agent",
+      agent: given.agent,
+      prompt: given.prompt,
+      ...typeof given.model === "string" && given.model !== "" ? { model: given.model } : {},
+      ...typeof given.effort === "string" && given.effort !== "" ? { effort: given.effort } : {}
+    };
+  }
+  fail2("usage", "say what runs: an agent with a prompt, or a shell command", {});
+}
+// hooks/runner.ts
+import { Duration, SystemTimer, Throttler } from "../../core/time/index.js";
+async function fire(automation, fired, { actions, runs, log, now }) {
+  const on = "event" in fired ? said(fired.event) : fired.byHand === true ? BY_HAND2 : "schedule";
+  const run = { at: now(), on, error: null };
+  const { hook } = automation;
+  try {
+    if (hook.kind === "run") {
+      await actions.run(hook.command, fired);
+    } else if (hook.kind === "agent") {
+      await actions.agent(hook, fired, automation.id);
+    } else if (hook.kind === "groom") {
+      await actions.groom(hook);
+    }
+  } catch (error) {
+    run.error = String(error);
+    log.error(`a ${hook.kind} hook on ${on} failed: ${String(error)}`);
+  }
+  await runs.ran(automation.id, run).catch((error) => log.error(String(error)));
+}
+function said(event) {
+  return [
+    event.name,
+    ...event.numbers.map((id) => `#${id}`),
+    ...event.task === null ? [] : [event.task]
+  ].join(" ");
+}
+
+class HookRunner2 {
+  deps;
+  #throttler;
+  #reading = Promise.resolve();
+  #watching = null;
+  #seenAt;
+  constructor(deps, timer) {
+    this.deps = deps;
+    this.#throttler = new Throttler(timer, BEAT);
+    this.#seenAt = deps.storage.document("hooks-seen.json");
+  }
+  static async follow({
+    timer = new SystemTimer,
+    ...deps
+  }) {
+    const runner = new HookRunner2(deps, timer);
+    await runner.#take();
+    try {
+      const watching = deps.storage.watch("");
+      watching.events.on("changed", () => void runner.changed());
+      runner.#watching = watching;
+      await runner.changed();
+    } catch (error) {
+      deps.log.error(`splates server cannot watch the project's records, so hooks run only as it starts: ${String(error)}`);
+    }
+    return runner;
+  }
+  changed() {
+    this.#throttler.call(() => {
+      this.#reading = this.#reading.then(() => this.#take()).catch((error) => this.deps.log.error(String(error)));
+    });
+    return this.#reading;
+  }
+  dispose() {
+    this.#watching?.dispose();
+    this.#throttler.dispose();
+  }
+  async#take() {
+    const events = await this.deps.journal.recent();
+    const seen = await this.#seen();
+    const last = events.at(-1);
+    if (seen === null) {
+      await this.#write(last === undefined ? null : last.at, events);
+      return;
+    }
+    const fresh = events.filter((event) => seen.at === null || event.at > seen.at || event.at === seen.at && !seen.ids.includes(event.id));
+    if (fresh.length === 0) {
+      return;
+    }
+    const automations = await this.deps.automations();
+    for (const event of fresh.flatMap(taskEventsOf2)) {
+      for (const automation of automations) {
+        const { trigger } = automation;
+        if (automation.paused === true || !("event" in trigger) || trigger.event !== event.name) {
+          continue;
+        }
+        const matching = await this.#matching(event, trigger.filter);
+        if (matching !== null) {
+          await fire(automation, { event: matching }, this.deps);
+        }
+      }
+    }
+    await this.#write(last?.at ?? null, events);
+  }
+  async#matching(event, filter) {
+    if (filter === undefined || filter.stages === undefined && filter.lanes === undefined) {
+      return event;
+    }
+    const numbers = [];
+    for (const id of event.numbers) {
+      const task = await this.deps.task(id);
+      if (task !== null && (filter.stages === undefined || filter.stages.includes(task.stage)) && (filter.lanes === undefined || task.lane !== null && filter.lanes.includes(task.lane))) {
+        numbers.push(id);
+      }
+    }
+    return numbers.length === 0 ? null : { ...event, numbers };
+  }
+  async#seen() {
+    return this.#seenAt.read().catch(() => null);
+  }
+  async#write(at, events) {
+    const ids = events.filter((each) => each.at === at).map(({ id }) => id);
+    await this.#seenAt.write({ at, ids });
+  }
+}
+var BEAT = Duration.ms(50);
+// hooks/runs.ts
+var KEPT = 5;
+
+class RunStore2 {
+  #writing = Promise.resolve();
+  #file;
+  constructor(storage) {
+    this.#file = storage.document("hooks-runs.json");
+  }
+  async read() {
+    const parsed = await this.#file.read().catch(() => null);
+    return parsed !== null && typeof parsed === "object" ? parsed : {};
+  }
+  ran(id, run) {
+    return this.#change((all) => {
+      const kept = all[id] ?? { runs: [] };
+      return {
+        ...all,
+        [id]: { ...kept, runs: [...kept.runs, run].slice(-KEPT) }
+      };
+    });
+  }
+  scheduled(id, at) {
+    return this.#change((all) => ({
+      ...all,
+      [id]: { ...all[id], runs: all[id]?.runs ?? [], scheduledAt: at }
+    }));
+  }
+  requested(id, at) {
+    return this.#change((all) => ({
+      ...all,
+      [id]: { ...all[id], runs: all[id]?.runs ?? [], requestedAt: at }
+    }));
+  }
+  #change(edit) {
+    this.#writing = this.#writing.catch(() => {}).then(async () => {
+      const all = edit(await this.read());
+      await this.#file.write(all);
+    });
+    return this.#writing;
+  }
+}
+// hooks/scheduler.ts
+import { Duration as Duration2, SystemTimer as SystemTimer2 } from "../../core/time/index.js";
+class Scheduler2 {
+  deps;
+  #ticking;
+  #looking = Promise.resolve();
+  constructor(deps, timer) {
+    this.deps = deps;
+    this.#ticking = timer.setInterval(() => void this.look(), TICK);
+  }
+  static async start({
+    timer = new SystemTimer2,
+    ...deps
+  }) {
+    const scheduler = new Scheduler2(deps, timer);
+    await scheduler.look();
+    return scheduler;
+  }
+  look() {
+    this.#looking = this.#looking.then(() => this.#take()).catch((error) => this.deps.log.error(String(error)));
+    return this.#looking;
+  }
+  dispose() {
+    this.#ticking.dispose();
+  }
+  async#take() {
+    const now = this.deps.clock.now();
+    const runs = await this.deps.runs.read();
+    for (const automation of await this.deps.automations()) {
+      const { trigger, requestedAt } = automation;
+      if (requestedAt !== undefined && requestedAt !== runs[automation.id]?.requestedAt) {
+        await this.deps.runs.requested(automation.id, requestedAt);
+        await fire(automation, { schedule: automation.id, byHand: true }, this.deps);
+      }
+      if (automation.paused === true || "event" in trigger) {
+        continue;
+      }
+      let due;
+      try {
+        const last = Math.max(Date.parse(runs[automation.id]?.scheduledAt ?? automation.createdAt), Date.parse(automation.editedAt ?? automation.createdAt));
+        due = scheduleOf(trigger).nextAfter(last);
+      } catch (error) {
+        this.deps.log.error(`automation ${automation.id} has a schedule that will not read: ${String(error)}`);
+        continue;
+      }
+      if (due > now) {
+        continue;
+      }
+      await this.deps.runs.scheduled(automation.id, new Date(now).toISOString());
+      await fire(automation, { schedule: automation.id }, this.deps);
+    }
+  }
+}
+var TICK = Duration2.mins(1);
+export { TASK_EVENTS2, taskEventsOf2, GROOMER_AUTOMATION2, GROOMER_TRIGGER2, BY_HAND2, runsNow2, HookStore2, fromHooks2, eventNamed2, stagesNamed2, lanesNamed2, hookList2, hookAdd2, hookEdit2, hookRemove2, hookGroomer2, hookPause2, hookRun2, described2, triggerLabel2, hookLabel2, AutomationRoutes2, HookRunner2, RunStore2, Scheduler2 };