@repogo/plugins 0.1.33 → 0.1.35

package/dist/testing.js

@@ -0,0 +1,1979 @@
+// @bun
+import {
+  MethodError,
+  toCallError
+} from "./index-83w1fk10.js";
+
+// src/testing.ts
+import { mkdir as mkdir4, mkdtemp, rm as rm3 } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join4 } 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 z2 } 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 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/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 journal_mode = wal");
+    await sql.unsafe("pragma busy_timeout = 5000");
+    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/duration.ts
+var unitMs = { s: 1000, m: 60000, h: 3600000, d: 86400000 };
+function parseDuration(duration) {
+  if (typeof duration === "number") {
+    if (!Number.isFinite(duration) || duration <= 0)
+      throw new Error(`a duration is a positive number of ms: ${duration}`);
+    return duration;
+  }
+  const match = /^(\d+(?:\.\d+)?)([smhd])$/.exec(duration);
+  if (!match)
+    throw new Error(`a duration is like "30s", "5m", "1h" or "7d": ${duration}`);
+  const ms = Number(match[1]) * unitMs[match[2]];
+  if (ms <= 0)
+    throw new Error(`a duration is longer than zero: ${duration}`);
+  return ms;
+}
+
+// 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/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;
+  events = new EventBus;
+  methods = new Map;
+  plugins = new Map;
+  crons = [];
+  databases = new Map;
+  stores = new Map;
+  invalidationListeners = new Set;
+  noticeListeners = new Set;
+  pluginsDir = null;
+  constructor(dataDir, root, host) {
+    this.dataDir = dataDir;
+    this.root = root;
+    this.host = host;
+  }
+  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);
+  }
+  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 hasData = 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 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 (!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) => {
+        const sent = { ...notice, plugin: name, root: runtime.callRoot.getStore() ?? runtime.root };
+        for (const listener of runtime.noticeListeners)
+          listener(sent);
+      },
+      agent: (prompt, options2) => this.agent(name, ctx, prompt, options2 ?? {}),
+      log: (...args) => console.log(...args)
+    };
+    for (const [methodName, method] of Object.entries(plugin.methods ?? {})) {
+      this.register({
+        name: `${name}.${methodName}`,
+        plugin: name,
+        kind: method.kind,
+        description: method.description,
+        confirm: method.confirm,
+        input: method.input,
+        output: method.output,
+        run: async (input) => method.run(input, ctx)
+      });
+    }
+    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 call(name, input = {}, options = {}) {
+    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)
+      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) {
+    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,
+        input: z2.toJSONSchema(method.input, { io: "input", unrepresentable: "any" }),
+        output: method.output ? z2.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 store(plugin, kind, name, schema, make, extra) {
+    const signature = JSON.stringify([z2.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 = z2.object({ id: z2.string() });
+    const record2 = schema.extend({ id: z2.string(), createdAt: z2.string(), updatedAt: z2.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", z2.object({
+      limit: z2.number().int().positive().max(500).optional(),
+      offset: z2.number().int().min(0).optional(),
+      orderBy: z2.string().optional(),
+      order: z2.enum(["asc", "desc"]).optional()
+    }), z2.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, z2.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 isAsyncIterable(value) {
+  return typeof value?.[Symbol.asyncIterator] === "function";
+}
+
+// src/testing.ts
+async function testRuntime(plugins, options = {}) {
+  const dataDir = await mkdtemp(join4(tmpdir(), "repogo-plugin-test-"));
+  const project = join4(dataDir, "project");
+  await mkdir4(project);
+  const host = options.mcp || options.host ? testHost(options.mcp, options.host) : undefined;
+  const runtime = await Runtime.open({ dataDir: join4(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 rm3(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 rm3(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 {
+  testRuntime
+};