@repogo/plugins 0.1.34 → 0.1.37

package/dist/testing.js

@@ -0,0 +1,3492 @@
+// @bun
+import {
+  MethodError,
+  attemptScope,
+  callFiles,
+  exports_src,
+  parseDuration,
+  toCallError,
+  workflowContext,
+  workflowScope
+} from "./index.js";
+
+// src/testing.ts
+import { mkdir as mkdir6, mkdtemp as mkdtemp2, rm as rm5 } from "fs/promises";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join8 } from "path";
+
+// src/logs.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { format } from "util";
+var logContext = new AsyncLocalStorage;
+var activeRuns = [];
+async function runWith(context, work) {
+  activeRuns.push(context);
+  try {
+    return await logContext.run(context, work);
+  } finally {
+    const i = activeRuns.lastIndexOf(context);
+    if (i >= 0)
+      activeRuns.splice(i, 1);
+  }
+}
+var textLimit = 8 * 1024;
+var levels = {
+  log: "info",
+  info: "info",
+  debug: "debug",
+  warn: "warn",
+  error: "error"
+};
+var original = { log: console.log, info: console.info, debug: console.debug, warn: console.warn, error: console.error };
+var sink = null;
+function captureConsole(to, options = {}) {
+  sink = to;
+  for (const name of Object.keys(levels)) {
+    console[name] = (...args) => {
+      if (options.passThrough)
+        original[name](...args);
+      record(levels[name], args);
+    };
+  }
+}
+function releaseConsole() {
+  sink = null;
+  Object.assign(console, original);
+}
+function record(level, args, context) {
+  const where = context ?? logContext.getStore() ?? activeRuns.at(-1);
+  if (!sink || !where) {
+    original[level === "info" ? "log" : level](...args);
+    return;
+  }
+  const text = format(...args);
+  sink({
+    at: Date.now(),
+    plugin: where.plugin,
+    level,
+    method: where.method ?? "",
+    caller: where.caller ?? "",
+    callId: where.callId ?? "",
+    chatId: where.chatId ?? "",
+    text: text.length > textLimit ? text.slice(0, textLimit) : text,
+    data: args.map(carryable)
+  });
+}
+function carryable(value) {
+  if (value instanceof Error) {
+    return { name: value.name, message: value.message, stack: value.stack ?? "" };
+  }
+  if (typeof value === "bigint")
+    return value.toString();
+  if (typeof value === "function" || typeof value === "symbol" || value === undefined)
+    return String(value);
+  try {
+    JSON.stringify(value);
+    return value;
+  } catch {
+    return format(value);
+  }
+}
+
+// src/runtime.ts
+import { AsyncLocalStorage as AsyncLocalStorage3 } from "async_hooks";
+import { mkdir as mkdir3, readdir as readdir3 } from "fs/promises";
+import { join as join3 } from "path";
+import { z as z5 } from "zod";
+
+// src/buckets.ts
+import { watch } from "fs";
+import { mkdir, readdir, readFile, rename, rm, stat, writeFile } from "fs/promises";
+import { join } from "path";
+
+// src/store.ts
+class Store {
+  options;
+  kind;
+  name;
+  tag;
+  plugins = new Set;
+  constructor(options, kind, name) {
+    this.options = options;
+    this.kind = kind;
+    this.name = name;
+    this.tag = `${options.namespace}.${kind}.${name}`;
+  }
+  close() {}
+  get sql() {
+    return this.options.database.sql;
+  }
+  async emit(event, payload) {
+    for (const plugin of this.plugins)
+      await this.options.events.emit(`${plugin}.${this.name}.${event}`, payload);
+  }
+}
+function tableName(kind, name) {
+  return `${kind}_${name.replace(/[^a-zA-Z0-9_]/g, "_")}`;
+}
+var safeName = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+
+// src/tracking.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+var current = new AsyncLocalStorage2;
+function currentAccess() {
+  return current.getStore();
+}
+async function tracked(readOnly, announce, work) {
+  const outer = current.getStore();
+  const outermost = !outer;
+  const access = outer && (outer.readOnly || !readOnly) ? outer : outer ? { ...outer, readOnly: true } : { reads: new Set, writes: new Set, readOnly, done: { value: false }, announce };
+  try {
+    const value = access === outer ? await work() : await current.run(access, work);
+    return { ok: true, value, access, outermost };
+  } catch (error) {
+    return { ok: false, error, access, outermost };
+  } finally {
+    if (outermost)
+      access.done.value = true;
+  }
+}
+function isolated(work) {
+  return current.run({ reads: new Set, writes: new Set, readOnly: true, done: { value: false }, announce: () => {} }, work);
+}
+function recordRead(tag) {
+  current.getStore()?.reads.add(tag);
+}
+function assertWritable(tag) {
+  if (current.getStore()?.readOnly) {
+    throw new MethodError("FORBIDDEN", `A query can't change data (it tried to write ${tag}).`);
+  }
+}
+function recordWrite(tag) {
+  const access = current.getStore();
+  if (!access)
+    return;
+  if (access.done.value)
+    access.announce([tag]);
+  else
+    access.writes.add(tag);
+}
+
+// src/buckets.ts
+var metaFile = "meta.json";
+var tmpFolder = ".tmp";
+var watchSettleMs = 200;
+var scanEveryMs = 60000;
+
+class Bucket extends Store {
+  schema;
+  table;
+  searchTable;
+  folder;
+  watcher = null;
+  settling = null;
+  scanning = Promise.resolve();
+  lastScan = 0;
+  constructor(options, name, schema) {
+    super(options, "buckets", name);
+    this.schema = schema;
+    if ("folder" in schema.shape)
+      throw new Error(`bucket ${name}: "folder" is the file's place, not a meta field`);
+    this.table = tableName("buckets", name);
+    this.searchTable = `${this.table}_search`;
+    this.folder = join(options.dir, "buckets", name);
+  }
+  get path() {
+    return this.folder;
+  }
+  async setup() {
+    await mkdir(join(this.folder, tmpFolder), { recursive: true });
+    await this.sql.unsafe(`create table if not exists "${this.table}" (
+        id text primary key,
+        name text not null,
+        folder text not null,
+        size integer not null,
+        type text not null,
+        meta text not null,
+        status text not null,
+        problem text,
+        revision integer not null,
+        file_print text not null,
+        meta_print text not null,
+        created_at text not null,
+        updated_at text not null
+      )`);
+    await this.sql.unsafe(`create virtual table if not exists "${this.searchTable}" using fts5(id unindexed, name, folder, text)`);
+    await this.scan();
+    this.watcher = watch(this.folder, { recursive: true }, (_, file) => {
+      if (String(file ?? "").startsWith(tmpFolder))
+        return;
+      if (this.settling)
+        clearTimeout(this.settling);
+      this.settling = setTimeout(() => void this.scan(), watchSettleMs);
+    });
+  }
+  async put(file) {
+    assertWritable(this.tag);
+    checkName(file.name);
+    const meta = this.schema.parse(file.meta ?? {});
+    const id = Bun.randomUUIDv7();
+    const staging = join(this.folder, tmpFolder, id);
+    await mkdir(staging, { recursive: true });
+    await Bun.write(join(staging, file.name), file.body);
+    await writeMeta(staging, { ...meta, ...file.folder ? { folder: file.folder } : {} });
+    await rename(staging, join(this.folder, id));
+    const { after } = await this.reindex(id);
+    return after;
+  }
+  async get(id) {
+    recordRead(this.tag);
+    const rows = await this.sql.unsafe(`select * from "${this.table}" where id = $1`, [id]);
+    return rows[0] ? this.toFile(rows[0]) : null;
+  }
+  async file(id) {
+    const found = await this.get(id);
+    if (!found)
+      throw new MethodError("NOT_FOUND", `${this.name} has no file ${id}.`);
+    return Bun.file(found.path);
+  }
+  async list(options = {}) {
+    recordRead(this.tag);
+    const rows = await this.sql.unsafe(`select * from "${this.table}"
+       where ($1 is null or folder = $1) and ($2 is null or status = $2)
+       order by created_at desc, id desc limit $3`, [options.folder ?? null, options.status ?? null, options.limit ?? 100]);
+    return rows.map((row) => this.toFile(row));
+  }
+  async search(query, options = {}) {
+    recordRead(this.tag);
+    const words = query.match(/[\p{L}\p{N}]+/gu) ?? [];
+    if (words.length === 0)
+      return [];
+    const rows = await this.sql.unsafe(`select t.* from "${this.searchTable}" s join "${this.table}" t on t.id = s.id
+       where "${this.searchTable}" match $1 order by s.rank limit $2`, [words.map((word) => `"${word}"*`).join(" "), options.limit ?? 50]);
+    return rows.map((row) => this.toFile(row));
+  }
+  async update(id, meta, options = {}) {
+    assertWritable(this.tag);
+    return this.rewrite(id, options.revision, async (folder, current2) => {
+      const merged = Object.fromEntries(Object.entries({ ...current2, ...meta }).filter(([, value]) => value !== null));
+      const { folder: place, ...fields } = merged;
+      return { ...this.schema.parse(fields), ...place ? { folder: place } : {} };
+    });
+  }
+  async move(id, to, options = {}) {
+    assertWritable(this.tag);
+    if (to.name !== undefined)
+      checkName(to.name);
+    return this.rewrite(id, options.revision, async (folder, current2, name) => {
+      if (to.name !== undefined && to.name !== name)
+        await rename(join(folder, name), join(folder, to.name));
+      const { folder: _, ...fields } = current2;
+      return { ...fields, ...to.folder ?? current2.folder ? { folder: to.folder ?? current2.folder } : {} };
+    });
+  }
+  async delete(id) {
+    assertWritable(this.tag);
+    checkID(id);
+    await rm(join(this.folder, id), { recursive: true, force: true });
+    await this.reindex(id);
+  }
+  async tick(now) {
+    if (now - this.lastScan >= scanEveryMs)
+      await this.scan();
+  }
+  close() {
+    this.watcher?.close();
+    if (this.settling)
+      clearTimeout(this.settling);
+  }
+  scan() {
+    this.scanning = this.scanning.then(() => this.scanNow()).catch((error) => {
+      console.error(`[buckets] ${this.name}: scan failed:`, toCallError(error).message);
+    });
+    return this.scanning;
+  }
+  async scanNow() {
+    this.lastScan = Date.now();
+    const entries = await readdir(this.folder, { withFileTypes: true });
+    const ids = entries.filter((entry) => entry.isDirectory() && safeName.test(entry.name)).map((entry) => entry.name);
+    const rows = await this.sql.unsafe(`select id, file_print, meta_print from "${this.table}"`);
+    const known = new Map(rows.map((row) => [row.id, row]));
+    const present = new Set(ids);
+    const changed = [];
+    for (const id of ids) {
+      const row = known.get(id);
+      const prints = await fingerprints(join(this.folder, id));
+      if (!row || row.file_print !== prints.file || row.meta_print !== prints.meta)
+        changed.push(id);
+    }
+    const gone = rows.map((row) => row.id).filter((id) => !present.has(id));
+    for (const id of [...changed, ...gone])
+      await this.reindex(id, { announce: true });
+  }
+  async reindex(id, options = {}) {
+    const result = await this.options.database.transaction(async () => {
+      const before2 = (await this.sql.unsafe(`select * from "${this.table}" where id = $1`, [id]))[0];
+      const disk = await this.read(id);
+      if (!disk) {
+        if (!before2)
+          return { before: null, after: null };
+        await this.sql.unsafe(`delete from "${this.table}" where id = $1`, [id]);
+        await this.sql.unsafe(`delete from "${this.searchTable}" where id = $1`, [id]);
+        recordWrite(this.tag);
+        return { before: before2, after: null };
+      }
+      if (before2 && before2.file_print === disk.file_print && before2.meta_print === disk.meta_print) {
+        return { before: before2, after: before2 };
+      }
+      const row = {
+        ...disk,
+        revision: (before2?.revision ?? 0) + 1,
+        created_at: before2?.created_at ?? disk.createdAt,
+        updated_at: disk.updatedAt
+      };
+      await this.sql.unsafe(`insert or replace into "${this.table}"
+         (id, name, folder, size, type, meta, status, problem, revision, file_print, meta_print, created_at, updated_at)
+         values ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)`, [
+        row.id,
+        row.name,
+        row.folder,
+        row.size,
+        row.type,
+        row.meta,
+        row.status,
+        row.problem,
+        row.revision,
+        row.file_print,
+        row.meta_print,
+        row.created_at,
+        row.updated_at
+      ]);
+      await this.sql.unsafe(`delete from "${this.searchTable}" where id = $1`, [id]);
+      await this.sql.unsafe(`insert into "${this.searchTable}" (id, name, folder, text) values ($1, $2, $3, $4)`, [
+        id,
+        row.name,
+        row.folder,
+        searchText(JSON.parse(row.meta))
+      ]);
+      recordWrite(this.tag);
+      return { before: before2, after: row };
+    });
+    const { before, after } = result;
+    if (before === after)
+      return { before: before && this.toFile(before), after: after && this.toFile(after) };
+    if (options.announce)
+      this.options.announce([this.tag]);
+    const file = after && this.toFile(after);
+    if (!before)
+      await this.emit("created", file);
+    else if (!after)
+      await this.emit("deleted", this.toFile(before));
+    else {
+      if (before.file_print !== after.file_print)
+        await this.emit("changed", file);
+      if (before.meta_print !== after.meta_print)
+        await this.emit("metaChanged", file);
+    }
+    return { before: before && this.toFile(before), after: file };
+  }
+  async read(id) {
+    const folder = join(this.folder, id);
+    const names = await readdir(folder).catch(() => null);
+    if (!names)
+      return null;
+    const files = names.filter((name) => name !== metaFile && !name.startsWith("."));
+    const prints = await fingerprints(folder);
+    const info = await stat(folder);
+    const file = files.length === 1 ? await stat(join(folder, files[0])) : null;
+    const disk = {
+      id,
+      name: files[0] ?? "",
+      folder: "",
+      size: file?.size ?? 0,
+      type: files.length === 1 ? Bun.file(join(folder, files[0])).type : "",
+      meta: "{}",
+      status: "empty",
+      problem: null,
+      file_print: prints.file,
+      meta_print: prints.meta,
+      createdAt: info.birthtime.toISOString(),
+      updatedAt: new Date(Math.max(info.mtimeMs, file?.mtimeMs ?? 0, prints.metaMtimeMs)).toISOString()
+    };
+    const raw = await readFile(join(folder, metaFile), "utf8").catch(() => null);
+    let meta = {};
+    if (raw !== null) {
+      try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+          throw new Error("meta.json is not an object");
+        meta = parsed;
+      } catch (error) {
+        return { ...disk, status: "malformed", problem: `meta.json: ${error.message}` };
+      }
+    }
+    const { folder: place, ...fields } = meta;
+    disk.folder = typeof place === "string" ? place : "";
+    disk.meta = JSON.stringify(fields);
+    if (files.length !== 1) {
+      return { ...disk, status: "malformed", problem: `A file's folder holds one file and meta.json; found ${files.length}.` };
+    }
+    if (Object.keys(fields).length === 0)
+      return disk;
+    const checked = this.schema.safeParse(fields);
+    if (!checked.success)
+      return { ...disk, status: "invalid", problem: toCallError(checked.error).message };
+    return { ...disk, status: "ok" };
+  }
+  async rewrite(id, revision, change) {
+    checkID(id);
+    const folder = join(this.folder, id);
+    await this.options.database.transaction(async () => {
+      const row = (await this.sql.unsafe(`select * from "${this.table}" where id = $1`, [id]))[0];
+      if (!row)
+        throw new MethodError("NOT_FOUND", `${this.name} has no file ${id}.`);
+      if (revision !== undefined && row.revision !== revision) {
+        throw new MethodError("VALIDATION", `${this.name} ${id} changed since it was read (revision ${row.revision}, not ${revision}).`);
+      }
+      const raw = await readFile(join(folder, metaFile), "utf8").catch(() => "{}");
+      await writeMeta(folder, await change(folder, JSON.parse(raw), row.name));
+    });
+    const { after } = await this.reindex(id);
+    return after;
+  }
+  toFile(row) {
+    return {
+      id: row.id,
+      name: row.name,
+      folder: row.folder,
+      path: join(this.folder, row.id, row.name),
+      size: row.size,
+      type: row.type,
+      meta: JSON.parse(row.meta),
+      status: row.status,
+      problem: row.problem,
+      revision: row.revision,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+}
+async function writeMeta(folder, meta) {
+  const temp = join(folder, `.${metaFile}.${crypto.randomUUID()}`);
+  await writeFile(temp, JSON.stringify(meta, null, 2) + `
+`);
+  await rename(temp, join(folder, metaFile));
+}
+async function fingerprints(folder) {
+  const names = (await readdir(folder).catch(() => [])).filter((name) => !name.startsWith(".")).sort();
+  const file = [];
+  let meta = "";
+  let metaMtimeMs = 0;
+  for (const name of names) {
+    const info = await stat(join(folder, name), { bigint: true }).catch(() => null);
+    if (!info)
+      continue;
+    const print = `${name}:${info.size}:${info.mtimeNs}`;
+    if (name === metaFile) {
+      meta = print;
+      metaMtimeMs = Number(info.mtimeMs);
+    } else
+      file.push(print);
+  }
+  return { file: file.join("|"), meta, metaMtimeMs };
+}
+function searchText(value) {
+  if (typeof value === "string" || typeof value === "number")
+    return String(value);
+  if (Array.isArray(value))
+    return value.map(searchText).join(" ");
+  if (value && typeof value === "object")
+    return Object.values(value).map(searchText).join(" ");
+  return "";
+}
+function checkID(id) {
+  if (!safeName.test(id))
+    throw new MethodError("VALIDATION", `Not a file id: ${id}`);
+}
+function checkName(name) {
+  if (!/^[^/\\\0.][^/\\\0]{0,254}$/.test(name) || name === metaFile) {
+    throw new MethodError("VALIDATION", `A file name has no slashes, doesn't start with a dot and isn't meta.json: ${name}`);
+  }
+}
+
+// src/cache.ts
+var maxBytes = 1e6;
+var keepMs = 30 * 86400000;
+
+class AnswerCache {
+  database;
+  namespace;
+  announce;
+  inflight = new Map;
+  constructor(database, namespace, announce) {
+    this.database = database;
+    this.namespace = namespace;
+    this.announce = announce;
+  }
+  async setup() {
+    await this.database.sql.unsafe(`create table if not exists cached_answers (
+        key text primary key,
+        value text not null,
+        checked_at integer not null
+      )`);
+  }
+  async read(key, options, fetch) {
+    const tag = `${this.namespace}.cached.${Bun.hash(key).toString(36)}`;
+    recordRead(tag);
+    const [row] = await this.database.sql.unsafe(`select value, checked_at from cached_answers where key = $1`, [key]);
+    if (!row)
+      return this.refresh(key, tag, options, fetch);
+    if (Date.now() - row.checked_at >= options.fresh) {
+      this.refresh(key, tag, options, fetch).catch((error) => record("error", [error]));
+    }
+    return JSON.parse(row.value);
+  }
+  async idle() {
+    while (this.inflight.size)
+      await Promise.allSettled([...this.inflight.values()]);
+  }
+  refresh(key, tag, options, fetch) {
+    const running = this.inflight.get(key);
+    if (running)
+      return running;
+    const started = Date.now();
+    const work = isolated(async () => withTimeout(Promise.resolve(fetch()), options.timeout)).then(async (value) => {
+      await this.save(key, tag, value ?? null, started);
+      return value ?? null;
+    }, async (error) => {
+      await this.database.transaction(() => this.database.sql.unsafe(`update cached_answers set checked_at = $1 where key = $2`, [Date.now(), key]));
+      throw error;
+    }).finally(() => this.inflight.delete(key));
+    this.inflight.set(key, work);
+    return work;
+  }
+  async save(key, tag, value, started) {
+    const text = JSON.stringify(value);
+    if (text.length > maxBytes)
+      return;
+    const changed = await this.database.transaction(async () => {
+      const [before] = await this.database.sql.unsafe(`select value, checked_at from cached_answers where key = $1`, [key]);
+      if (before && before.checked_at > started)
+        return false;
+      const now = Date.now();
+      await this.database.sql.unsafe(`insert into cached_answers (key, value, checked_at) values ($1, $2, $3)
+         on conflict (key) do update set value = excluded.value, checked_at = excluded.checked_at`, [key, text, now]);
+      await this.database.sql.unsafe(`delete from cached_answers where checked_at < $1`, [now - keepMs]);
+      return before?.value !== text;
+    });
+    if (changed)
+      this.announce([tag]);
+  }
+}
+function cacheKey(method, root, input) {
+  return JSON.stringify([method, root, sorted(input)]);
+}
+function sorted(value) {
+  if (Array.isArray(value))
+    return value.map(sorted);
+  if (value === null || typeof value !== "object")
+    return value;
+  return Object.fromEntries(Object.keys(value).sort().map((key) => [key, sorted(value[key])]));
+}
+function withTimeout(work, ms) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new MethodError("INTERNAL", `The answer took longer than ${Math.round(ms / 1000)} s.`)), ms);
+  });
+  return Promise.race([work, timeout]).finally(() => clearTimeout(timer));
+}
+
+// src/collections.ts
+class Collection {
+  database;
+  events;
+  plugin;
+  name;
+  schema;
+  table;
+  tag;
+  constructor(database, events, plugin, namespace, name, schema) {
+    this.database = database;
+    this.events = events;
+    this.plugin = plugin;
+    this.name = name;
+    this.schema = schema;
+    this.table = name.replace(/[^a-zA-Z0-9_]/g, "_");
+    this.tag = `${namespace}.${name}`;
+  }
+  async setup() {
+    await this.sql.unsafe(`create table if not exists "${this.table}" (
+        id text primary key,
+        data text not null,
+        created_at text not null,
+        updated_at text not null
+      )`);
+  }
+  get sql() {
+    return this.database.sql;
+  }
+  async create(input) {
+    assertWritable(this.tag);
+    const record2 = await this.database.transaction(async () => {
+      const data = this.schema.parse(input);
+      const now = new Date().toISOString();
+      const record3 = { ...data, id: crypto.randomUUID(), createdAt: now, updatedAt: now };
+      await this.sql.unsafe(`insert into "${this.table}" (id, data, created_at, updated_at) values ($1, $2, $3, $4)`, [
+        record3.id,
+        JSON.stringify(data),
+        now,
+        now
+      ]);
+      recordWrite(this.tag);
+      return record3;
+    });
+    await this.events.emit(this.eventName("created"), record2);
+    return record2;
+  }
+  async get(id) {
+    recordRead(this.tag);
+    const rows = await this.sql.unsafe(`select * from "${this.table}" where id = $1`, [id]);
+    return rows[0] ? this.toRecord(rows[0]) : null;
+  }
+  async update(id, patch) {
+    assertWritable(this.tag);
+    const { before, after } = await this.database.transaction(async () => {
+      const before2 = await this.get(id);
+      if (!before2)
+        throw new Error(`${this.name} ${id} not found`);
+      const { id: _, createdAt, updatedAt: __, ...fields } = before2;
+      const data = this.schema.parse({ ...fields, ...patch });
+      const now = new Date().toISOString();
+      await this.sql.unsafe(`update "${this.table}" set data = $1, updated_at = $2 where id = $3`, [JSON.stringify(data), now, id]);
+      recordWrite(this.tag);
+      return { before: before2, after: { ...data, id, createdAt, updatedAt: now } };
+    });
+    await this.events.emit(this.eventName("updated"), { before, after });
+    return after;
+  }
+  async delete(id) {
+    assertWritable(this.tag);
+    const before = await this.database.transaction(async () => {
+      const before2 = await this.get(id);
+      if (!before2)
+        return null;
+      await this.sql.unsafe(`delete from "${this.table}" where id = $1`, [id]);
+      recordWrite(this.tag);
+      return before2;
+    });
+    if (before)
+      await this.events.emit(this.eventName("deleted"), before);
+  }
+  async list(options = {}) {
+    recordRead(this.tag);
+    const { sql, params } = this.select(options);
+    const rows = await this.sql.unsafe(sql, params);
+    return rows.map((row) => this.toRecord(row));
+  }
+  async deleteMany(options = {}) {
+    assertWritable(this.tag);
+    const deleted = await this.database.transaction(async () => {
+      const { sql, params } = this.select(options);
+      const rows = (await this.sql.unsafe(sql, params)).map((row) => this.toRecord(row));
+      if (!rows.length)
+        return rows;
+      const ids = rows.map((row) => row.id);
+      await this.sql.unsafe(`delete from "${this.table}" where id in (${ids.map((_, i) => `$${i + 1}`).join(", ")})`, ids);
+      recordWrite(this.tag);
+      return rows;
+    });
+    for (const row of deleted)
+      await this.events.emit(this.eventName("deleted"), row);
+    return deleted.length;
+  }
+  select(options) {
+    const params = [];
+    const field = (name) => {
+      if (/["\\]/.test(name))
+        throw new Error(`bad field name: ${name}`);
+      params.push(`$."${name}"`);
+      return `json_extract(data, $${params.length})`;
+    };
+    const clauses = Object.entries(options.where ?? {}).map(([name, value]) => {
+      const path = field(name);
+      if (value === null)
+        return `${path} is null`;
+      params.push(typeof value === "boolean" ? Number(value) : value);
+      return `${path} = $${params.length}`;
+    });
+    const where = clauses.length ? `where ${clauses.join(" and ")}` : "";
+    const orderBy = options.orderBy ?? "createdAt";
+    const columns = { id: "id", createdAt: "created_at", updatedAt: "updated_at" };
+    const column = columns[orderBy] ?? field(orderBy);
+    const order = options.order === "asc" ? "asc" : "desc";
+    params.push(options.limit ?? 100, options.offset ?? 0);
+    return {
+      sql: `select * from "${this.table}" ${where} order by ${column} ${order}, id ${order} limit $${params.length - 1} offset $${params.length}`,
+      params
+    };
+  }
+  eventName(kind) {
+    return `${this.plugin}.${this.name}.${kind}`;
+  }
+  toRecord(row) {
+    return { ...JSON.parse(row.data), id: row.id, createdAt: row.created_at, updatedAt: row.updated_at };
+  }
+}
+
+// src/cron.ts
+var ranges = { second: [0, 59], minute: [0, 59], hour: [0, 23], day: [1, 31], month: [1, 12], weekday: [0, 7] };
+function parseSchedule(source) {
+  const fields = source.trim().split(/\s+/);
+  if (fields.length !== 5 && fields.length !== 6) {
+    throw new Error(`"${source}" has ${fields.length} fields; a cron has 5 (minute hour day month weekday), or 6 with seconds first`);
+  }
+  const [second, minute, hour, day, month, weekday] = fields.length === 6 ? fields : [null, ...fields];
+  const weekdays = field(weekday, "weekday");
+  if (weekdays.has(7)) {
+    weekdays.delete(7);
+    weekdays.add(0);
+  }
+  return {
+    seconds: second === null ? null : field(second, "second"),
+    minutes: field(minute, "minute"),
+    hours: field(hour, "hour"),
+    days: field(day, "day"),
+    months: field(month, "month"),
+    weekdays,
+    daysRestricted: day !== "*",
+    weekdaysRestricted: weekday !== "*"
+  };
+}
+function field(source, name) {
+  const [min, max] = ranges[name];
+  const out = new Set;
+  for (const part of source.split(",")) {
+    const [span, stepText] = part.split("/");
+    const step = stepText === undefined ? 1 : whole(stepText, name);
+    if (step < 1)
+      throw new Error(`the ${name} step in "${part}" must be at least 1`);
+    let [from, to] = [min, max];
+    if (span !== "*") {
+      const [a, b] = span.split("-");
+      from = whole(a, name);
+      to = b === undefined ? stepText === undefined ? from : max : whole(b, name);
+    }
+    if (from < min || to > max || from > to)
+      throw new Error(`the ${name} "${part}" is outside ${min}-${max}`);
+    for (let v = from;v <= to; v += step)
+      out.add(v);
+  }
+  return out;
+}
+function whole(text, name) {
+  if (!/^\d+$/.test(text))
+    throw new Error(`the ${name} "${text}" isn't a whole number`);
+  return Number(text);
+}
+function checkTimezone(zone) {
+  new Intl.DateTimeFormat("en-US", { timeZone: zone });
+}
+var formats = new Map;
+function wall(ms, zone) {
+  let format2 = formats.get(zone);
+  if (!format2) {
+    format2 = new Intl.DateTimeFormat("en-US", {
+      timeZone: zone,
+      hourCycle: "h23",
+      weekday: "short",
+      year: "numeric",
+      month: "numeric",
+      day: "numeric",
+      hour: "numeric",
+      minute: "numeric",
+      second: "numeric"
+    });
+    formats.set(zone, format2);
+  }
+  const parts = {};
+  for (const p of format2.formatToParts(new Date(ms)))
+    parts[p.type] = p.value;
+  return {
+    year: Number(parts.year),
+    month: Number(parts.month),
+    day: Number(parts.day),
+    weekday: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"].indexOf(parts.weekday),
+    hour: Number(parts.hour),
+    minute: Number(parts.minute),
+    second: Number(parts.second)
+  };
+}
+var minute = 60000;
+var horizon = 4 * 366 * 24 * 60 * minute;
+function nextDue(s, after, zone) {
+  let at = Math.floor(after / minute) * minute;
+  const end = after + horizon;
+  if (s.seconds) {
+    const first = firstSecond(s, at, after, zone);
+    if (first !== null)
+      return first;
+  }
+  at += minute;
+  while (at < end) {
+    const w = wall(at, zone);
+    if (!s.months.has(w.month)) {
+      at += untilNextDay(w);
+      continue;
+    }
+    if (!dayMatches(s, w)) {
+      at += untilNextDay(w);
+      continue;
+    }
+    if (!s.hours.has(w.hour)) {
+      at += (60 - w.minute) * minute;
+      continue;
+    }
+    if (!s.minutes.has(w.minute) || repeated(at, w, zone)) {
+      at += minute;
+      continue;
+    }
+    if (!s.seconds)
+      return at;
+    const first = firstSecond(s, at, at - 1, zone);
+    if (first !== null)
+      return first;
+    at += minute;
+  }
+  return null;
+}
+function firstSecond(s, start, after, zone) {
+  const w = wall(start, zone);
+  if (!s.months.has(w.month) || !dayMatches(s, w) || !s.hours.has(w.hour) || !s.minutes.has(w.minute) || repeated(start, w, zone))
+    return null;
+  for (let second = 0;second < 60; second++) {
+    const at = start + second * 1000;
+    if (s.seconds.has(second) && at > after)
+      return at;
+  }
+  return null;
+}
+function dayMatches(s, w) {
+  const day = s.days.has(w.day), weekday = s.weekdays.has(w.weekday);
+  if (s.daysRestricted && s.weekdaysRestricted)
+    return day || weekday;
+  return day && weekday;
+}
+function untilNextDay(w) {
+  return ((23 - w.hour) * 60 + (60 - w.minute)) * minute;
+}
+function repeated(at, w, zone) {
+  for (const back of [60, 120]) {
+    const earlier = wall(at - back * minute, zone);
+    if (earlier.day === w.day && earlier.hour === w.hour && earlier.minute === w.minute)
+      return true;
+  }
+  return false;
+}
+
+// src/database.ts
+var {SQL } = globalThis.Bun;
+
+class Database {
+  sql;
+  writes = Promise.resolve();
+  constructor(sql) {
+    this.sql = sql;
+  }
+  static async open(path) {
+    const sql = new SQL(`sqlite://${path}`);
+    await sql.unsafe("pragma busy_timeout = 5000");
+    await sql.unsafe("pragma journal_mode = wal");
+    return new Database(sql);
+  }
+  transaction(work) {
+    const result = this.writes.then(() => this.run(work), () => this.run(work));
+    this.writes = result.catch(() => {});
+    return result;
+  }
+  close() {
+    this.sql.close();
+  }
+  async run(work) {
+    await this.sql.unsafe("begin immediate");
+    try {
+      const value = await work();
+      await this.sql.unsafe("commit");
+      return value;
+    } catch (error) {
+      await this.sql.unsafe("rollback").catch(() => {});
+      throw error;
+    }
+  }
+}
+
+// src/events.ts
+class EventBus {
+  listeners = new Map;
+  all = [];
+  on(name, listener) {
+    const list = this.listeners.get(name) ?? [];
+    list.push(listener);
+    this.listeners.set(name, list);
+  }
+  onAny(listener) {
+    this.all.push(listener);
+  }
+  async emit(name, payload) {
+    const event = { name, payload, at: new Date().toISOString() };
+    const listeners = [...this.listeners.get(name) ?? [], ...this.all];
+    const results = await Promise.allSettled(listeners.map(async (listener) => listener(event)));
+    for (const result of results) {
+      if (result.status === "rejected")
+        console.error(`[events] ${name}:`, result.reason);
+    }
+  }
+}
+
+// src/generated.ts
+import { isAbsolute } from "path";
+import { z } from "zod";
+var limit = z.number().int().positive().max(500).optional();
+var ttl = z.union([z.number().positive(), z.string().regex(/^\d+(\.\d+)?[smhd]$/)]).optional();
+function kvMethods(name, kv, schema) {
+  const key = z.string().min(1);
+  const entry = z.object({ key: z.string(), value: schema, expiresAt: z.string().nullable(), createdAt: z.string(), updatedAt: z.string() });
+  return {
+    get: {
+      kind: "query",
+      description: `Get one ${name} entry by key, or null`,
+      input: z.object({ key }),
+      output: entry.nullable(),
+      run: ({ key: key2 }) => kv.entry(key2)
+    },
+    list: {
+      kind: "query",
+      description: `List ${name} entries in key order, optionally by prefix`,
+      input: z.object({ prefix: z.string().optional(), limit }),
+      output: z.array(entry),
+      run: (input) => kv.list(input)
+    },
+    set: {
+      kind: "mutation",
+      description: `Set a ${name} key; ttl ("5m", "1h", "7d" or ms) makes it expire`,
+      input: z.object({ key, value: schema, ttl }),
+      output: entry,
+      run: ({ key: key2, value, ttl: ttl2 }) => kv.set(key2, value, { ttl: ttl2 })
+    },
+    delete: {
+      kind: "mutation",
+      description: `Delete a ${name} key`,
+      input: z.object({ key }),
+      output: z.null(),
+      confirm: "Delete this key?",
+      run: async ({ key: key2 }) => (await kv.delete(key2), null)
+    }
+  };
+}
+function streamMethods(name, stream, schema) {
+  const key = z.string().min(1);
+  const line = z.object({ id: z.string(), key: z.string(), offset: z.number(), at: z.string(), data: schema });
+  return {
+    tail: {
+      kind: "stream",
+      description: `Follow a ${name} key live: its last lines (100 unless last says), then each new one, until it ends`,
+      input: z.object({ key, from: z.number().int().min(0).optional(), last: z.number().int().positive().max(500).optional() }),
+      run: ({ key: key2, from, last }, signal) => stream.follow(key2, { from, last, signal })
+    },
+    read: {
+      kind: "query",
+      description: `Read a ${name} key's lines from an offset`,
+      input: z.object({ key, from: z.number().int().min(0).optional(), limit }),
+      output: z.array(line),
+      run: ({ key: key2, ...options }) => stream.read(key2, options)
+    },
+    keys: {
+      kind: "query",
+      description: `List ${name} keys, most recently written first`,
+      input: z.object({ limit }),
+      output: z.array(z.object({ key: z.string(), lines: z.number(), bytes: z.number(), endedAt: z.string().nullable(), updatedAt: z.string() })),
+      run: (input) => stream.keys(input)
+    },
+    append: {
+      kind: "mutation",
+      description: `Append a line to a ${name} key`,
+      input: z.object({ key, data: schema }),
+      output: line,
+      run: ({ key: key2, data }) => stream.append(key2, data)
+    },
+    end: {
+      kind: "mutation",
+      description: `End a ${name} key: followers stop and appends fail`,
+      input: z.object({ key }),
+      output: z.null(),
+      run: async ({ key: key2 }) => (await stream.end(key2), null)
+    },
+    delete: {
+      kind: "mutation",
+      description: `Delete a ${name} key and its lines`,
+      input: z.object({ key }),
+      output: z.null(),
+      confirm: "Delete this stream and its lines?",
+      run: async ({ key: key2 }) => (await stream.delete(key2), null)
+    }
+  };
+}
+function bucketMethods(name, bucket, schema) {
+  const id = z.string().min(1);
+  const status = z.enum(["ok", "empty", "invalid", "malformed"]);
+  const file = z.object({
+    id: z.string(),
+    name: z.string(),
+    folder: z.string(),
+    path: z.string(),
+    size: z.number(),
+    type: z.string(),
+    meta: schema.partial(),
+    status,
+    problem: z.string().nullable(),
+    revision: z.number(),
+    createdAt: z.string(),
+    updatedAt: z.string()
+  });
+  const revision = z.number().int().optional();
+  return {
+    list: {
+      kind: "query",
+      description: `List ${name} files, newest first, optionally in one folder or with one status`,
+      input: z.object({ folder: z.string().optional(), status: status.optional(), limit }),
+      output: z.array(file),
+      run: (input) => bucket.list(input)
+    },
+    search: {
+      kind: "query",
+      description: `Search ${name} files by name, folder and meta`,
+      input: z.object({ query: z.string(), limit }),
+      output: z.array(file),
+      run: ({ query, limit: limit2 }) => bucket.search(query, { limit: limit2 })
+    },
+    get: {
+      kind: "query",
+      description: `Get one ${name} file by id, or null`,
+      input: z.object({ id }),
+      output: file.nullable(),
+      run: ({ id: id2 }) => bucket.get(id2)
+    },
+    put: {
+      kind: "mutation",
+      description: `Add a file to ${name}: its name, and text or an absolute path to copy`,
+      input: z.object({
+        name: z.string(),
+        folder: z.string().optional(),
+        text: z.string().optional(),
+        from: z.string().refine(isAbsolute, "from is an absolute path").optional(),
+        meta: schema.optional()
+      }),
+      output: file,
+      run: async ({ name: name2, folder, text, from, meta }) => {
+        if (text === undefined === (from === undefined))
+          throw new MethodError("VALIDATION", "Send text or from, one of them.");
+        return bucket.put({ name: name2, folder, meta, body: text ?? Bun.file(from) });
+      }
+    },
+    update: {
+      kind: "mutation",
+      description: `Change fields of a ${name} file's meta; null removes one`,
+      input: z.object({ id, meta: z.record(z.string(), z.unknown()), revision }),
+      output: file,
+      run: ({ id: id2, meta, revision: revision2 }) => bucket.update(id2, meta, { revision: revision2 })
+    },
+    move: {
+      kind: "mutation",
+      description: `Rename a ${name} file or move it to another folder`,
+      input: z.object({ id, name: z.string().optional(), folder: z.string().optional(), revision }),
+      output: file,
+      run: ({ id: id2, name: name2, folder, revision: revision2 }) => bucket.move(id2, { name: name2, folder }, { revision: revision2 })
+    },
+    delete: {
+      kind: "mutation",
+      description: `Delete a ${name} file and its meta`,
+      input: z.object({ id }),
+      output: z.null(),
+      confirm: "Delete this file?",
+      run: async ({ id: id2 }) => (await bucket.delete(id2), null)
+    }
+  };
+}
+
+// src/kv.ts
+class Kv extends Store {
+  schema;
+  table;
+  constructor(options, name, schema) {
+    super(options, "kv", name);
+    this.schema = schema;
+    this.table = tableName("kv", name);
+  }
+  async setup() {
+    await this.sql.unsafe(`create table if not exists "${this.table}" (
+        key text primary key,
+        value text not null,
+        expires_at integer,
+        created_at text not null,
+        updated_at text not null
+      )`);
+  }
+  async get(key) {
+    return (await this.entry(key))?.value ?? null;
+  }
+  async entry(key) {
+    recordRead(this.tag);
+    const row = await this.live(key);
+    return row ? toEntry(row) : null;
+  }
+  async set(key, value, options = {}) {
+    assertWritable(this.tag);
+    const parsed = this.schema.parse(value);
+    const expiresAt = options.ttl === undefined ? null : Date.now() + parseDuration(options.ttl);
+    const { entry, created } = await this.options.database.transaction(async () => {
+      const before = await this.live(key);
+      const now = new Date().toISOString();
+      const row = {
+        key,
+        value: JSON.stringify(parsed),
+        expires_at: expiresAt,
+        created_at: before?.created_at ?? now,
+        updated_at: now
+      };
+      await this.sql.unsafe(`insert into "${this.table}" (key, value, expires_at, created_at, updated_at) values ($1, $2, $3, $4, $5)
+         on conflict (key) do update set value = excluded.value, expires_at = excluded.expires_at,
+           created_at = excluded.created_at, updated_at = excluded.updated_at`, [row.key, row.value, row.expires_at, row.created_at, row.updated_at]);
+      recordWrite(this.tag);
+      return { entry: toEntry(row), created: !before };
+    });
+    await this.emit(created ? "created" : "updated", entry);
+    return entry;
+  }
+  async delete(key) {
+    assertWritable(this.tag);
+    const before = await this.options.database.transaction(async () => {
+      const before2 = await this.live(key);
+      await this.sql.unsafe(`delete from "${this.table}" where key = $1`, [key]);
+      if (before2)
+        recordWrite(this.tag);
+      return before2;
+    });
+    if (before)
+      await this.emit("deleted", toEntry(before));
+  }
+  async list(options = {}) {
+    recordRead(this.tag);
+    const prefix = options.prefix ?? "";
+    const rows = await this.sql.unsafe(`select * from "${this.table}"
+       where substr(key, 1, length($1)) = $1 and (expires_at is null or expires_at > $2)
+       order by key limit $3`, [prefix, Date.now(), options.limit ?? 100]);
+    return rows.map(toEntry);
+  }
+  async tick(now) {
+    const expired = await this.options.database.transaction(async () => {
+      const rows = await this.sql.unsafe(`select * from "${this.table}" where expires_at <= $1`, [now]);
+      if (rows.length > 0)
+        await this.sql.unsafe(`delete from "${this.table}" where expires_at <= $1`, [now]);
+      return rows;
+    });
+    if (expired.length === 0)
+      return;
+    this.options.announce([this.tag]);
+    for (const row of expired)
+      await this.emit("deleted", toEntry(row));
+  }
+  async live(key) {
+    const rows = await this.sql.unsafe(`select * from "${this.table}" where key = $1 and (expires_at is null or expires_at > $2)`, [key, Date.now()]);
+    return rows[0] ?? null;
+  }
+}
+function toEntry(row) {
+  return {
+    key: row.key,
+    value: JSON.parse(row.value),
+    expiresAt: row.expires_at === null ? null : new Date(row.expires_at).toISOString(),
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+
+// src/streams.ts
+import { appendFile, mkdir as mkdir2, readdir as readdir2, readFile as readFile2, rm as rm2, stat as stat2, truncate } from "fs/promises";
+import { join as join2 } from "path";
+var defaultRetain = { age: "7d", bytes: 50000000 };
+var segmentBytes = 1e6;
+var retainEveryMs = 60000;
+var followPollMs = 1000;
+
+class Stream extends Store {
+  schema;
+  table;
+  folder;
+  ageMs;
+  maxBytes;
+  lastRetain = 0;
+  waiting = new Map;
+  constructor(options, name, schema, retain = defaultRetain) {
+    super(options, "streams", name);
+    this.schema = schema;
+    this.table = tableName("streams", name);
+    this.folder = join2(options.dir, "streams", name);
+    this.ageMs = retain === "forever" || retain.age === undefined ? null : parseDuration(retain.age);
+    this.maxBytes = retain === "forever" ? null : retain.bytes ?? null;
+  }
+  get path() {
+    return this.folder;
+  }
+  async setup() {
+    await mkdir2(this.folder, { recursive: true });
+    await this.sql.unsafe(`create table if not exists "${this.table}" (
+        key text primary key,
+        first_offset integer not null,
+        next_offset integer not null,
+        segment integer not null,
+        segment_bytes integer not null,
+        bytes integer not null,
+        ended_at text,
+        updated_at text not null
+      )`);
+  }
+  async append(key, data) {
+    assertWritable(this.tag);
+    checkKey(key);
+    const parsed = this.schema.parse(data);
+    const entry = await this.options.database.transaction(async () => {
+      const row = await this.row(key) ?? await this.start(key);
+      if (row.ended_at)
+        throw new MethodError("VALIDATION", `${this.name} ${key} has ended; append to a new key.`);
+      await this.cutUncommitted(row);
+      const at = new Date().toISOString();
+      const line = JSON.stringify({ offset: row.next_offset, at, data: parsed }) + `
+`;
+      const size = Buffer.byteLength(line);
+      const segment = row.segment_bytes > 0 && row.segment_bytes + size > segmentBytes ? row.next_offset : row.segment;
+      const written = segment === row.segment ? row.segment_bytes : 0;
+      await appendFile(this.segmentPath(key, segment), line);
+      await this.sql.unsafe(`update "${this.table}" set next_offset = $1, segment = $2, segment_bytes = $3, bytes = bytes + $4, updated_at = $5 where key = $6`, [row.next_offset + 1, segment, written + size, size, at, key]);
+      recordWrite(this.tag);
+      return { id: `${key}:${row.next_offset}`, key, offset: row.next_offset, at, data: parsed };
+    });
+    this.wake(key);
+    return entry;
+  }
+  async read(key, options = {}) {
+    recordRead(this.tag);
+    const row = await this.row(key);
+    return row ? this.lines(row, options.from ?? 0, options.limit ?? 100) : [];
+  }
+  async* follow(key, options) {
+    recordRead(this.tag);
+    let next = options.from ?? Math.max(0, ((await this.row(key))?.next_offset ?? 0) - (options.last ?? 100));
+    while (!options.signal.aborted) {
+      const appended = this.nextAppend(key, options.signal);
+      const row = await this.row(key);
+      const lines = row ? await this.lines(row, next, 500) : [];
+      for (const line of lines)
+        yield line;
+      next = lines.at(-1) ? lines.at(-1).offset + 1 : next;
+      if (lines.length === 500)
+        continue;
+      if (row?.ended_at)
+        return;
+      await appended;
+    }
+  }
+  async end(key) {
+    assertWritable(this.tag);
+    await this.options.database.transaction(async () => {
+      if (!await this.row(key))
+        throw new MethodError("NOT_FOUND", `${this.name} has no key ${key}.`);
+      const now = new Date().toISOString();
+      await this.sql.unsafe(`update "${this.table}" set ended_at = $1, updated_at = $1 where key = $2`, [now, key]);
+      recordWrite(this.tag);
+    });
+    this.wake(key);
+  }
+  async keys(options = {}) {
+    recordRead(this.tag);
+    const rows = await this.sql.unsafe(`select * from "${this.table}" order by updated_at desc limit $1`, [
+      options.limit ?? 100
+    ]);
+    return rows.map(toKey);
+  }
+  async delete(key) {
+    assertWritable(this.tag);
+    await this.options.database.transaction(async () => {
+      await rm2(join2(this.folder, key), { recursive: true, force: true });
+      await this.sql.unsafe(`delete from "${this.table}" where key = $1`, [key]);
+      recordWrite(this.tag);
+    });
+    this.wake(key);
+  }
+  async tick(now) {
+    if (now - this.lastRetain < retainEveryMs || this.ageMs === null && this.maxBytes === null)
+      return;
+    this.lastRetain = now;
+    const changed = await this.options.database.transaction(async () => {
+      let changed2 = false;
+      const rows = await this.sql.unsafe(`select * from "${this.table}"`);
+      for (const row of rows)
+        changed2 = await this.retain(row, now) || changed2;
+      return changed2;
+    });
+    if (changed)
+      this.options.announce([this.tag]);
+  }
+  close() {
+    for (const wakers of this.waiting.values())
+      for (const wake of wakers)
+        wake();
+    this.waiting.clear();
+  }
+  async retain(row, now) {
+    if (this.ageMs !== null && Date.parse(row.updated_at) <= now - this.ageMs) {
+      await rm2(join2(this.folder, row.key), { recursive: true, force: true });
+      await this.sql.unsafe(`delete from "${this.table}" where key = $1`, [row.key]);
+      return true;
+    }
+    const segments = (await this.segments(row.key)).filter((start) => start < row.segment);
+    let { bytes, first_offset: first } = row;
+    for (const [index, start] of segments.entries()) {
+      const path = this.segmentPath(row.key, start);
+      const info = await stat2(path);
+      const old = this.ageMs !== null && info.mtimeMs <= now - this.ageMs;
+      const over = this.maxBytes !== null && bytes > this.maxBytes;
+      if (!old && !over)
+        break;
+      await rm2(path, { force: true });
+      bytes -= info.size;
+      first = segments[index + 1] ?? row.segment;
+    }
+    if (first === row.first_offset)
+      return false;
+    await this.sql.unsafe(`update "${this.table}" set first_offset = $1, bytes = $2 where key = $3`, [first, bytes, row.key]);
+    return true;
+  }
+  async lines(row, from, limit2) {
+    const start = Math.max(from, row.first_offset);
+    const segments = await this.segments(row.key);
+    const firstSegment = segments.findLastIndex((segment) => segment <= start);
+    const lines = [];
+    for (const segment of segments.slice(Math.max(0, firstSegment))) {
+      const text = await readFile2(this.segmentPath(row.key, segment), "utf8").catch(() => "");
+      for (const raw of text.split(`
+`)) {
+        if (!raw)
+          continue;
+        const line = JSON.parse(raw);
+        if (line.offset < start || line.offset >= row.next_offset)
+          continue;
+        lines.push({ id: `${row.key}:${line.offset}`, key: row.key, ...line });
+        if (lines.length >= limit2)
+          return lines;
+      }
+    }
+    return lines;
+  }
+  async cutUncommitted(row) {
+    const path = this.segmentPath(row.key, row.segment);
+    const size = await stat2(path).then((info) => info.size, () => 0);
+    if (size > row.segment_bytes)
+      await truncate(path, row.segment_bytes);
+  }
+  async start(key) {
+    await mkdir2(join2(this.folder, key), { recursive: true });
+    const row = {
+      key,
+      first_offset: 0,
+      next_offset: 0,
+      segment: 0,
+      segment_bytes: 0,
+      bytes: 0,
+      ended_at: null,
+      updated_at: new Date().toISOString()
+    };
+    await this.sql.unsafe(`insert into "${this.table}" (key, first_offset, next_offset, segment, segment_bytes, bytes, updated_at)
+       values ($1, 0, 0, 0, 0, 0, $2)`, [key, row.updated_at]);
+    return row;
+  }
+  async row(key) {
+    const rows = await this.sql.unsafe(`select * from "${this.table}" where key = $1`, [key]);
+    return rows[0] ?? null;
+  }
+  async segments(key) {
+    const names = await readdir2(join2(this.folder, key)).catch(() => []);
+    return names.filter((name) => /^\d+\.jsonl$/.test(name)).map((name) => Number.parseInt(name)).sort((a, b) => a - b);
+  }
+  segmentPath(key, segment) {
+    return join2(this.folder, key, `${String(segment).padStart(12, "0")}.jsonl`);
+  }
+  nextAppend(key, signal) {
+    return new Promise((resolve) => {
+      const wakers = this.waiting.get(key) ?? new Set;
+      this.waiting.set(key, wakers);
+      const done = () => {
+        clearTimeout(timer);
+        signal.removeEventListener("abort", done);
+        wakers.delete(done);
+        resolve();
+      };
+      const timer = setTimeout(done, followPollMs);
+      signal.addEventListener("abort", done);
+      wakers.add(done);
+    });
+  }
+  wake(key) {
+    for (const wake of [...this.waiting.get(key) ?? []])
+      wake();
+  }
+}
+function checkKey(key) {
+  if (!safeName.test(key)) {
+    throw new MethodError("VALIDATION", `A stream key is letters, digits, dots, dashes and underscores, up to 128: ${key}`);
+  }
+}
+function toKey(row) {
+  return {
+    key: row.key,
+    lines: row.next_offset - row.first_offset,
+    bytes: row.bytes,
+    endedAt: row.ended_at,
+    updatedAt: row.updated_at
+  };
+}
+
+// src/workflow/register.ts
+import { z as z4 } from "zod";
+
+// src/workflow/contracts.ts
+import { z as z3 } from "zod";
+import { isAbsolute as isAbsolute2 } from "path";
+
+// src/workflow/policy.ts
+import { z as z2 } from "zod";
+var duration = z2.custom((value) => typeof value === "number" || typeof value === "string");
+var StepOptionsSchema = z2.object({
+  kind: z2.enum(["query", "mutation"]).optional(),
+  attempts: z2.number().optional(),
+  timeout: duration.optional(),
+  backoff: z2.object({ initial: duration.optional(), factor: z2.number().optional(), max: duration.optional() }).strict().optional()
+}).strict();
+var maxDurationMs = 365 * 86400000;
+var DurationMsSchema = z2.number().int().positive().max(maxDurationMs);
+var StepPolicySchema = z2.object({
+  kind: z2.enum(["query", "mutation"]),
+  attempts: z2.number().int().min(1).max(100),
+  timeoutMs: DurationMsSchema,
+  backoff: z2.object({ initialMs: DurationMsSchema, factor: z2.number().min(1).max(1000), maxMs: DurationMsSchema }).strict()
+}).strict().refine((value) => value.kind === "query" || value.attempts === 1, "Only query steps may retry.").refine((value) => value.backoff.initialMs <= value.backoff.maxMs, "Initial backoff must not exceed its maximum.");
+function durationMs(value) {
+  return DurationMsSchema.parse(Math.ceil(parseDuration(value)));
+}
+
+// src/workflow/contracts.ts
+var RunSummarySchema = z3.object({
+  id: z3.string(),
+  workflow: z3.string(),
+  status: z3.enum(["pending", "running", "waiting", "attention", "completed", "failed", "cancelled", "expired", "unknown", "blocked"]),
+  currentStep: z3.string().nullable(),
+  attempt: z3.number().int(),
+  createdAt: z3.string(),
+  updatedAt: z3.string(),
+  nextAttemptAt: z3.string().nullable(),
+  deadlineAt: z3.string().nullable()
+});
+var RunMetadataSchema = z3.object({
+  id: z3.string().uuid(),
+  dir: z3.string().refine(isAbsolute2),
+  root: z3.string().refine(isAbsolute2),
+  namespace: z3.string().regex(/^[a-z0-9][a-z0-9.-]*$/),
+  plugin: z3.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+  caller: z3.enum(["card", "agent", "cron", "code", "http"]),
+  workflow: z3.string().regex(/^[a-z][a-zA-Z0-9_-]*$/),
+  input: z3.json(),
+  key: z3.string().nullable(),
+  timeoutMs: DurationMsSchema,
+  maxOfflineMs: DurationMsSchema,
+  retentionMs: DurationMsSchema,
+  createdAt: z3.iso.datetime()
+}).strict();
+var RunLocationSchema = RunMetadataSchema.omit({ input: true, timeoutMs: true, workflow: true, createdAt: true });
+
+// src/workflow/register.ts
+function workflowTag(namespace) {
+  return `${namespace}.workflows`;
+}
+function workflowMethods(plugin, namespace, name, definition, ctx, bridge, directory) {
+  const invoke = (operation, input) => {
+    const dir = directory();
+    if (!bridge || !dir)
+      throw new MethodError("INTERNAL", "Durable workflows run through the plugins service with source files.");
+    return bridge({ operation, dir, plugin, namespace, workflow: name, root: ctx.root, caller: ctx.caller, input, settings: workflowSettings(definition) });
+  };
+  const id = z4.object({ id: z4.string().uuid() }).strict();
+  const spec = (method, kind, input, description, confirm, output) => ({
+    name: `${plugin}.${name}.${method}`,
+    plugin,
+    kind,
+    input,
+    description,
+    confirm,
+    output,
+    run: async (input2, raw) => {
+      if (kind === "query")
+        recordRead(workflowTag(namespace));
+      const request = method === "start" ? { ...input2, input: raw.input } : input2;
+      return invoke(method, request);
+    }
+  });
+  return [
+    spec("list", "query", z4.object({ limit: z4.number().int().min(1).max(100).default(20), status: z4.string().optional(), cursor: z4.string().optional() }).strict(), "List workflow runs", undefined, z4.object({ items: z4.array(RunSummarySchema), cursor: z4.string().nullable() })),
+    spec("get", "query", id, "Get one workflow run"),
+    spec("start", "mutation", z4.object({ input: definition.input, key: z4.string().min(1).max(200).optional() }).strict(), definition.description ?? "Start a durable workflow", definition.confirm, RunSummarySchema),
+    spec("retry", "mutation", id, "Retry a safely failed query step", undefined, RunSummarySchema),
+    spec("restart", "mutation", id, "Start a run that needs attention over from the beginning, on the current code", undefined, RunSummarySchema),
+    spec("cancel", "mutation", id, "Request cancellation of a workflow", undefined, RunSummarySchema),
+    spec("cancelAll", "mutation", z4.object({ status: z4.string().optional() }).strict(), "Cancel every unfinished run, or only those in one status", undefined, z4.object({ cancelled: z4.number().int() }))
+  ];
+}
+function workflowSettings(definition) {
+  return {
+    timeoutMs: durationMs(definition.timeout ?? "30d"),
+    maxOfflineMs: durationMs(definition.maxOffline ?? "14d"),
+    retentionMs: durationMs(definition.retention ?? "30d")
+  };
+}
+
+// src/runtime.ts
+var sampleMs = Number(process.env.REPOGO_PLUGINS_SAMPLE_MS ?? 5000);
+var sampleLimit = 200;
+var cronLateMs = 2 * 60000;
+var never = new AbortController().signal;
+var agentTimeoutMs = 10 * 60000;
+var agentWaitMs = 50000;
+var pluginName = /^[a-z][a-z0-9-]*$/;
+var namespaceName = /^[a-z][a-z0-9.-]*$/;
+
+class Runtime {
+  dataDir;
+  root;
+  host;
+  workflows;
+  events = new EventBus;
+  methods = new Map;
+  plugins = new Map;
+  crons = [];
+  contexts = new Map;
+  databases = new Map;
+  answerCaches = new Map;
+  stores = new Map;
+  invalidationListeners = new Set;
+  noticeListeners = new Set;
+  pluginsDir = null;
+  constructor(dataDir, root, host, workflows) {
+    this.dataDir = dataDir;
+    this.root = root;
+    this.host = host;
+    this.workflows = workflows;
+  }
+  callRoot = new AsyncLocalStorage3;
+  callSignal = new AsyncLocalStorage3;
+  callCaller = new AsyncLocalStorage3;
+  callConfirmed = new AsyncLocalStorage3;
+  cronsTag = `crons.${crypto.randomUUID()}`;
+  static async open(options) {
+    await mkdir3(options.dataDir, { recursive: true });
+    return new Runtime(options.dataDir, options.root ?? process.cwd(), options.host, options.workflows);
+  }
+  async loadDir(pluginsDir, only = null) {
+    this.pluginsDir = pluginsDir;
+    const entries = await readdir3(pluginsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || !pluginName.test(entry.name))
+        continue;
+      if (only && !only.includes(entry.name))
+        continue;
+      const module = await logContext.run({ plugin: entry.name }, () => import(join3(pluginsDir, entry.name, "app.ts")));
+      await this.add(entry.name, module.default);
+    }
+  }
+  async add(name, plugin) {
+    if (!pluginName.test(name))
+      throw new Error(`plugin names are lowercase letters, digits and hyphens: ${name}`);
+    const collections = {};
+    const buckets = {};
+    const kv = {};
+    const streams = {};
+    const declared = Object.entries(plugin.collections ?? {});
+    const stores = [...declared.map(([n]) => n), ...[plugin.kv, plugin.streams, plugin.buckets].flatMap((group) => Object.keys(group ?? {}))];
+    const hidden = new Set(plugin.private ?? []);
+    for (const store of hidden) {
+      if (!stores.includes(store))
+        throw new Error(`plugin ${name} lists ${store} as private, but keeps no collection, kv, stream or bucket by that name`);
+    }
+    const hasCache = Object.values(plugin.methods ?? {}).some((method) => method.cache);
+    const hasData = hasCache || Object.keys(plugin.workflows ?? {}).length > 0 || declared.length > 0 || [plugin.buckets, plugin.kv, plugin.streams].some((stores2) => Object.keys(stores2 ?? {}).length > 0);
+    const namespace = plugin.namespace ?? "";
+    if (hasData && !namespace)
+      throw new Error(`plugin ${name} keeps data, so it needs a namespace: "<project>.${name}" for one project's, "${name}" to share it`);
+    if (namespace && !namespaceName.test(namespace))
+      throw new Error(`a plugin's namespace is lowercase letters, digits, dots and hyphens: ${namespace}`);
+    const file = hasData ? await this.database(namespace) : null;
+    for (const [collectionName, schema] of declared) {
+      const collection = new Collection(file, this.events, name, namespace, collectionName, schema);
+      await collection.setup();
+      collections[collectionName] = collection;
+      if (!hidden.has(collectionName))
+        this.registerCrud(name, collectionName, collection, schema);
+    }
+    const options = {
+      database: file,
+      events: this.events,
+      namespace,
+      dir: join3(this.dataDir, namespace),
+      announce: (tags) => this.notifyInvalidated(tags)
+    };
+    for (const [storeName, schema] of Object.entries(plugin.kv ?? {})) {
+      const store = await this.store(name, "kv", storeName, schema, () => new Kv(options, storeName, schema));
+      kv[storeName] = store;
+      if (!hidden.has(storeName))
+        this.registerGenerated(name, storeName, kvMethods(storeName, store, schema));
+    }
+    for (const [storeName, definition] of Object.entries(plugin.streams ?? {})) {
+      const { item, retain } = "item" in definition ? definition : { item: definition, retain: defaultRetain };
+      const store = await this.store(name, "streams", storeName, item, () => new Stream(options, storeName, item, retain), retain);
+      streams[storeName] = store;
+      if (!hidden.has(storeName))
+        this.registerGenerated(name, storeName, streamMethods(storeName, store, item));
+    }
+    for (const [storeName, schema] of Object.entries(plugin.buckets ?? {})) {
+      const store = await this.store(name, "buckets", storeName, schema, () => new Bucket(options, storeName, schema));
+      buckets[storeName] = store;
+      if (!hidden.has(storeName))
+        this.registerGenerated(name, storeName, bucketMethods(storeName, store, schema));
+    }
+    const runtime = this;
+    const ctx = {
+      plugin: name,
+      get caller() {
+        return runtime.callCaller.getStore() ?? "code";
+      },
+      get root() {
+        return runtime.callRoot.getStore() ?? runtime.root;
+      },
+      get signal() {
+        return attemptScope.getStore()?.signal ?? runtime.callSignal.getStore() ?? never;
+      },
+      collections,
+      buckets,
+      kv,
+      streams,
+      call: async (method, input) => (await this.call(method.includes(".") ? method : `${name}.${method}`, input)).result,
+      emit: (event, payload) => this.events.emit(`${name}.${event}`, payload),
+      host: async (method, params) => {
+        if (workflowScope.getStore())
+          assertWritable("host methods");
+        if (!runtime.host)
+          throw new MethodError("INTERNAL", "ctx.host runs only under the RepoGo host.");
+        return runtime.host(name, method, params ?? {});
+      },
+      mcp: async (server, tool, input) => {
+        if (!runtime.host)
+          throw new MethodError("INTERNAL", "ctx.mcp runs only under the RepoGo host.");
+        const answer = await runtime.host(name, "mcp.call", {
+          project: ctx.root,
+          server,
+          tool,
+          input: input ?? {},
+          read: currentAccess()?.readOnly ?? false,
+          confirmed: runtime.callConfirmed.getStore() ?? false
+        });
+        if (answer.error)
+          throw mcpFailure(server, tool, answer.error);
+        return answer.result ?? null;
+      },
+      plugins: () => {
+        recordRead(this.cronsTag);
+        return this.manifest().plugins;
+      },
+      notify: (notice) => {
+        assertWritable("notifications");
+        const sent = { ...notice, plugin: name, root: runtime.callRoot.getStore() ?? runtime.root };
+        for (const listener of runtime.noticeListeners)
+          listener(sent);
+      },
+      activity: async (activity) => {
+        assertWritable("activities");
+        if (!runtime.host)
+          throw new MethodError("INTERNAL", "ctx.activity runs only under the RepoGo host.");
+        await runtime.host(name, "activities.set", activityParams(activity, ctx.root));
+      },
+      agent: (prompt, options2) => this.agent(name, ctx, prompt, options2 ?? {}),
+      log: (...args) => console.log(...args)
+    };
+    const cache = hasCache ? await this.answerCache(namespace, file) : null;
+    for (const [methodName, method] of Object.entries(plugin.methods ?? {})) {
+      const fullName = `${name}.${methodName}`;
+      const options2 = method.cache;
+      this.register({
+        name: fullName,
+        plugin: name,
+        kind: method.kind,
+        description: method.description,
+        confirm: method.confirm,
+        http: method.http,
+        input: method.input,
+        output: method.output,
+        run: options2 && cache ? async (input) => cache.read(cacheKey(fullName, options2.shared ? null : ctx.root, input), options2, () => method.run(input, ctx)) : async (input) => method.run(input, ctx)
+      });
+    }
+    this.contexts.set(name, ctx);
+    for (const [workflowName, definition] of Object.entries(plugin.workflows ?? {})) {
+      if (!/^[a-z][a-zA-Z0-9_-]*$/.test(workflowName))
+        throw new Error(`Invalid workflow name ${workflowName}.`);
+      workflowSettings(definition);
+      for (const method of workflowMethods(name, namespace, workflowName, definition, ctx, this.workflows, () => this.pluginsDir))
+        this.register(method);
+    }
+    for (const [event, handler] of Object.entries(plugin.on ?? {})) {
+      this.events.on(`${name}.${event}`, (e) => logContext.run(this.logContextFor(name), () => handler(e.payload, ctx)));
+    }
+    this.plugins.set(name, plugin);
+  }
+  async executeWorkflow(plugin, name, input, context) {
+    const definition = this.plugins.get(plugin)?.workflows?.[name];
+    if (!definition)
+      throw new MethodError("NOT_FOUND", `No workflow ${plugin}.${name}.`);
+    const ctx = this.contexts.get(plugin);
+    return workflowScope.run(true, () => this.callCaller.run(context.caller, () => this.callRoot.run(context.root, () => this.callSignal.run(context.signal, () => runWith({ plugin, method: `${plugin}.${name}`, caller: context.caller, callId: context.runId }, async () => {
+      const result = await definition.run(definition.input.parse(input), workflowContext(ctx, context));
+      return definition.output ? definition.output.parse(result) : result;
+    })))));
+  }
+  async call(name, input = {}, options = {}) {
+    if (options.files) {
+      const { files, ...rest } = options;
+      const fields = input ?? {};
+      if (Object.hasOwn(fields, "files"))
+        throw new MethodError("VALIDATION", "files comes from the upload; leave it out of the input.");
+      return callFiles.run(files, () => this.call(name, { ...fields, files }, rest));
+    }
+    if (options.root && options.root !== this.callRoot.getStore()) {
+      const { root, ...rest } = options;
+      return this.callRoot.run(root, () => this.call(name, input, rest));
+    }
+    if (options.caller && options.caller !== this.callCaller.getStore()) {
+      const { caller, ...rest } = options;
+      return this.callCaller.run(caller, () => this.call(name, input, rest));
+    }
+    const method = this.methods.get(name);
+    if (!method)
+      throw new MethodError("NOT_FOUND", `There is no method ${name}.`);
+    const where = this.logContextFor(method.plugin, name, options.chat);
+    if (!logContext.getStore())
+      return runWith(where, () => this.call(name, input, options));
+    if (where !== logContext.getStore())
+      return logContext.run(where, () => this.call(name, input, options));
+    if ((options.expect === "query" || currentAccess()?.readOnly) && method.kind === "mutation") {
+      throw new MethodError("FORBIDDEN", `${name} changes data, so it only runs when the user acts.`);
+    }
+    const raw = input ?? {};
+    const parsed = method.input.parse(raw);
+    if (method.confirm && (options.confirmed === false || workflowScope.getStore()))
+      throw new MethodError("CONFIRM", fillConfirm(method.confirm, parsed));
+    if (method.kind === "stream")
+      return { result: await this.sample(name, input), reads: [], invalidates: [] };
+    const confirmed = this.callConfirmed.getStore() ?? false;
+    const run = await tracked(method.kind === "query", (tags) => this.notifyInvalidated(tags), () => this.callConfirmed.run(confirmed || method.confirm !== undefined, async () => {
+      const result = await method.run(parsed, raw);
+      await this.events.emit(name, { input: parsed, result });
+      return result;
+    }));
+    const invalidates = run.outermost ? [...run.access.writes] : [];
+    if (invalidates.length > 0)
+      this.notifyInvalidated(invalidates);
+    if (!run.ok) {
+      if (!(run.error instanceof MethodError && run.error.code === "CONFIRM"))
+        record("error", [run.error]);
+      throw run.error;
+    }
+    return { result: run.value ?? null, reads: [...run.access.reads], invalidates };
+  }
+  stream(name, input, options, onItem) {
+    const method = this.methods.get(name);
+    if (!method)
+      throw new MethodError("NOT_FOUND", `There is no method ${name}.`);
+    if (method.kind !== "stream")
+      throw new MethodError("VALIDATION", `${name} is a ${method.kind}, not a stream.`);
+    const raw = input ?? {};
+    const parsed = method.input.parse(raw);
+    const root = options.root ?? this.callRoot.getStore() ?? this.root;
+    const caller = options.caller ?? this.callCaller.getStore() ?? "code";
+    const where = this.logContextFor(method.plugin, name);
+    return this.callRoot.run(root, () => this.callCaller.run(caller, () => this.callSignal.run(options.signal, () => runWith(where, async () => {
+      const run = await tracked(true, (tags) => this.notifyInvalidated(tags), async () => {
+        const items = await method.run(parsed, raw);
+        if (!isAsyncIterable(items))
+          throw new MethodError("INTERNAL", `${name} is a stream but returned no async iterable.`);
+        for await (const item of items) {
+          if (options.signal.aborted)
+            break;
+          onItem(item);
+        }
+      });
+      if (!run.ok && !options.signal.aborted) {
+        record("error", [run.error]);
+        throw run.error;
+      }
+    }))));
+  }
+  async sample(name, input) {
+    const items = [];
+    const stop = new AbortController;
+    const timer = setTimeout(() => stop.abort(), sampleMs);
+    try {
+      const stopped = new Promise((resolve) => stop.signal.addEventListener("abort", () => resolve()));
+      const ended = this.stream(name, input, { signal: stop.signal }, (item) => {
+        items.push(item);
+        if (items.length >= sampleLimit)
+          stop.abort();
+      });
+      await Promise.race([ended, stopped]);
+      return { items, done: !stop.signal.aborted };
+    } finally {
+      clearTimeout(timer);
+      stop.abort();
+    }
+  }
+  onNotify(listener) {
+    this.noticeListeners.add(listener);
+    return () => this.noticeListeners.delete(listener);
+  }
+  onInvalidate(listener) {
+    this.invalidationListeners.add(listener);
+    return () => this.invalidationListeners.delete(listener);
+  }
+  setCrons(entries) {
+    const kept = new Map(this.crons.map((job) => [job.signature, job]));
+    const jobs = [];
+    const statuses = [];
+    for (const entry of entries) {
+      const timezone = entry.timezone ?? Intl.DateTimeFormat().resolvedOptions().timeZone;
+      const signature = `${entry.plugin}.${entry.method} ${entry.schedule} ${timezone}`;
+      try {
+        const job = kept.get(signature) ?? this.cronJob(entry, timezone, signature);
+        jobs.push(job);
+        statuses.push({ ...cronState(job), plugin: job.plugin, error: null });
+      } catch (error) {
+        statuses.push({
+          plugin: entry.plugin,
+          method: `${entry.plugin}.${entry.method}`,
+          schedule: entry.schedule,
+          timezone,
+          error: error.message,
+          nextRunAt: null,
+          lastRunAt: null,
+          lastError: null,
+          lastDurationMs: null,
+          running: false,
+          runs: 0
+        });
+      }
+    }
+    this.crons.splice(0, this.crons.length, ...jobs);
+    this.notifyInvalidated([this.cronsTag]);
+    return statuses;
+  }
+  cronJob(entry, timezone, signature) {
+    if (!this.plugins.has(entry.plugin))
+      throw new Error(`${entry.plugin} isn't loaded here`);
+    const name = `${entry.plugin}.${entry.method}`;
+    const method = this.methods.get(name);
+    if (!method || method.plugin !== entry.plugin)
+      throw new Error(`${entry.method} isn't one of ${entry.plugin}'s methods`);
+    if (method.kind === "stream")
+      throw new Error(`${name} is a stream; a cron runs a query or a mutation`);
+    if (method.confirm)
+      throw new Error(`${name} asks before it runs, so nothing may run it on a schedule`);
+    if (!method.input.safeParse({}).success)
+      throw new Error(`${name} needs input; a cron calls it with {}`);
+    const parsed = parseSchedule(entry.schedule);
+    try {
+      checkTimezone(timezone);
+    } catch {
+      throw new Error(`"${timezone}" isn't a time zone`);
+    }
+    const nextRunAt = nextDue(parsed, Date.now(), timezone);
+    if (nextRunAt === null)
+      throw new Error(`"${entry.schedule}" is never due`);
+    return {
+      signature,
+      plugin: entry.plugin,
+      method: name,
+      schedule: entry.schedule,
+      timezone,
+      parsed,
+      nextRunAt,
+      lastRunAt: null,
+      lastDurationMs: null,
+      lastError: null,
+      running: false,
+      runs: 0
+    };
+  }
+  tickCrons(now = Date.now()) {
+    const started = [];
+    for (const job of this.crons) {
+      if (job.nextRunAt === null || job.nextRunAt > now)
+        continue;
+      const due = job.nextRunAt;
+      job.nextRunAt = nextDue(job.parsed, now, job.timezone);
+      if (job.running || now - due > cronLateMs)
+        continue;
+      job.running = true;
+      job.lastRunAt = now;
+      const startedAt = Date.now();
+      started.push(this.call(job.method, {}, { caller: "cron" }).then(() => {
+        job.lastError = null;
+      }, (error) => {
+        job.lastError = toCallError(error).message;
+      }).finally(() => {
+        job.running = false;
+        job.runs += 1;
+        job.lastDurationMs = Date.now() - startedAt;
+        this.notifyInvalidated([this.cronsTag]);
+      }));
+    }
+    if (started.length)
+      this.notifyInvalidated([this.cronsTag]);
+    return started;
+  }
+  logContextFor(plugin, method, chat) {
+    const outer = logContext.getStore();
+    if (outer && outer.plugin === plugin && outer.method === method)
+      return outer;
+    return {
+      plugin,
+      method: method ?? outer?.method,
+      caller: this.callCaller.getStore() ?? outer?.caller,
+      callId: outer?.callId ?? crypto.randomUUID().slice(0, 8),
+      chatId: chat ?? outer?.chatId
+    };
+  }
+  async agent(plugin, ctx, prompt, options) {
+    assertWritable("agents");
+    if (!this.host)
+      throw new MethodError("INTERNAL", "ctx.agent runs only under the RepoGo host.");
+    if (!options.agent)
+      throw new MethodError("VALIDATION", 'ctx.agent needs the agent to run: { agent: "claude" } or "codex".');
+    const started = await this.host(plugin, "chats.start", {
+      cwd: options.project ?? ctx.root,
+      agent: options.agent,
+      title: options.title ?? "",
+      turn: { prompt, config: {}, attachments: [] }
+    });
+    const deadline = Date.now() + parseDuration(options.timeout ?? agentTimeoutMs);
+    let chatId = "";
+    for (;; ) {
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) {
+        throw new MethodError("INTERNAL", `The agent didn't answer in time; its chat ${chatId || started.turn_id} is still running.`);
+      }
+      const waited = await this.host(plugin, "chats.wait", { turn_id: started.turn_id, timeout_ms: Math.min(remaining, agentWaitMs) });
+      chatId = waited.chat_id ?? chatId;
+      if (waited.state === "queued" || waited.state === "running")
+        continue;
+      if (waited.state !== "done")
+        throw new MethodError("INTERNAL", `The agent's turn ${waited.state}${waited.error ? `: ${waited.error}` : ""} (chat ${chatId}).`);
+      return { chatId, text: waited.reply ?? "" };
+    }
+  }
+  manifest() {
+    const plugins = [...this.plugins.entries()].map(([name, plugin]) => ({
+      name,
+      description: plugin.description ?? null,
+      methods: [...this.methods.values()].filter((method) => method.plugin === name).map((method) => ({
+        name: method.name,
+        kind: method.kind,
+        description: method.description ?? null,
+        confirm: method.confirm ?? null,
+        http: method.http ?? null,
+        input: z5.toJSONSchema(method.input, { io: "input", unrepresentable: "any" }),
+        output: method.output ? z5.toJSONSchema(method.output, { io: "output", unrepresentable: "any" }) : null
+      })),
+      crons: this.crons.filter((job) => job.plugin === name).map(cronState),
+      storage: {
+        buckets: this.storesOf(name, "buckets").map((store) => ({ name: store.name, path: store.path })),
+        kv: this.storesOf(name, "kv").map((store) => ({ name: store.name })),
+        streams: this.storesOf(name, "streams").map((store) => ({ name: store.name, path: store.path }))
+      }
+    }));
+    return { plugins };
+  }
+  get runningCrons() {
+    return this.crons.filter((job) => job.running).map((job) => job.method);
+  }
+  get hasStorage() {
+    return this.stores.size > 0;
+  }
+  async tickStorage(now = Date.now()) {
+    for (const { store } of this.stores.values()) {
+      await store.tick(now).catch((error) => console.error(`[${store.kind}] ${store.name}:`, toCallError(error).message));
+    }
+  }
+  close() {
+    for (const { store } of this.stores.values())
+      store.close();
+    for (const database of this.databases.values())
+      database.close();
+  }
+  async database(namespace) {
+    let database = this.databases.get(namespace);
+    if (database)
+      return database;
+    await mkdir3(join3(this.dataDir, namespace), { recursive: true });
+    database = await Database.open(join3(this.dataDir, namespace, "data.db"));
+    this.databases.set(namespace, database);
+    return database;
+  }
+  async answerCache(namespace, database) {
+    let cache = this.answerCaches.get(namespace);
+    if (cache)
+      return cache;
+    cache = new AnswerCache(database, namespace, (tags) => this.notifyInvalidated(tags));
+    await cache.setup();
+    this.answerCaches.set(namespace, cache);
+    return cache;
+  }
+  async store(plugin, kind, name, schema, make, extra) {
+    const signature = JSON.stringify([z5.toJSONSchema(schema, { unrepresentable: "any" }), extra ?? null]);
+    const made = make();
+    const found = this.stores.get(made.tag);
+    if (found && found.schema !== signature) {
+      throw new Error(`${plugin}: ${kind} ${name} is declared by another plugin in this namespace with a different schema`);
+    }
+    const store = found?.store ?? made;
+    if (!found) {
+      await store.setup();
+      this.stores.set(store.tag, { store, schema: signature });
+    }
+    store.plugins.add(plugin);
+    return store;
+  }
+  storesOf(plugin, kind) {
+    return [...this.stores.values()].map(({ store }) => store).filter((store) => store.kind === kind && store.plugins.has(plugin));
+  }
+  notifyInvalidated(tags) {
+    for (const listener of this.invalidationListeners)
+      listener(tags);
+  }
+  register(method) {
+    if (this.methods.has(method.name))
+      throw new Error(`${method.name} is defined twice; rename the method or the data`);
+    this.methods.set(method.name, method);
+  }
+  registerGenerated(plugin, name, methods) {
+    for (const [method, { run, ...spec }] of Object.entries(methods)) {
+      this.register({
+        name: `${plugin}.${name}.${method}`,
+        plugin,
+        ...spec,
+        run: async (input) => run(input, this.callSignal.getStore() ?? never)
+      });
+    }
+  }
+  registerCrud(plugin, name, collection, schema) {
+    const prefix = `${plugin}.${name}`;
+    const id = z5.object({ id: z5.string() });
+    const record2 = schema.extend({ id: z5.string(), createdAt: z5.string(), updatedAt: z5.string() });
+    const crud = (method, kind, input, output, description, run, confirm) => this.register({
+      name: `${prefix}.${method}`,
+      plugin,
+      kind,
+      description,
+      confirm,
+      input,
+      output,
+      run: async (value, raw) => run(value, raw)
+    });
+    crud("list", "query", z5.object({
+      limit: z5.number().int().positive().max(500).optional(),
+      offset: z5.number().int().min(0).optional(),
+      orderBy: z5.string().optional(),
+      order: z5.enum(["asc", "desc"]).optional()
+    }), z5.array(record2), `List ${name} records, newest first unless orderBy says`, (input) => collection.list(input));
+    crud("get", "query", id, record2.nullable(), `Get one ${name} record by id, or null`, (input) => collection.get(input.id));
+    crud("create", "mutation", schema, record2, `Create a ${name} record`, (input) => collection.create(input));
+    crud("update", "mutation", id.extend(schema.partial().shape), record2, `Update fields on a ${name} record`, ({ id: id2, ...fields }, raw) => collection.update(id2, Object.fromEntries(Object.entries(fields).filter(([key]) => Object.hasOwn(raw ?? {}, key)))));
+    crud("delete", "mutation", id, z5.null(), `Delete a ${name} record by id`, async (input) => {
+      await collection.delete(input.id);
+      return null;
+    }, "Delete this record?");
+  }
+}
+function fillConfirm(question, input) {
+  const fields = input ?? {};
+  return question.replace(/\{\{\s*([A-Za-z0-9_]+)\s*\}\}/g, (_, field2) => {
+    const value = Object.hasOwn(fields, field2) ? fields[field2] : undefined;
+    return value === undefined || value === null ? "" : String(value);
+  });
+}
+function cronState(job) {
+  return {
+    method: job.method,
+    schedule: job.schedule,
+    timezone: job.timezone,
+    nextRunAt: job.nextRunAt,
+    lastRunAt: job.lastRunAt,
+    lastError: job.lastError,
+    lastDurationMs: job.lastDurationMs,
+    running: job.running,
+    runs: job.runs
+  };
+}
+function mcpFailure(server, tool, error) {
+  switch (error.code) {
+    case "NOT_READ_ONLY":
+      return new MethodError("FORBIDDEN", `${server}.${tool} changes data, so it runs from a mutation, not a query.`);
+    case "CONFIRM":
+      return new MethodError("FORBIDDEN", `${server}.${tool} may destroy data, so it runs only from a method with a confirm.`);
+  }
+  return new MethodError("INTERNAL", error.message);
+}
+function activityParams(activity, project) {
+  const { compactLabel, timer, ...rest } = activity;
+  return {
+    ...rest,
+    compact_label: compactLabel,
+    timer: timer && {
+      kind: timer.kind,
+      started_at: timer.kind === "elapsed" ? timer.startedAt : undefined,
+      ends_at: timer.kind === "countdown" ? timer.endsAt : undefined
+    },
+    project
+  };
+}
+function isAsyncIterable(value) {
+  return typeof value?.[Symbol.asyncIterator] === "function";
+}
+
+// src/self.ts
+Bun.plugin({
+  name: "@repogo/plugins",
+  setup(build) {
+    build.module("@repogo/plugins", () => ({ exports: exports_src, loader: "object" }));
+  }
+});
+
+// src/workflow/testing.ts
+import { mkdtemp, rm as rm4 } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join7, resolve as resolve2 } from "path";
+
+// src/workflow/service.ts
+import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
+import { readdir as readdir4, rm as rm3, stat as stat3 } from "fs/promises";
+import { join as join6 } from "path";
+import { fileURLToPath } from "url";
+import { z as z7 } from "zod";
+
+// src/workflow/catalog.ts
+var {SQL: SQL3 } = globalThis.Bun;
+import { mkdir as mkdir4 } from "fs/promises";
+import { join as join4 } from "path";
+
+// src/workflow/lease.ts
+var {SQL: SQL2 } = globalThis.Bun;
+
+// src/workflow/events.ts
+import { z as z6 } from "zod";
+var ID = z6.string().min(1).max(200);
+var sleepId = (position) => `@sleep:${position}`;
+var SleepID = z6.string().regex(/^@sleep:[1-9]\d*$/);
+var StepID = ID.refine((value) => !value.startsWith("@sleep:"), "Sleep IDs are reserved for the workflow core.");
+var Attempt = z6.number().int().positive();
+var Failure = z6.object({ message: z6.string(), code: z6.string().optional() }).strict();
+var Step = { stepId: StepID, attempt: Attempt };
+var EventInputSchema = z6.discriminatedUnion("type", [
+  z6.object({ type: z6.literal("run.started"), workflow: ID, input: z6.json(), timeoutMs: DurationMsSchema, location: RunLocationSchema.optional() }).strict(),
+  z6.object({ type: z6.literal("sleep.scheduled"), sleepId: SleepID, durationMs: DurationMsSchema }).strict(),
+  z6.object({ type: z6.literal("sleep.completed"), sleepId: SleepID }).strict(),
+  z6.object({ type: z6.literal("step.started"), ...Step, policy: StepPolicySchema }).strict(),
+  z6.object({ type: z6.literal("step.completed"), ...Step, result: z6.json() }).strict(),
+  z6.object({ type: z6.literal("step.failed"), ...Step, error: Failure }).strict(),
+  z6.object({ type: z6.literal("step.unknown"), ...Step, error: Failure }).strict(),
+  z6.object({ type: z6.literal("step.retryScheduled"), ...Step, error: Failure, delayMs: z6.number().int().min(0).max(maxDurationMs) }).strict(),
+  z6.object({ type: z6.literal("run.retryRequested"), stepId: StepID }).strict(),
+  z6.object({ type: z6.literal("run.completed"), result: z6.json() }).strict(),
+  z6.object({ type: z6.literal("run.failed"), error: Failure }).strict(),
+  z6.object({ type: z6.literal("run.cancelRequested") }).strict(),
+  z6.object({ type: z6.literal("run.cancelled") }).strict(),
+  z6.object({ type: z6.literal("run.expired"), reason: z6.string().min(1) }).strict(),
+  z6.object({ type: z6.literal("run.unknown"), error: Failure }).strict(),
+  z6.object({ type: z6.literal("run.attention"), error: Failure }).strict(),
+  z6.object({ type: z6.literal("run.restarted") }).strict()
+]);
+var Envelope = z6.object({ version: z6.literal(1), seq: z6.number().int().positive(), at: z6.iso.datetime() }).strict();
+
+class JournalError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "JournalError";
+  }
+}
+function eventInput(value) {
+  const parsed = EventInputSchema.safeParse(value);
+  if (!parsed.success)
+    throw new JournalError("INVALID_EVENT", parsed.error.message);
+  return JSON.parse(JSON.stringify(parsed.data));
+}
+function storedEvent(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("Expected an event object.");
+  const { version, seq, at, ...input } = value;
+  return { ...eventInput(input), ...Envelope.parse({ version, seq, at }) };
+}
+
+// src/workflow/lease.ts
+async function acquireOwner(path) {
+  const owner = new SQL2({ adapter: "sqlite", filename: path });
+  try {
+    await owner.unsafe("pragma busy_timeout = 0");
+    await owner.unsafe("begin exclusive");
+  } catch (error) {
+    await owner.close();
+    if (error instanceof SQL2.SQLiteError && [5, 6].includes(error.errno & 255))
+      throw new JournalError("LOCKED", "Another executor owns this storage.");
+    throw error;
+  }
+  let closed = false;
+  return async () => {
+    if (closed)
+      return;
+    closed = true;
+    try {
+      await owner.unsafe("rollback");
+    } finally {
+      await owner.close();
+    }
+  };
+}
+
+// src/workflow/catalog.ts
+class WorkflowCatalog {
+  sql;
+  release;
+  constructor(sql, release) {
+    this.sql = sql;
+    this.release = release;
+  }
+  static async open(directory) {
+    await mkdir4(directory, { recursive: true, mode: 448 });
+    const release = await acquireOwner(join4(directory, "owner.db"));
+    let sql = null;
+    try {
+      sql = new SQL3({ adapter: "sqlite", filename: join4(directory, "catalog.db") });
+      await sql.unsafe("pragma journal_mode = wal");
+      await sql.unsafe("pragma synchronous = full");
+      await sql.unsafe("create table if not exists runs (id text primary key, metadata text not null, summary text not null, seen real not null, terminal real, error text)");
+      await sql.unsafe("create table if not exists availability (id integer primary key check(id = 1), seen real not null, offline_since real)");
+      return new WorkflowCatalog(sql, release);
+    } catch (error) {
+      await sql?.close();
+      await release();
+      throw error;
+    }
+  }
+  async all() {
+    const rows = await this.sql.unsafe("select metadata, summary, seen, terminal, error from runs order by id");
+    return rows.map((row) => ({ run: JSON.parse(row.metadata), summary: JSON.parse(row.summary), seen: row.seen, terminal: row.terminal, error: row.error }));
+  }
+  async put(value) {
+    await this.sql.unsafe("insert into runs (id,metadata,summary,seen,terminal,error) values (?,?,?,?,?,?) on conflict(id) do update set metadata=excluded.metadata,summary=excluded.summary,seen=excluded.seen,terminal=excluded.terminal,error=excluded.error", [
+      value.run.id,
+      JSON.stringify(value.run),
+      JSON.stringify(value.summary),
+      value.seen,
+      value.terminal,
+      value.error
+    ]);
+  }
+  async availability() {
+    const [row] = await this.sql.unsafe("select seen, offline_since from availability where id = 1");
+    return row ? { seen: row.seen, offlineSince: row.offline_since } : null;
+  }
+  async heartbeat(value) {
+    await this.sql.unsafe("insert into availability (id,seen,offline_since) values (1,?,?) on conflict(id) do update set seen=excluded.seen,offline_since=excluded.offline_since", [value.seen, value.offlineSince]);
+  }
+  async remove(id) {
+    await this.sql.unsafe("delete from runs where id = ?", [id]);
+  }
+  async close() {
+    try {
+      await this.sql.close();
+    } finally {
+      await this.release();
+    }
+  }
+}
+
+// src/workflow/availability.ts
+import { networkInterfaces } from "os";
+var networkAvailable = () => {
+  try {
+    return Object.values(networkInterfaces()).flat().some((address) => address && !address.internal && (address.family === "IPv4" ? !address.address.startsWith("169.254.") : !address.address.startsWith("fe80:")));
+  } catch {
+    return null;
+  }
+};
+function nextAvailability(saved, now, online) {
+  const offlineSince = online === true ? null : online === false ? saved?.offlineSince ?? now : saved?.offlineSince ?? null;
+  return { seen: now, offlineSince };
+}
+
+// src/workflow/clock.ts
+var systemClock = {
+  now: () => Date.now(),
+  schedule(at, callback) {
+    let timer;
+    let cancelled = false;
+    const tick = () => {
+      if (cancelled)
+        return;
+      const remaining = at - Date.now();
+      if (remaining <= 0)
+        callback();
+      else
+        timer = setTimeout(tick, Math.min(remaining, 2147483647));
+    };
+    timer = setTimeout(tick, Math.min(Math.max(0, at - Date.now()), 2147483647));
+    return () => {
+      cancelled = true;
+      if (timer !== undefined)
+        clearTimeout(timer);
+    };
+  }
+};
+function deadlineFrom(at, milliseconds) {
+  return new Date(Date.parse(at) + milliseconds).toISOString();
+}
+
+// src/workflow/interrupted.ts
+async function settleInterrupted(journal, code) {
+  for (const [stepId, step] of Object.entries(journal.state.steps)) {
+    if (step.status !== "running")
+      continue;
+    await journal.append({
+      type: step.policy.kind === "mutation" ? "step.unknown" : "step.failed",
+      stepId,
+      attempt: step.attempt,
+      error: { code, message: "The workflow stopped before this attempt's outcome was recorded." }
+    });
+  }
+}
+
+// src/workflow/state.ts
+import { isDeepStrictEqual } from "util";
+function initialState() {
+  return {
+    version: 2,
+    lastSeq: 0,
+    status: "pending",
+    workflow: null,
+    input: null,
+    currentStep: null,
+    operationOrder: [],
+    steps: {},
+    sleeps: {},
+    result: null,
+    error: null,
+    expiryReason: null,
+    deadlineAt: null,
+    timeoutMs: null,
+    cancelRequested: false,
+    updatedAt: null,
+    endedAt: null,
+    metadata: null
+  };
+}
+function applyEvent(state, event) {
+  if (event.seq !== state.lastSeq + 1)
+    refuse("Event sequence is not contiguous.");
+  const next = { ...state, lastSeq: event.seq, updatedAt: event.at };
+  if (event.type === "run.started") {
+    if (state.status !== "pending")
+      refuse("The run already started.");
+    return { ...next, metadata: event.location ? { ...event.location, workflow: event.workflow, input: event.input, timeoutMs: event.timeoutMs, createdAt: event.at } : null, status: "running", workflow: event.workflow, input: event.input, timeoutMs: event.timeoutMs, deadlineAt: deadlineFrom(event.at, event.timeoutMs) };
+  }
+  if (event.type === "run.retryRequested") {
+    const step2 = Object.hasOwn(state.steps, event.stepId) ? state.steps[event.stepId] : null;
+    if (state.status !== "failed" || state.cancelRequested || !step2 || step2.status !== "failed" || step2.policy.kind !== "query" || !["STEP", "TIMEOUT", "INTERRUPTED"].includes(step2.error?.code ?? "") || Object.values(state.sleeps).some((sleep) => sleep.status !== "completed") || Object.entries(state.steps).some(([id, value]) => id !== event.stepId && value.status !== "completed"))
+      refuse("Only a safely failed query step can be retried.");
+    if (state.deadlineAt && Date.parse(event.at) >= Date.parse(state.deadlineAt))
+      refuse("The workflow lifetime has ended.");
+    const limit2 = step2.attempt + step2.policy.attempts;
+    if (limit2 > 1e4)
+      refuse("The run's attempt limit is exhausted.");
+    return { ...next, endedAt: null, status: "waiting", error: null, currentStep: event.stepId, steps: {
+      ...state.steps,
+      [event.stepId]: { ...step2, status: "waiting", limit: limit2, nextAttemptAt: event.at }
+    } };
+  }
+  if (event.type === "run.restarted") {
+    if (state.status !== "attention")
+      refuse("Only a run that needs attention can restart.");
+    const deadlineAt = state.timeoutMs === null ? state.deadlineAt : deadlineFrom(event.at, state.timeoutMs);
+    return { ...next, status: "running", error: null, currentStep: null, operationOrder: [], steps: {}, sleeps: {}, deadlineAt };
+  }
+  if (state.status === "attention") {
+    if (event.type === "run.cancelRequested")
+      return { ...next, cancelRequested: true };
+    if (event.type === "run.cancelled")
+      return { ...next, endedAt: event.at, status: "cancelled" };
+    if (event.type === "run.expired")
+      return { ...next, endedAt: event.at, status: "expired", expiryReason: event.reason };
+    refuse("The run needs attention: restart or cancel it.");
+  }
+  if (state.status !== "running" && state.status !== "waiting")
+    refuse("The run is not active.");
+  if (event.type === "run.attention") {
+    if (Object.values(state.steps).some((step2) => step2.status === "running"))
+      refuse("A step is running.");
+    return { ...next, status: "attention", error: event.error };
+  }
+  if (event.type === "run.cancelRequested")
+    return { ...next, cancelRequested: true };
+  if (event.type === "run.completed") {
+    if (state.cancelRequested)
+      refuse("Cancellation prevents run completion.");
+    if (Object.values(state.sleeps).some((sleep) => sleep.status !== "completed") || Object.values(state.steps).some((step2) => step2.status !== "completed"))
+      refuse("An unfinished or failed step prevents run completion.");
+    return { ...next, endedAt: event.at, status: "completed", result: event.result };
+  }
+  if (event.type === "run.failed" || event.type === "run.unknown") {
+    return { ...next, endedAt: event.at, status: event.type === "run.failed" ? "failed" : "unknown", error: event.error };
+  }
+  if (event.type === "run.cancelled")
+    return { ...next, endedAt: event.at, status: "cancelled" };
+  if (event.type === "run.expired")
+    return { ...next, endedAt: event.at, status: "expired", expiryReason: event.reason };
+  if (event.type === "sleep.scheduled") {
+    if (state.cancelRequested)
+      refuse("Cancellation prevents starting sleeps.");
+    if (event.sleepId !== sleepId(state.operationOrder.length + 1) || Object.hasOwn(state.sleeps, event.sleepId))
+      refuse("Sleep identity must match its operation position.");
+    if (Object.values(state.steps).some((step2) => step2.status !== "completed") || Object.values(state.sleeps).some((sleep2) => sleep2.status !== "completed"))
+      refuse("Another operation is unfinished.");
+    const sleep = { status: "waiting", durationMs: event.durationMs, wakeAt: deadlineFrom(event.at, event.durationMs) };
+    return { ...next, status: "waiting", currentStep: event.sleepId, operationOrder: [...state.operationOrder, event.sleepId], sleeps: { ...state.sleeps, [event.sleepId]: sleep } };
+  }
+  if (event.type === "sleep.completed") {
+    const sleep = Object.hasOwn(state.sleeps, event.sleepId) ? state.sleeps[event.sleepId] : null;
+    if (!sleep || sleep.status !== "waiting")
+      refuse("Only a waiting sleep can complete.");
+    if (state.cancelRequested)
+      refuse("Cancellation prevents completing sleeps.");
+    if (Date.parse(event.at) < Date.parse(sleep.wakeAt))
+      throw new JournalError("NOT_DUE", "The sleep is not due.");
+    return { ...next, status: "running", currentStep: event.sleepId, sleeps: { ...state.sleeps, [event.sleepId]: { ...sleep, status: "completed" } } };
+  }
+  const previous = Object.hasOwn(state.steps, event.stepId) ? state.steps[event.stepId] : undefined;
+  let step;
+  if (event.type === "step.started") {
+    if (state.cancelRequested)
+      refuse("Cancellation prevents starting steps.");
+    if (Object.values(state.sleeps).some((sleep) => sleep.status !== "completed"))
+      refuse("A sleep is unfinished.");
+    if (Object.values(state.steps).some((step2) => step2.status === "failed"))
+      refuse("A failed step prevents starting steps.");
+    if (previous) {
+      if (!isDeepStrictEqual(previous.policy, event.policy))
+        refuse("Retry policy differs from its recorded policy.");
+      if (previous.status !== "waiting" || event.attempt !== previous.attempt + 1)
+        refuse("Only a scheduled retry can start the next attempt.");
+      if (Date.parse(event.at) < Date.parse(previous.nextAttemptAt))
+        throw new JournalError("NOT_DUE", "The retry is not due.");
+    } else if (event.attempt !== 1) {
+      refuse("A new step starts at attempt one.");
+    }
+    if (event.attempt > (previous?.limit ?? event.policy.attempts))
+      refuse("The attempt budget is exhausted.");
+    if (Object.entries(state.steps).some(([id, value]) => id !== event.stepId && active(value)))
+      refuse("Another step is unfinished.");
+    step = { status: "running", attempt: event.attempt, limit: previous?.limit ?? event.policy.attempts, result: null, error: null, nextAttemptAt: null, policy: event.policy };
+  } else {
+    if (!previous || previous.status !== "running" || previous.attempt !== event.attempt)
+      refuse("The event does not match a running attempt.");
+    if (event.type === "step.completed") {
+      step = { ...previous, status: "completed", result: event.result, error: null, nextAttemptAt: null };
+    } else if (event.type === "step.failed" || event.type === "step.unknown") {
+      step = { ...previous, status: event.type === "step.failed" ? "failed" : "unknown", error: event.error };
+    } else {
+      if (previous.policy.kind !== "query" || previous.attempt >= previous.limit)
+        refuse("The step cannot retry.");
+      if (state.cancelRequested)
+        refuse("Cancellation prevents retries.");
+      const nextAttemptAt = deadlineFrom(event.at, event.delayMs);
+      step = { ...previous, status: "waiting", error: event.error, nextAttemptAt };
+    }
+  }
+  return {
+    ...next,
+    status: step.status === "waiting" ? "waiting" : "running",
+    currentStep: event.stepId,
+    operationOrder: previous ? state.operationOrder : [...state.operationOrder, event.stepId],
+    steps: { ...state.steps, [event.stepId]: step }
+  };
+}
+function active(step) {
+  return step.status === "running" || step.status === "waiting" || step.status === "unknown";
+}
+function refuse(message) {
+  throw new JournalError("INVALID_EVENT", message);
+}
+
+// src/workflow/storage.ts
+import { constants } from "fs";
+import { mkdir as mkdir5, open, rename as rename2 } from "fs/promises";
+import { dirname, join as join5, resolve } from "path";
+var maxRecordBytes = 1024 * 1024;
+var maxJournalBytes = 64 * 1024 * 1024;
+
+class FileJournalStorage {
+  directory;
+  events;
+  release;
+  constructor(directory, events, release) {
+    this.directory = directory;
+    this.events = events;
+    this.release = release;
+  }
+  static async open(directory, create = true) {
+    directory = resolve(directory);
+    const created = create ? await mkdir5(directory, { recursive: true, mode: 448 }) : undefined;
+    const ancestor = created ? dirname(resolve(created)) : dirname(directory);
+    for (let parent = dirname(directory);; parent = dirname(parent)) {
+      await syncDirectory(parent);
+      if (parent === ancestor)
+        break;
+    }
+    const release = await acquireOwner(join5(directory, "owner.db"));
+    let events;
+    try {
+      events = await open(join5(directory, "events.jsonl"), constants.O_RDWR | constants.O_APPEND | (create ? constants.O_CREAT : 0), 384);
+      await events.sync();
+      await syncDirectory(directory);
+      return new FileJournalStorage(directory, events, release);
+    } catch (error) {
+      try {
+        await events?.close();
+      } finally {
+        await release();
+      }
+      throw error;
+    }
+  }
+  async readEvents() {
+    if ((await this.events.stat()).size > maxJournalBytes)
+      throw new JournalError("LIMIT", "The run journal exceeds its size limit.");
+    return this.events.readFile();
+  }
+  async append(record2) {
+    await this.events.writeFile(record2);
+    await this.events.sync();
+  }
+  async truncateEvents(bytes) {
+    await this.events.truncate(bytes);
+    await this.events.sync();
+  }
+  async replaceSnapshot(snapshot) {
+    const temporary = join5(this.directory, "state.json.tmp");
+    const file = await open(temporary, "w", 384);
+    try {
+      await file.writeFile(snapshot);
+      await file.sync();
+    } finally {
+      await file.close();
+    }
+    await rename2(temporary, join5(this.directory, "state.json"));
+    await syncDirectory(this.directory);
+  }
+  async close() {
+    try {
+      await this.events.close();
+    } finally {
+      await this.release();
+    }
+  }
+}
+async function syncDirectory(path) {
+  const directory = await open(path, "r");
+  try {
+    await directory.sync();
+  } finally {
+    await directory.close();
+  }
+}
+
+// src/workflow/journal.ts
+class RunJournal {
+  storage;
+  clock;
+  value = initialState();
+  listeners = new Set;
+  bytes = 0;
+  queue = Promise.resolve();
+  closing = null;
+  poisoned = false;
+  snapshotFailure = null;
+  constructor(storage, clock) {
+    this.storage = storage;
+    this.clock = clock;
+  }
+  static async open(directory, clock = systemClock) {
+    return RunJournal.recover(await FileJournalStorage.open(directory), clock);
+  }
+  static async openExisting(directory, clock = systemClock) {
+    return RunJournal.recover(await FileJournalStorage.open(directory, false), clock);
+  }
+  static async recover(storage, clock) {
+    const journal = new RunJournal(storage, clock);
+    try {
+      const bytes = Buffer.from(await storage.readEvents());
+      if (bytes.length > maxJournalBytes)
+        throw new JournalError("LIMIT", "The run journal exceeds its size limit.");
+      const complete = bytes.lastIndexOf(10) + 1;
+      let offset = 0;
+      while (offset < complete) {
+        const end = bytes.indexOf(10, offset);
+        if (end - offset + 1 > maxRecordBytes)
+          throw new JournalError("CORRUPT_JOURNAL", "A committed record exceeds its size limit.");
+        try {
+          const line = new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(offset, end));
+          journal.value = applyEvent(journal.value, storedEvent(JSON.parse(line)));
+        } catch (error) {
+          throw new JournalError("CORRUPT_JOURNAL", `Invalid committed event at byte ${offset}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        offset = end + 1;
+      }
+      if (complete !== bytes.length)
+        await storage.truncateEvents(complete);
+      journal.bytes = complete;
+      await journal.checkpoint();
+      return journal;
+    } catch (error) {
+      await storage.close();
+      throw error;
+    }
+  }
+  onChange(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  get state() {
+    return structuredClone(this.value);
+  }
+  get snapshotError() {
+    return this.snapshotFailure;
+  }
+  append(input) {
+    if (this.closing)
+      return Promise.reject(new JournalError("CLOSED", "The journal is closing or closed."));
+    let captured;
+    try {
+      captured = structuredClone(eventInput(input));
+    } catch (error) {
+      return Promise.reject(error);
+    }
+    const writing = this.queue.then(async () => {
+      if (this.poisoned)
+        throw new JournalError("POISONED", "A journal write failed. Close and recover before continuing.");
+      const event = { ...captured, version: 1, seq: this.value.lastSeq + 1, at: new Date(this.clock.now()).toISOString() };
+      const next = applyEvent(this.value, event);
+      const record2 = Buffer.from(JSON.stringify(event) + `
+`);
+      const reserve = event.type === "step.started" || event.type === "sleep.scheduled" ? 3 * maxRecordBytes : 0;
+      if (record2.length > maxRecordBytes || this.bytes + record2.length + reserve > maxJournalBytes) {
+        throw new JournalError("LIMIT", "The event or run journal exceeds its size limit.");
+      }
+      try {
+        await this.storage.append(record2);
+      } catch (error) {
+        this.poisoned = true;
+        throw error;
+      }
+      this.value = next;
+      this.bytes += record2.length;
+      await this.checkpoint();
+      for (const listener of this.listeners) {
+        try {
+          listener();
+        } catch (error) {
+          console.error("Workflow observer failed:", error);
+        }
+      }
+      return structuredClone(event);
+    });
+    this.queue = writing.catch(() => {});
+    return writing;
+  }
+  close() {
+    this.closing ??= this.queue.then(async () => {
+      try {
+        if (!this.poisoned && this.snapshotFailure) {
+          await this.checkpoint();
+          if (this.snapshotFailure)
+            throw this.snapshotFailure;
+        }
+      } finally {
+        await this.storage.close();
+      }
+    });
+    return this.closing;
+  }
+  async checkpoint() {
+    try {
+      await this.storage.replaceSnapshot(JSON.stringify(this.value) + `
+`);
+      this.snapshotFailure = null;
+    } catch (error) {
+      this.snapshotFailure = error;
+    }
+  }
+}
+
+// src/workflow/summary.ts
+function summarize(run, state) {
+  const step = state.currentStep && Object.hasOwn(state.steps, state.currentStep) ? state.steps[state.currentStep] : null;
+  const sleep = state.currentStep && Object.hasOwn(state.sleeps, state.currentStep) ? state.sleeps[state.currentStep] : null;
+  return {
+    id: run.id,
+    workflow: run.workflow,
+    status: state.status,
+    currentStep: state.currentStep,
+    attempt: step?.attempt ?? 0,
+    createdAt: run.createdAt,
+    updatedAt: state.updatedAt ?? run.createdAt,
+    nextAttemptAt: !activeStatuses.has(state.status) ? null : sleep?.status === "waiting" ? sleep.wakeAt : step?.nextAttemptAt ?? null,
+    deadlineAt: state.deadlineAt
+  };
+}
+var terminalStatuses = new Set(["completed", "failed", "cancelled", "expired", "unknown"]);
+var activeStatuses = new Set(["pending", "running", "waiting"]);
+var openStatuses = new Set([...activeStatuses, "attention"]);
+function describe(state) {
+  const bounded = (value) => JSON.stringify(value).length <= 16 * 1024 ? value : null;
+  const result = bounded(state.result);
+  return {
+    error: briefError(state.error),
+    input: bounded(state.input),
+    result,
+    resultTruncated: result === null && state.result !== null,
+    inputTruncated: bounded(state.input) === null && state.input !== null,
+    expiryReason: state.expiryReason,
+    cancelRequested: state.cancelRequested,
+    steps: state.operationOrder.slice(-20).map((id) => {
+      const sleep = Object.hasOwn(state.sleeps, id) ? state.sleeps[id] : null;
+      if (sleep)
+        return { id, kind: "sleep", status: sleep.status, attempt: 0, attempts: 0, error: null, nextAttemptAt: activeStatuses.has(state.status) && sleep.status === "waiting" ? sleep.wakeAt : null, durationMs: sleep.durationMs };
+      const step = state.steps[id];
+      return { id, kind: "step", durationMs: null, status: step.status, attempt: step.attempt, attempts: step.limit, error: briefError(step.error), nextAttemptAt: activeStatuses.has(state.status) ? step.nextAttemptAt : null };
+    })
+  };
+}
+function briefError(error) {
+  return error ? { ...error, message: error.message.slice(0, 4000) } : null;
+}
+function unavailableDetail(input, error) {
+  return describe({ ...initialState(), input, error: error ? { message: error } : null });
+}
+
+// src/workflow/service.ts
+var scopeMatches = (run, request) => run.dir === request.dir && run.plugin === request.plugin && run.namespace === request.namespace && run.workflow === request.workflow && run.root === request.root;
+var runReserve = 130 * 1024 * 1024;
+var storageFull = "The workflow storage budget is fully reserved by unfinished runs and retained history. Finish or cancel runs, or wait for retention cleanup.";
+var executor = fileURLToPath(new URL(import.meta.url.endsWith(".ts") ? "./executor.ts" : "./workflow-executor.js", import.meta.url));
+
+class WorkflowService {
+  dataDir;
+  catalog;
+  callbacks;
+  clock;
+  storageLimit;
+  network;
+  queue = Promise.resolve();
+  details = new Map;
+  rows = new Map;
+  unrecovered = new Set;
+  maintenanceErrors = new Map;
+  cancelling = new Set;
+  active = new Map;
+  observers = new Set;
+  timer = null;
+  closing = false;
+  started = false;
+  constructor(dataDir, catalog, callbacks, clock, storageLimit, network) {
+    this.dataDir = dataDir;
+    this.catalog = catalog;
+    this.callbacks = callbacks;
+    this.clock = clock;
+    this.storageLimit = storageLimit;
+    this.network = network;
+  }
+  static async open(dataDir, callbacks, options = {}) {
+    const service = new WorkflowService(dataDir, await WorkflowCatalog.open(join6(dataDir, ".workflows")), callbacks, options.clock ?? systemClock, options.storageLimit ?? 512 * 1024 * 1024, options.network ?? networkAvailable);
+    try {
+      for (const row of await service.catalog.all()) {
+        row.run = RunMetadataSchema.parse(row.run);
+        service.rows.set(row.run.id, row);
+      }
+      await service.recoverCatalog();
+      return service;
+    } catch (error) {
+      await service.catalog.close();
+      throw error;
+    }
+  }
+  directory(run) {
+    return join6(this.dataDir, run.namespace, "workflows", run.id);
+  }
+  serial(work) {
+    const result = this.queue.then(work);
+    this.queue = result.catch(() => {});
+    return result;
+  }
+  observe(listener) {
+    this.observers.add(listener);
+    return () => {
+      this.observers.delete(listener);
+    };
+  }
+  start() {
+    if (!this.closing) {
+      this.started = true;
+      this.wake();
+    }
+  }
+  wake() {
+    this.timer?.();
+    this.timer = null;
+    if (!this.started || this.closing)
+      return;
+    let due = this.clock.now() + (this.rows.size ? 5000 : 60000);
+    for (const row of this.rows.values()) {
+      if (!activeStatuses.has(row.summary.status) && row.summary.status !== "blocked")
+        continue;
+      due = Math.min(due, this.clock.now() + row.run.maxOfflineMs / 2);
+      if (this.active.has(row.run.id) || this.active.size >= 4)
+        continue;
+      due = Math.min(due, row.summary.nextAttemptAt ? Date.parse(row.summary.nextAttemptAt) : this.clock.now());
+      if (row.summary.status !== "blocked" && row.summary.deadlineAt)
+        due = Math.min(due, Date.parse(row.summary.deadlineAt));
+    }
+    this.timer = this.clock.schedule(due, () => {
+      this.tick().finally(() => this.wake()).catch(() => {});
+    });
+  }
+  async save(row) {
+    this.rows.set(row.run.id, row);
+    await this.catalog.put(row);
+    this.callbacks.invalidate([workflowTag(row.run.namespace)]);
+    for (const observer of this.observers) {
+      try {
+        observer(row.summary);
+      } catch (error) {
+        console.error(error);
+      }
+    }
+  }
+  async request(request) {
+    if (this.closing)
+      throw new MethodError("INTERNAL", "The workflow service is closing.");
+    if (request.operation === "list") {
+      const rows = [...this.rows.values()].filter((row2) => scopeMatches(row2.run, request) && (!request.input.status || row2.summary.status === request.input.status)).sort((a, b) => b.run.createdAt.localeCompare(a.run.createdAt) || b.run.id.localeCompare(a.run.id));
+      const cursor = request.input.cursor;
+      const start = cursor ? rows.findIndex((row2) => row2.run.id === cursor) + 1 : 0;
+      if (cursor && start === 0)
+        throw new MethodError("VALIDATION", "Invalid workflow cursor.");
+      const count = Math.min(100, Math.max(1, Number(request.input.limit ?? 20)));
+      const page = rows.slice(start, start + count);
+      return { items: page.map((row2) => row2.summary), cursor: start + count < rows.length ? page.at(-1).run.id : null };
+    }
+    if (request.operation === "start")
+      return this.serial(() => this.create(request));
+    if (request.operation === "cancelAll")
+      return this.cancelAll(request);
+    const row = this.rows.get(String(request.input.id));
+    if (!row || !scopeMatches(row.run, request))
+      throw new MethodError("NOT_FOUND", "No workflow run in this project.");
+    if (request.operation === "retry")
+      return this.serial(async () => {
+        if (await this.bytes(row.run.id) > this.storageLimit)
+          throw new MethodError("VALIDATION", storageFull);
+        const active2 = this.active.get(row.run.id);
+        if (active2) {
+          await active2.ended;
+          this.active.delete(row.run.id);
+        }
+        const journal = await this.openJournal(row.run);
+        try {
+          const stepId = journal.state.currentStep;
+          if (!stepId)
+            throw new MethodError("VALIDATION", "This run has no failed query to retry.");
+          try {
+            await journal.append({ type: "run.retryRequested", stepId });
+          } catch (error) {
+            throw new MethodError("VALIDATION", toCallError(error).message);
+          }
+          row.summary = summarize(row.run, journal.state);
+          row.terminal = null;
+          row.error = null;
+          row.seen = this.clock.now();
+          await this.save(row);
+          this.wake();
+          return row.summary;
+        } finally {
+          await journal.close();
+        }
+      });
+    if (request.operation === "restart")
+      return this.serial(async () => {
+        const journal = await this.openJournal(row.run);
+        try {
+          if (journal.state.status !== "attention")
+            throw new MethodError("VALIDATION", "Only a run that needs attention can restart.");
+          await journal.append({ type: "run.restarted" });
+          row.summary = summarize(row.run, journal.state);
+          row.error = null;
+          row.seen = this.clock.now();
+          await this.save(row);
+          this.wake();
+          return row.summary;
+        } finally {
+          await journal.close();
+        }
+      });
+    if (request.operation === "cancel")
+      return this.cancel(row);
+    return this.serial(async () => {
+      const fallback = unavailableDetail(row.run.input, row.error);
+      if (this.active.has(row.run.id))
+        return { ...row.summary, ...this.details.get(row.run.id) ?? fallback };
+      let journal;
+      try {
+        journal = await this.openJournal(row.run);
+      } catch (error) {
+        if (row.summary.status === "blocked" || row.error)
+          return { ...row.summary, ...fallback };
+        throw error;
+      }
+      try {
+        const state = journal.state;
+        const summary = row.summary.status === "blocked" ? row.summary : summarize(row.run, state);
+        return { ...summary, ...describe(state), error: briefError(state.error ?? (row.error ? { message: row.error } : null)) };
+      } finally {
+        await journal.close();
+      }
+    });
+  }
+  async cancelAll(request) {
+    const status = request.input.status;
+    const rows = [...this.rows.values()].filter((row) => scopeMatches(row.run, request) && (openStatuses.has(row.summary.status) || row.summary.status === "blocked") && (!status || row.summary.status === status));
+    for (const row of rows)
+      await this.cancel(row);
+    return { cancelled: rows.length };
+  }
+  cancel(row) {
+    const active2 = this.active.get(row.run.id);
+    if (active2 && active2.worker.exitCode === null)
+      return this.cancelActive(row, active2);
+    return this.serial(async () => {
+      if (active2) {
+        await active2.ended;
+        this.active.delete(row.run.id);
+      }
+      return this.cancelIdle(row);
+    });
+  }
+  async cancelIdle(row) {
+    const journal = await this.openJournal(row.run);
+    try {
+      if (openStatuses.has(journal.state.status)) {
+        await journal.append({ type: "run.cancelRequested" });
+        await settleInterrupted(journal, "CANCELLED");
+        await journal.append({ type: "run.cancelled" });
+      }
+      row.summary = summarize(row.run, journal.state);
+      if (terminalStatuses.has(row.summary.status))
+        row.terminal ??= Date.parse(row.summary.updatedAt);
+      await this.save(row);
+      return row.summary;
+    } finally {
+      await journal.close();
+    }
+  }
+  async cancelActive(row, active2) {
+    this.cancelling.add(row.run.id);
+    const ack = Promise.withResolvers();
+    active2.acknowledge = ack.resolve;
+    let timer;
+    try {
+      active2.worker.send({ type: "cancel" });
+      const accepted = await Promise.race([ack.promise, active2.worker.exited.then(() => null), new Promise((resolve2) => {
+        timer = setTimeout(() => {
+          active2.worker.kill("SIGKILL");
+          resolve2(null);
+        }, 1000);
+      })]);
+      if (accepted)
+        return accepted;
+      await active2.worker.exited;
+      return await this.serial(async () => {
+        this.active.delete(row.run.id);
+        return this.cancelIdle(row);
+      });
+    } finally {
+      if (timer)
+        clearTimeout(timer);
+      delete active2.acknowledge;
+      this.cancelling.delete(row.run.id);
+      this.wake();
+    }
+  }
+  async create(request) {
+    const input = z7.json().parse(request.input.input);
+    const key = request.input.key ? String(request.input.key) : null;
+    const found = key ? [...this.rows.values()].find((row2) => scopeMatches(row2.run, request) && row2.run.key === key) : undefined;
+    if (found) {
+      if (!isDeepStrictEqual2(found.run.input, input))
+        throw new MethodError("VALIDATION", "This workflow key already has different input.");
+      return found.summary;
+    }
+    if (!request.settings)
+      throw new MethodError("VALIDATION", "Workflow settings are required.");
+    if (await this.bytes() + runReserve > this.storageLimit)
+      throw new MethodError("VALIDATION", storageFull);
+    let run = RunMetadataSchema.parse({ dir: request.dir, root: request.root, namespace: request.namespace, plugin: request.plugin, workflow: request.workflow, caller: request.caller ?? "code", input, key, id: crypto.randomUUID(), createdAt: new Date(this.clock.now()).toISOString(), ...request.settings });
+    const journal = await RunJournal.open(this.directory(run), this.clock);
+    let summary;
+    try {
+      const { workflow, input: savedInput, timeoutMs, createdAt, ...location } = run;
+      await journal.append({ type: "run.started", workflow, input: savedInput, timeoutMs, location });
+      run = journal.state.metadata;
+      summary = summarize(run, journal.state);
+    } finally {
+      await journal.close();
+    }
+    const row = { run, summary, seen: this.clock.now(), terminal: null, error: null };
+    await this.save(row);
+    if (!await this.catalog.availability())
+      await this.catalog.heartbeat(nextAvailability(null, this.clock.now(), this.network()));
+    this.wake();
+    return summary;
+  }
+  tick() {
+    return this.serial(async () => {
+      if (this.closing)
+        return;
+      const now = this.clock.now();
+      if (!this.rows.size) {
+        await this.recoverCatalog();
+        return;
+      }
+      const availability = await this.catalog.availability();
+      const next = nextAvailability(availability, now, this.network());
+      const offlineSince = availability?.offlineSince ?? next.offlineSince;
+      for (const row of [...this.rows.values()]) {
+        try {
+          const networkExpired = offlineSince !== null && now - Math.max(offlineSince, Date.parse(row.run.createdAt)) >= row.run.maxOfflineMs;
+          const unavailable = availability !== null && now - Math.max(availability.seen, Date.parse(row.run.createdAt)) >= row.run.maxOfflineMs;
+          const deadlineReached = row.summary.deadlineAt !== null && now >= Date.parse(row.summary.deadlineAt);
+          if (this.active.has(row.run.id)) {
+            if (!networkExpired && !unavailable && !deadlineReached) {
+              row.seen = now;
+              continue;
+            }
+            const active2 = this.active.get(row.run.id);
+            active2.worker.kill("SIGKILL");
+            await active2.worker.exited;
+            this.active.delete(row.run.id);
+          }
+          if (row.terminal !== null && now - row.terminal < row.run.retentionMs)
+            continue;
+          if (availability && !networkExpired && !unavailable && !deadlineReached && row.summary.nextAttemptAt && Date.parse(row.summary.nextAttemptAt) > now) {
+            row.seen = now;
+            continue;
+          }
+          const blockedUntil = row.summary.status === "blocked" ? row.summary.nextAttemptAt : null;
+          try {
+            const journal = await this.openJournal(row.run);
+            try {
+              const state = journal.state;
+              const offline = networkExpired || unavailable || !availability && now - row.seen >= row.run.maxOfflineMs;
+              const expired = state.deadlineAt !== null && now >= Date.parse(state.deadlineAt);
+              if (openStatuses.has(state.status) && (offline || expired)) {
+                await settleInterrupted(journal, "EXPIRED");
+                await journal.append({ type: "run.expired", reason: offline ? "Environment unavailable beyond the workflow offline limit." : "Workflow deadline reached." });
+              }
+              row.summary = summarize(row.run, journal.state);
+              if (activeStatuses.has(row.summary.status) && blockedUntil && Date.parse(blockedUntil) > now)
+                row.summary = { ...row.summary, status: "blocked", nextAttemptAt: blockedUntil };
+              row.seen = now;
+              if (journal.state.endedAt)
+                row.terminal ??= Date.parse(journal.state.endedAt);
+              await this.save(row);
+            } finally {
+              await journal.close();
+            }
+          } catch (error) {
+            row.error = toCallError(error).message;
+            if (!terminalStatuses.has(row.summary.status)) {
+              const expired = now - row.seen >= row.run.maxOfflineMs || row.summary.deadlineAt !== null && now >= Date.parse(row.summary.deadlineAt);
+              row.summary = { ...row.summary, status: expired ? "expired" : "blocked", nextAttemptAt: expired ? null : new Date(now + 60000).toISOString() };
+              if (expired)
+                row.terminal ??= now;
+            }
+            await this.save(row);
+          }
+          if (row.terminal !== null && now - row.terminal >= row.run.retentionMs) {
+            await rm3(this.directory(row.run), { recursive: true, force: true });
+            await this.catalog.remove(row.run.id);
+            this.rows.delete(row.run.id);
+            this.details.delete(row.run.id);
+            this.maintenanceErrors.delete(row.run.id);
+            this.callbacks.invalidate([workflowTag(row.run.namespace)]);
+            continue;
+          }
+          if (!this.cancelling.has(row.run.id) && activeStatuses.has(row.summary.status) && this.active.size < 4 && (!row.summary.nextAttemptAt || now >= Date.parse(row.summary.nextAttemptAt)))
+            await this.launch(row);
+          this.maintenanceErrors.delete(row.run.id);
+        } catch (error) {
+          row.error = toCallError(error).message;
+          if (this.maintenanceErrors.get(row.run.id) !== row.error)
+            console.error("Workflow maintenance failed:", row.run.id, row.error);
+          this.maintenanceErrors.set(row.run.id, row.error);
+        }
+      }
+      await this.catalog.heartbeat(next);
+      await this.recoverCatalog();
+    });
+  }
+  async launch(row) {
+    try {
+      const worker = Bun.spawn([process.execPath, "--no-env-file", executor], {
+        cwd: row.run.dir,
+        stdin: "ignore",
+        stdout: "ignore",
+        stderr: "pipe",
+        ipc: (message) => onMessage(message),
+        serialization: "advanced"
+      });
+      const stderr = stderrTail(worker.stderr);
+      let finish;
+      const ended = new Promise((resolve2) => {
+        finish = resolve2;
+      });
+      const active2 = { worker, ended, finish, error: null };
+      this.active.set(row.run.id, active2);
+      let finished = false;
+      const complete = () => {
+        if (finished)
+          return;
+        finished = true;
+        active2.finish();
+        if (this.closing)
+          return;
+        this.serial(async () => {
+          if (this.active.get(row.run.id) !== active2)
+            return;
+          this.active.delete(row.run.id);
+          row.error = active2.error;
+          if (active2.error && !terminalStatuses.has(row.summary.status)) {
+            row.summary = { ...row.summary, status: "blocked", nextAttemptAt: new Date(this.clock.now() + 60000).toISOString() };
+            await this.save(row);
+          }
+        }).then(() => this.tick()).then(() => this.wake()).catch(() => {});
+      };
+      const onMessage = (message) => {
+        if (this.closing)
+          return;
+        if (message.type === "host") {
+          this.callbacks.host(message.plugin, message.method, message.params).then((result) => worker.send({ type: "hosted", id: message.id, result }), (error) => worker.send({ type: "hosted", id: message.id, error: toCallError(error) })).catch(() => {});
+        } else if (message.type === "state") {
+          const summary = RunSummarySchema.safeParse(message.summary);
+          if (!summary.success || summary.data.id !== row.run.id || summary.data.workflow !== row.run.workflow || summary.data.createdAt !== row.run.createdAt) {
+            active2.error = "The workflow executor reported an invalid run identity.";
+            return;
+          }
+          if (message.detail.cancelRequested)
+            active2.acknowledge?.(message.summary);
+          this.serial(async () => {
+            if (this.active.get(row.run.id) !== active2)
+              return;
+            row.summary = message.summary;
+            this.details.set(row.run.id, message.detail);
+            row.seen = this.clock.now();
+            await this.save(row);
+          });
+        } else if (message.type === "invalidated")
+          this.callbacks.invalidate(message.tags);
+        else if (message.type === "notice")
+          this.callbacks.notify(message.notice);
+        else if (message.type === "log")
+          this.callbacks.logs(row.run.dir, message.records);
+        else if (message.type === "error")
+          active2.error = message.message;
+        else if (message.type === "done") {}
+      };
+      worker.exited.then(async (code) => {
+        if (code !== 0 && !active2.error)
+          active2.error = (await stderr).slice(-4000) || `Workflow executor exited ${code}.`;
+        complete();
+      });
+      worker.send({ type: "start", run: row.run, directory: this.directory(row.run), dataDir: this.dataDir });
+    } catch (error) {
+      row.summary = { ...row.summary, status: "blocked", nextAttemptAt: new Date(this.clock.now() + 60000).toISOString() };
+      row.error = toCallError(error).message;
+      await this.save(row);
+    }
+  }
+  async openJournal(run) {
+    const path = this.directory(run);
+    if (!(await stat3(join6(path, "events.jsonl"))).size)
+      throw new Error("The workflow journal is missing or empty; execution is blocked.");
+    return RunJournal.openExisting(path, this.clock);
+  }
+  async recoverCatalog() {
+    let complete = true;
+    const namespaces = await readdir4(this.dataDir, { withFileTypes: true });
+    for (const namespace of namespaces) {
+      if (!namespace.isDirectory() || !/^[a-z0-9][a-z0-9.-]*$/.test(namespace.name))
+        continue;
+      const base = join6(this.dataDir, namespace.name, "workflows");
+      const entries = await readdir4(base, { withFileTypes: true }).catch((error) => {
+        if (error.code !== "ENOENT") {
+          complete = false;
+          if (!this.unrecovered.has(base))
+            console.error("Workflow discovery blocked:", base, toCallError(error).message);
+          this.unrecovered.add(base);
+        }
+        return [];
+      });
+      for (const entry of entries) {
+        if (!entry.isDirectory() || !z7.string().uuid().safeParse(entry.name).success || this.rows.has(entry.name))
+          continue;
+        const directory = join6(base, entry.name);
+        try {
+          const history = await stat3(join6(directory, "events.jsonl")).catch((error) => {
+            if (error.code !== "ENOENT")
+              throw error;
+            return null;
+          });
+          if (!history?.size)
+            continue;
+          const journal = await RunJournal.openExisting(directory, this.clock);
+          try {
+            const state = journal.state;
+            const run = state.metadata;
+            if (!run || run.id !== entry.name || run.namespace !== namespace.name)
+              throw new Error("Workflow journal location is invalid.");
+            const row = { run, summary: summarize(run, state), seen: Date.parse(state.updatedAt), terminal: state.endedAt ? Date.parse(state.endedAt) : null, error: null };
+            await this.catalog.put(row);
+            this.rows.set(run.id, row);
+            this.unrecovered.delete(directory);
+          } finally {
+            await journal.close();
+          }
+        } catch (error) {
+          complete = false;
+          if (!this.unrecovered.has(directory))
+            console.error("Workflow discovery blocked:", directory, toCallError(error).message);
+          this.unrecovered.add(directory);
+        }
+      }
+    }
+    return complete;
+  }
+  async bytes(reserveId) {
+    const tree = async (path) => {
+      const entries = await readdir4(path, { withFileTypes: true }).catch((error) => {
+        if (error.code !== "ENOENT")
+          throw error;
+        return [];
+      });
+      let size = 0;
+      for (const entry of entries) {
+        const name = join6(path, entry.name);
+        if (entry.isDirectory())
+          size += await tree(name);
+        else
+          size += await stat3(name).then((info) => info.size, (error) => {
+            if (error.code !== "ENOENT")
+              throw error;
+            return 0;
+          });
+      }
+      return size;
+    };
+    let bytes = 0;
+    for (const row of this.rows.values()) {
+      const size = await tree(this.directory(row.run));
+      const reserved = openStatuses.has(row.summary.status) || row.summary.status === "blocked" || row.run.id === reserveId;
+      bytes += reserved ? Math.max(size, runReserve) : size;
+    }
+    return bytes;
+  }
+  async close() {
+    if (this.closing)
+      return;
+    this.closing = true;
+    this.timer?.();
+    this.timer = null;
+    const active2 = [...this.active.values()];
+    for (const value of active2)
+      value.worker.send({ type: "suspend" });
+    let timer;
+    try {
+      await Promise.race([Promise.all(active2.map((value) => value.worker.exited)), new Promise((resolve2) => {
+        timer = setTimeout(resolve2, 1000);
+      })]);
+    } finally {
+      if (timer)
+        clearTimeout(timer);
+    }
+    for (const value of active2)
+      if (value.worker.exitCode === null)
+        value.worker.kill("SIGKILL");
+    await Promise.all(active2.map((value) => value.worker.exited));
+    await this.queue;
+    await this.catalog.close();
+  }
+}
+async function stderrTail(stream) {
+  const decoder = new TextDecoder;
+  let tail = "";
+  for await (const chunk of stream)
+    tail = (tail + decoder.decode(chunk, { stream: true })).slice(-4000);
+  return (tail + decoder.decode()).slice(-4000);
+}
+
+// src/workflow/testing.ts
+async function testWorkflowRuntime(directory, options = {}) {
+  const dataDir = await mkdtemp(join7(tmpdir(), "repogo-workflow-test-"));
+  let runtime;
+  const host = async (_plugin, method, params) => {
+    if (!options.host)
+      throw new MethodError("FORBIDDEN", `This test does not serve ${method}.`);
+    return options.host(method, params);
+  };
+  const service = await WorkflowService.open(dataDir, {
+    host,
+    invalidate: () => {},
+    notify: () => {},
+    logs: () => {}
+  });
+  try {
+    runtime = await Runtime.open({ dataDir, root: resolve2(options.root ?? directory), host, workflows: (request) => service.request(request) });
+    await runtime.loadDir(resolve2(directory));
+    service.start();
+    return {
+      call: async (method, input = {}, call = {}) => (await runtime.call(method, input, call)).result,
+      manifest: () => runtime.manifest(),
+      wait: (method, id, timeout = 1e4) => new Promise((resolve3, reject) => {
+        const finish = () => {
+          clearTimeout(timer);
+          remove();
+          runtime.call(`${method}.get`, { id }).then((value) => resolve3(value.result), reject);
+        };
+        const remove = service.observe((summary) => {
+          if (summary.id === id && (terminalStatuses.has(summary.status) || summary.status === "blocked"))
+            finish();
+        });
+        const timer = setTimeout(() => {
+          remove();
+          reject(new Error(`Workflow ${id} did not finish within ${timeout}ms.`));
+        }, timeout);
+        runtime.call(`${method}.get`, { id }).then((value) => {
+          const summary = value.result;
+          if (terminalStatuses.has(summary.status) || summary.status === "blocked")
+            finish();
+        }, (error) => {
+          clearTimeout(timer);
+          remove();
+          reject(error);
+        });
+      }),
+      close: async () => {
+        await service.close();
+        runtime.close();
+        await rm4(dataDir, { recursive: true, force: true });
+      }
+    };
+  } catch (error) {
+    await service.close();
+    runtime?.close();
+    await rm4(dataDir, { recursive: true, force: true });
+    throw error;
+  }
+}
+
+// src/testing.ts
+async function testRuntime(plugins, options = {}) {
+  const dataDir = await mkdtemp2(join8(tmpdir2(), "repogo-plugin-test-"));
+  const project = join8(dataDir, "project");
+  await mkdir6(project);
+  const host = options.mcp || options.host ? testHost(options.mcp, options.host) : undefined;
+  const runtime = await Runtime.open({ dataDir: join8(dataDir, "data"), root: options.root ?? project, host });
+  const notices = [];
+  runtime.onNotify((notice) => notices.push(notice));
+  const logs = [];
+  captureConsole((entry) => logs.push(entry), { passThrough: true });
+  try {
+    for (const [name, plugin] of Object.entries(plugins))
+      await runtime.add(name, plugin);
+  } catch (error) {
+    releaseConsole();
+    runtime.close();
+    await rm5(dataDir, { recursive: true, force: true });
+    throw error;
+  }
+  return {
+    call: async (method, input = {}, call = {}) => (await runtime.call(method, input, call)).result,
+    setCrons: (crons) => runtime.setCrons(crons),
+    tickCrons: async (now) => {
+      await Promise.all(runtime.tickCrons(now));
+    },
+    manifest: () => runtime.manifest(),
+    notices,
+    logs,
+    close: async () => {
+      releaseConsole();
+      runtime.close();
+      await rm5(dataDir, { recursive: true, force: true });
+    }
+  };
+}
+function testHost(mcp, host) {
+  return async (_plugin, method, params) => {
+    if (method !== "mcp.call") {
+      if (!host)
+        throw new MethodError("FORBIDDEN", `This test runtime doesn't serve ${method}.`);
+      return host(method, params);
+    }
+    if (!mcp)
+      throw new MethodError("FORBIDDEN", "This test runtime has no MCP servers.");
+    try {
+      return { result: await mcp(params) };
+    } catch (error) {
+      return { error: { code: "TOOL_ERROR", message: error instanceof Error ? error.message : String(error) } };
+    }
+  };
+}
+export {
+  testWorkflowRuntime,
+  testRuntime
+};